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
''' In this example we are saving the data to a csv file to be opened with Excel. ''' from gdx import gdx gdx = gdx.gdx() 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)
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()
import matplotlib.pyplot as plt 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() fig, ax = plt.subplots() # CHANGE TO MATCH YOUR EXPERIMENT time_between_readings_in_seconds = 0.5 number_of_readings = 20 digits_of_precision = 2 #gdx.open_usb() # Comment out if you are not using a USB connection. gdx.open_ble() # Uncomment if you wish to connect via Bluetooth. gdx.select_sensors( ) # You will be asked to select the sensors to be used. You can select up to three. #gdx.select_sensors([1]) # You can also use an argument to select sensors. Separate multiple sensors with a comma, ([1,3]) # This gets the name and units of the sensors selected. column_headers = gdx.enabled_sensor_info() # Store the number of sensors. This variable is used in plot_graph() and print_table() number_of_sensors = len(column_headers) # Use the columm_headers to create a list of the units for each sensor. # Use this list of units in the Collect loop below to add the units to the graph unit_list = [] units = '' for headers in column_headers: units = str(headers[headers.find('('):headers.find(')') + 1]) unit_list.append(units)
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()
# If there is an error trying to find the gdx module, uncomment this to see where # 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()
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. ''' import socket, pickle 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([2]) gdx.start(period=1000) for i in range(0, 1): measurements = gdx.read( ) #returns a list of measurements from the sensors selected. if measurements == None: break HOST = 'localhost' PORT = 50007 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((HOST, PORT)) s.listen(5) while True: conn, addr = s.accept() from_client = ''
pos_graph.height = 500 model_data=gcurve(color=color.red) actual_data=gcurve(color=color.blue) model_data.plot(0,0) actual_data.plot(0,0) model_data.delete() actual_data.delete() scene.autoscale = False gdx.open_usb() #gdx.open_ble() gdx.select_sensors([5]) #use the motion detector distance channel only. This is channel 5 ############################## # A record button is created. Use it to take live measurements from the Motion Detector ############################## 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
import roslib import sys import rospy from std_msgs.msg import Float32MultiArray, Bool # For Godirect libs. from gdx import gdx # define information of Veriner sensors sensor_name = 'GDX-RB 0K2002Z5' # change name with your device __name__ sensor_sampling_rate = 10 #unit = milliseconds gdx = gdx.gdx() gdx.open_ble(sensor_name) # 1: Force (N), 2: Respiration Rate (bpm), 4: Steps (steps), 5: Step Rate (spm) gdx.select_sensors([1, 2, 4, 5]) class veriner_resp_belt_reading(): ############################################################# # Subscriber Functions ############################################################# def sub_respiration_belt_state_callback(self, msg): #For a callback function self.sensor_status = msg.data #print(self.sensor_status) ############################################################# # Main Loop ############################################################# def __init__(self):
sys.path.append(gdx_module_path) # If there is an error trying to find the gdx module, uncomment this to see where # the program is looking to find the gdx folder #print(sys.path) from gdx import gdx gdx = gdx.gdx() import math gdx.open_usb() #gdx.open_ble() gdx.select_sensors([1,3,4]) # Hand Dynamometer sensors to use: 3 - y axis accel, 4 - z axis accel gdx.start(period=200) import turtle square = turtle.Turtle() square.shape("square") square.shapesize(5,20) #for i in range(0,100): a = True while a: measurements = gdx.read() if measurements == None: break force = measurements[0]/5
CLIportP = {} DataportP = {} CLIportD = {} DataportD = {} CLIportD, DataportD, CLIportP, DataportP = serialConfig(configFileName) # Get the configuration parameters from the configuration file configParameters = parseConfigFile(configFileName) # START QtAPPfor the plot app = QtGui.QApplication([]) ## Vernier gdx.open_usb() gdx.select_sensors([6]) gdx.start(period=20) column_header = gdx.enabled_sensor_info() ## Camera """ Available image formats are (depending on platform): - pylon.ImageFileFormat_Bmp (Windows) - pylon.ImageFileFormat_Tiff (Linux, Windows) - pylon.ImageFileFormat_Jpeg (Windows) - pylon.ImageFileFormat_Png (Linux, Windows) - pylon.ImageFileFormat_Raw (Windows) """ img = pylon.PylonImage() tlf = pylon.TlFactory.GetInstance()
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():