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():