def Record(r):
model_data.delete() #clear the graph
actual_data.delete()
global time_at_max_stretch #these variables will be used to pass the info to the Model function
global index_at_max_stretch
global actual_list
global max_stretch
global dt
spring_stretch_actual = 0
max_stretch = 0
i=0
t = 0.0
dt = 0.05 #note gdx.start below where it sets the sampling period to 100ms (or 0.1 seconds)
time_at_max_stretch = 0
index_at_max_stretch = 0
actual_list = []
#gdx.start(period=50) #start data collection
gdx.start(period = (dt*1000))
while t < tmax + dt: #use the loop to read the data
measurements = gdx.read() #returns a list of measurements from the sensors selected.
if measurements == None:
break
print('distance (cm) = ', measurements[0]*100)
spring_stretch_actual = measurements[0]*100 - starting_spring_position
spring_actual.axis.y = -spring_equilibrium_length + spring_stretch_actual
mass_actual.pos.y = spring_actual.pos.y-spring_equilibrium_length + spring_stretch_actual
actual_data.plot(t,spring_stretch_actual)
actual_list.append(spring_stretch_actual) #create a list of all the measurements. Store in a variable to send to the Model function
if spring_stretch_actual>max_stretch: #Capture the biggest stretch. Store in variables to send to the Model function
max_stretch=spring_stretch_actual
time_at_max_stretch = t
index_at_max_stretch = i
t = t + dt
i = i + 1
gdx.stop()
def open_device():
log.info('attempting to connect over USB')
try:
gdx.open_usb()
except OSError as _:
gdx.devices = []
pass
if not gdx.devices:
log.info('attempting to connect over BLE')
try:
gdx.open_ble(config['device_id'])
except OSError as _:
return False
# select sensors for GDX-RB 0K1007T6 BLE -41
# 1: Force (N)
# 2: Respiration Rate (bpm)
# 4: Steps (steps)
# 5: Step Rate (spm)
gdx.select_sensors([1,2])
gdx.start(int(config['sampling_period_ms']))
return True
def __init__(self):
#############################################################
# Global Variables
#############################################################
#example: self.dx_1_read_position_data = 0
self.sensor_status = 0
#############################################################
# Publisher Parts
#############################################################
self.pub_respiration_belt_data = rospy.Publisher(
"respiration_belt/data", Float32MultiArray, queue_size=10)
#############################################################
# Subscriber Parts
#############################################################
# Set up your subscriber and define its callback
self.sub_h10_request_state = rospy.Subscriber(
"/respiration_belt/status", Bool,
self.sub_respiration_belt_state_callback)
#############################################################
# ROS main loop
#############################################################
r = rospy.Rate(sensor_sampling_rate) # 10hz
while not rospy.is_shutdown():
if self.sensor_status == True:
gdx.start(sensor_sampling_rate)
arr_resp_belt_data = gdx.read()
self.pub_respiration_belt_data.publish(
Float32MultiArray(data=arr_resp_belt_data))
else:
gdx.stop()
pass
r.sleep()
gdx.close()
rospy.spin() # Spin until ctrl + c
import csv
import os
#gdx.open_usb()
gdx.open_ble(
) # Comment this out if you decide to use the gdx.open_usb() function instead.
gdx.select_sensors()
with open('csvexample.csv', 'w', newline='') as my_data_file:
# The commented-out code below would be used if you want to hard-code in an absolute file path for the location of the csv file...
#with open('C:/full/path/to/your/documents/folder/csvexample2.csv', 'w', newline='') as my_data_file:
csv_writer = csv.writer(my_data_file)
gdx.start(period=200)
column_headers = gdx.enabled_sensor_info()
csv_writer.writerow(column_headers)
for i in range(0, 40):
measurements = gdx.read()
if measurements == None:
break
csv_writer.writerow(measurements)
print(measurements)
gdx.stop()
gdx.close()
# If you did not hard-code in an absolute path, this is where the file should be found.
print("location of current working directory = ", os.getcwd())
def simulation(q):
import time
from gdx import gdx #The gdx function calls are from a gdx.py file inside the gdx folder, which must be with this program.
gdx = gdx.gdx()
time_between_readings_in_seconds = 0.2
number_of_readings = 500
digits_of_precision = 2
gdx.open_usb()
gdx.select_sensors(
[1]
) # You will be asked to select the sensors to be used. You can select up to three.
sensor_times = []
sensor_readings = []
period_in_ms = time_between_readings_in_seconds * 1000
gdx.start(period_in_ms)
# Data Collection:
collection_complete = False
while not collection_complete:
try:
time = 0
print('Starting...')
for i in range(0, number_of_readings):
# This is where we are reading the list of measurements from the sensors.
measurements = gdx.read()
if measurements == None:
break
q.put([time, measurements[0]])
# Update the time variable with the new time for the next data point
time = time + time_between_readings_in_seconds
# The data collection loop is finished
collection_complete = True
print('Data collection complete.')
#stop sensor readings and disconnect device
gdx.stop()
gdx.close()
q.put('Q')
exit()
except KeyboardInterrupt:
collection_complete = True
gdx.stop() #Stop sensor readings
gdx.close() #Disconnect the device
print('data collection stopped by keypress')
print('Number of readings: ', i + 1)
q.put('Q')
exit()
column_headers_string = column_headers_string.replace("[", "")
column_headers_string = column_headers_string.replace("]", "")
# Variables to store the time and readings from the sensors
sensor_times = []
sensor_readings0 = []
sensor_readings1 = []
sensor_readings2 = []
print_table_string = []
plt.pause(1)
period_in_ms = time_between_readings_in_seconds * 1000
#Start data collection at the specified rate. The period argument is in milliseconds
gdx.start(period_in_ms)
# This graphing function will be used to set up the graph and may be used during data collection to give you
# a "live" graph. Note that plotting to the graph during data collection may slow the data collection loop.
def plot_graph():
# Customize the graph See Pyplot documentation
ax.plot(sensor_times, sensor_readings0, color='r',
label=column_headers[0]) #red line for sensor 1
# sensor_times and sensor_readings are variables storing the time and measurements from the data collection loop.
if (number_of_sensors > 1):
ax.plot(sensor_times,
sensor_readings1,
color='b',
the serial number) or "proximity_pairing", or leave it blank.
'''
from gdx import gdx
gdx = gdx.gdx()
gdx.open_ble(
"GDX-FOR 071000U9"
) #replace "GDX-FOR 071000U9" with the name of your device (order code, space, serial number)
device_info = gdx.device_info(
) # device_info list [0 = name, 1 = description, 2 = battery %, 3 = charger state, 4 = rssi]
battery_level = device_info[2]
charger_state = device_info[3]
print("battery level % = ", battery_level)
print("charger state = ", charger_state)
gdx.select_sensors([1, 2])
gdx.start(period=500)
column_headers = gdx.enabled_sensor_info()
print(column_headers)
for i in range(0, 5):
measurements = gdx.read()
if measurements == None:
break
print(measurements)
gdx.stop()
gdx.close()
import sys
import time
from gdx import gdx #the gdx function calls are from a gdx.py file inside the gdx folder.
gdx = gdx.gdx()
gdx.open_usb()
info = gdx.sensor_info()
chan = info[0][0]
gdx.select_sensors(
) #Auto-selects lowest channel available in connected device
gdx.start()
count = int(0)
num = int(100) #Number of measurements to take
sensNum = len(
gdx.getSensors()) #Get total number of sensors to test dictionary against
begin = time.time()
while count < num:
measurements = gdx.readValuesRetLatestDict(
) #returns a list of measurements from the sensors selected
for val in measurements:
if count < num: #Prevents printing out too many measurements, ie packet of 3 printing 100 measurements ends on 102
print(count + 1, "", val)
count += 1
end = time.time()
final = end - begin
print("")
print(final, "is total runtime")
gdx.stop()
gdx.close()
# the program is looking to find the gdx folder
#print(sys.path)
from gdx import gdx
from vpython import *
gdx = gdx.gdx()
import math
canvas(title='<b>Live Freebody Diagram<b>')
hanging_mass=float(input("Enter the mass (in kg) of the hanging mass:")) # prompts user for mass of hanging mass
gdx.open_ble('GDX-FOR 07200362') # change GDX-FOR ID to match your device
gdx.select_sensors([1,2,3,4]) # GDX-FOR sensors: 1 - force sensor, 2 - x axis accel, 3 - y axis accel, 4 - z axis accel
gdx.start(period=200) # data collection period of 200 ms, means a sampling rate of 5 samples/second
# create vpython objects for the ring and each force, as well as labels for the forces
obj = ring(axis=vector(0,0,1),radius=0.5,thickness=0.1,color=color.blue)
Pointer_hm = arrow (pos=vector(0,-1.1,0),axis=vector(0,-1,0),length=hanging_mass*9.8,color=color.red)
Label_hm = label(text='<i><b>F</i></b><sub>hanging mass</sub> = '+str(round(9.8*hanging_mass,2))+' N @ 270°',color=color.red,pos=Pointer_hm.pos,xoffset=10,yoffset=-10,box=False,line=False)
Pointer_gdx = arrow(color=color.green)
Label_gdx=label(text='<i><b>F</i></b><sub>GDX-FOR</sub>',color=color.green,pos=Pointer_gdx.pos,xoffset=50,yoffset=20,box=False,line=False)
Pointer_string = arrow(color=color.yellow)
Label_string=label(text='<i><b>F</i></b><sub>string</sub>',color=color.yellow,pos=Pointer_string.pos,xoffset=-50,yoffset=20,box=False,line=False)
# data collection loop, runs for 100 samples or 20 seconds (with a 200 ms period -> see line 27)
for i in range(0,100):
# get force and direction measurements from GDX-FOR
measurements = gdx.read()
if measurements == None:
'''
This examples is the same as gdx_getting_started_1.py, except we are now
passing arguments in the select_sensors() and start() functions to avoid the prompts.
This example assumes the Go Direct sensor is connected via USB. Go to the
gdx_getting_started_4.py example to see how to open a bluetooth connection.
Note that the select_sensors argument is a list and the sensor numbers must be inside
list brackets, e.g. gdx.select_sensors([1,2,3]).
How do you know what the sensor numbers are on your Go Direct device? Go to
gdx_getting_started.3.py example to list all of the sensor channels.
'''
from gdx import gdx #the gdx function calls are from a gdx.py file inside the gdx folder.
gdx = gdx.gdx()
gdx.open_usb()
gdx.select_sensors([1, 2])
gdx.start(period=1000)
for i in range(0, 500):
measurements = gdx.read(
) #returns a list of measurements from the sensors selected.
if measurements == None:
break
print(measurements)
gdx.stop()
gdx.close()
import sys
import time
from gdx import gdx #the gdx function calls are from a gdx.py file inside the gdx folder.
gdx = gdx.gdx()
gdx.open_usb()
gdx.select_sensors(
) #Auto-selects lowest channel available in connected device
gdx.start() #Start function that begins collection thread gdx.collectLoop()
count = int(0)
num = int(1000) #Number of measurements to take
keys = gdx.getSensors()
sensNum = len(keys) #Get total number of sensors to test dictionary against
begin = time.time()
while count < num:
gdx.readStoreDict() #API that doesn't return, just takes measurements.
for key in keys:
if (count < num): #For each key, print each individual entry per key
print(key)
measurements = gdx.valueReturner(key)
for val in measurements:
if count < num: #Prevents printing out too many measurements, ie packet of 3 printing 100 measurements ends on 102
print(count + 1, "", val)
count += 1
""" if(count < num): #For a single key, print all values
print(keys[0])
measurements = gdx.valueReturner(keys[0])
for val in measurements:
if count < num: #Prevents printing out too many measurements, ie packet of 3 printing 100 measurements ends on 102
from godirect import GoDirect
import matplotlib.pyplot as plt
import queue
import numpy as np
from matplotlib.animation import FuncAnimation
from gdx import gdx
sample_rate = 10
gdx = gdx.gdx()
gdx.open_usb()
gdx.select_sensors(sensors=gdx.devices[0].list_sensors())
gdx.start(period=1000 / sample_rate) # the unit is millisecond
data = queue.Queue()
# for i in range(0,40):
# measurements = gdx.read()
# if measurements == None:
# break
# print(data)
# data.put(measurements)
# animation script
fig, ax = plt.subplots()
plt.xlabel('Time (s)')
plt.ylabel('Force (N)')
xdata, ydata = [], []
ln, = plt.plot([], [], 'r-')
time = 0
def init():
