def auto_detect_serial(self): import glob glist = glob.glob('/dev/ttyACM*') + glob.glob('/dev/ttyUSB*') + glob.glob('/dev/cu.usbmodem*') self.auto_detected = False for port in glist: print "trying", port ble = None ble = bglib.BGLib() ble.package_mode = self.packet_mode ble.ble_rsp_system_address_get += self.address_response ser = serial.Serial(port, self.baud_rate, timeout=1) ser.flushInput() ser.flushOutput() ble.send_command(ser, ble.ble_cmd_system_address_get()) time.sleep(0.1) try: ble.check_activity(ser, 1) except: pass if self.auto_detected: self.port = port self.ser = ser self.ble = ble print "Using serial:", port return else: ser.close() raise Exception("Serial port not found")
def start_benchmark(self): ''' start benchmark ''' import bglib self.bg = bglib.BGLib() import serial print self.port_name self.ser = serial.Serial(port=self.port_name, baudrate=38400, timeout=1) self.register_handlers() self.setup() self.process_state = PROCESS_STATE_RUNNING for step in self.steps: self.set(step) self.logger.info('Starting next Step') self.run() t0 = current_milli_time() print "step time " + str(step.time) print "t0 " + str(t0) while current_milli_time( ) - t0 < step.time and self.process_state == PROCESS_STATE_RUNNING: # catch all incoming data self.bg.check_activity(self.ser) # don't burden the CPU time.sleep(0.001) # if for some reason, we end up in standby, benchmark fails if self.ble_state == BLE_STATE_STANDBY: raise Exception("We are in standby, but we should not be!") t1 = current_milli_time() print "t1 " + str(t1) print "diff " + str(t1 - t0) self.standby() self.stop() # close serial connection after benchmark
def main(devpath): port = devpath baud = 115200 packet_mode = False ble = bglib.BGLib() ble.packet_mode = packet_mode ble.ble_rsp_system_address_get += ble_cb ser = serial.Serial(port=port, baudrate=baud, timeout=1) ser.flushInput() ser.flushOutput() ble.send_command(ser, ble.ble_cmd_system_address_get()) ble.check_activity(ser, 1)
def start(self, port = None): if port is None: self.auto_detect_serial() else: self.ble = bglib.BGLib() self.ble.packet_mode = self.packet_mode self.ble.ble_rsp_system_address_get += self.address_response ble = self.ble ble.on_timeout += self.on_timeout ble.ble_evt_gap_scan_response += self.handle_scan_response self.ser = serial.Serial(port=self.port, baudrate=self.baud_rate, timeout=1) self.ser.flushInput() self.ser.flushOutput() ser = self.ser # disconnect if we are connected already self.send_command(ble.ble_cmd_connection_disconnect(0)) ble.check_activity(ser, 1) # stop advertising if we are advertising already self.send_command(ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser, 1) # stop scanning if we are scanning already self.send_command(ble.ble_cmd_gap_end_procedure()) ble.check_activity(ser, 1) # set scan parameters self.send_command(ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) ble.check_activity(ser, 1) # start scanning now self.send_command(ble.ble_cmd_gap_discover(2)) ble.check_activity(ser, 1) # IO port stuff for LED; doesn't work currently self.send_command(ble.ble_cmd_hardware_io_port_config_pull(0, 0, 0)) self.send_command(ble.ble_cmd_hardware_io_port_config_direction(0, 1)) self.send_command(ble.ble_cmd_hardware_io_port_config_function(0, 0)) self.send_command(ble.ble_cmd_hardware_io_port_write(0, 1, 0)) # handle connections self.ble.ble_evt_connection_status += self.handle_connection_status self.ble.ble_evt_connection_disconnected += self.handle_connection_disconnected # handle service info self.ble.ble_evt_attclient_group_found += self.handle_attclient_group_found # get local address ble.send_command(ser, ble.ble_cmd_system_address_get()) ble.check_activity(ser, 1) print "local device:", self.address self.ble.ble_evt_attclient_procedure_completed += self.handle_attclient_procedure_completed self.ble.ble_evt_attclient_find_information_found += self.handle_attclient_information_found self.ble.ble_evt_attclient_attribute_value += self.handle_attclient_attribute_value self.ble.ble_evt_attclient_read_multiple_response += self.handle_attclient_read_multiple_response
def main(): # NOTE: CHANGE THESE TO FIT YOUR TEST SYSTEM port_name = "com5" baud_rate = 38400 packet_mode = True # create BGLib object ble = bglib.BGLib() ble.packet_mode = packet_mode # add handler for BGAPI timeout condition (hopefully won't happen) ble.on_timeout += my_timeout # add handler for the gap_scan_response event ble.ble_evt_gap_scan_response += my_ble_evt_gap_scan_response # create serial port object and flush buffers ser = serial.Serial(port=port_name, baudrate=baud_rate, timeout=1) ser.flushInput() ser.flushOutput() # disconnect if we are connected already ble.send_command(ser, ble.ble_cmd_connection_disconnect(0)) ble.check_activity(ser, 1) # stop advertising if we are advertising already ble.send_command(ser, ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser, 1) # stop scanning if we are scanning already ble.send_command(ser, ble.ble_cmd_gap_end_procedure()) ble.check_activity(ser, 1) # set scan parameters ble.send_command(ser, ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) ble.check_activity(ser, 1) # start scanning now ble.send_command(ser, ble.ble_cmd_gap_discover(1)) ble.check_activity(ser, 1) while (1): # check for all incoming data (no timeout, non-blocking) ble.check_activity(ser) # don't burden the CPU time.sleep(0.01)
def ble_start(port_num, baud_rate=11520, debug=False): global ble, ser, txtwin, statwin option_port = port_num option_baud = baud_rate option_packet = False option_debug = debug # create and setup BGLib object statwin.write("Status: USB Dongle Initializing...") ble = bglib.BGLib() ble.packet_mode = option_packet ble.debug = option_debug # add handler for BGAPI timeout condition (hopefully won't happen) ble.on_timeout += my_timeout # add handlers for BGAPI events ble.ble_evt_gap_scan_response += my_ble_evt_gap_scan_response ble.ble_evt_connection_status += my_ble_evt_connection_status ble.ble_evt_connection_disconnected += my_ble_evt_connection_disconnected # create serial port object ser = serial.Serial(port=option_port, baudrate=option_baud, timeout=1, writeTimeout=1) # flush buffers ser.flushInput() ser.flushOutput() statwin.write("Status: USB Dongle Initialization Completed") # disconnect if we are connected already statwin.write("Status: Disconnecting...") for i in range(9): ble.send_command(ser, ble.ble_cmd_connection_disconnect(i)) ble.check_activity(ser, 1) #enable buttons button_start.config(state="disabled", background="green") button_scan.config(state="normal") button_connect.config(state="disabled")
def __init__(self, port, one_meter_rssi, n): self.one_meter_rssi = one_meter_rssi self.n = n self.port_name = port self.baud_rate = 115200 ble = bglib.BGLib() ble.packet_mode = False #setup our serial port ser = serial.Serial(port=self.port_name, baudrate=self.baud_rate, timeout=1) ser.flushInput() ser.flushOutput() #add our bluetooth events ble.on_timeout += self.timeout ble.ble_evt_gap_scan_response += self.ble_evt_gap_scan_response # disconnect if we are connected already ble.send_command(ser, ble.ble_cmd_connection_disconnect(0)) ble.check_activity(ser, 1) # stop advertising if we are advertising already ble.send_command(ser, ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser, 1) # stop scanning if we are scanning already ble.send_command(ser, ble.ble_cmd_gap_end_procedure()) ble.check_activity(ser, 1) # set scan parameters ble.send_command(ser, ble.ble_cmd_gap_set_scan_parameters(0x0400, 0x0400, 0)) ble.check_activity(ser, 1) # start scanning now ble.send_command(ser, ble.ble_cmd_gap_discover(1)) ble.check_activity(ser, 1) while True: # check for all incoming data (no timeout, non-blocking) ble.check_activity(ser) # don't burden the CPU time.sleep(0.1)
def main(): global ble, ser # create option parser p = optparse.OptionParser(description='BGLib Demo: Health Thermometer Collector v' + __version__) # set defaults for options p.set_defaults(port="/dev/ttyACM0", baud=115200, packet=False, debug=False) # create serial port options argument group group = optparse.OptionGroup(p, "Connection Options") group.add_option('--port', '-p', type="string", help="Serial port device name (default /dev/ttyACM0)", metavar="PORT") group.add_option('--baud', '-b', type="int", help="Serial port baud rate (default 115200)", metavar="BAUD") group.add_option('--packet', '-k', action="store_true", help="Packet mode (prefix API packets with <length> byte)") group.add_option('--debug', '-d', action="store_true", help="Debug mode (show raw RX/TX API packets)") p.add_option_group(group) # actually parse all of the arguments options, arguments = p.parse_args() # create and setup BGLib object ble = bglib.BGLib() ble.packet_mode = options.packet ble.debug = options.debug # add handler for BGAPI timeout condition (hopefully won't happen) ble.on_timeout += my_timeout # add handlers for BGAPI events ble.ble_evt_gap_scan_response += my_ble_evt_gap_scan_response ble.ble_evt_connection_status += my_ble_evt_connection_status ble.ble_evt_attclient_group_found += my_ble_evt_attclient_group_found ble.ble_evt_attclient_find_information_found += my_ble_evt_attclient_find_information_found ble.ble_evt_attclient_procedure_completed += my_ble_evt_attclient_procedure_completed ble.ble_evt_attclient_attribute_value += my_ble_evt_attclient_attribute_value # create serial port object try: ser = serial.Serial(port=options.port, baudrate=options.baud, timeout=1, writeTimeout=1) except serial.SerialException as e: print "\n================================================================" print "Port error (name='%s', baud='%ld'): %s" % (options.port, options.baud, e) print "================================================================" exit(2) # flush buffers ser.flushInput() ser.flushOutput() # disconnect if we are connected already ble.send_command(ser, ble.ble_cmd_connection_disconnect(0)) ble.check_activity(ser, 1) # stop advertising if we are advertising already ble.send_command(ser, ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser, 1) # stop scanning if we are scanning already ble.send_command(ser, ble.ble_cmd_gap_end_procedure()) ble.check_activity(ser, 1) # set scan parameters ble.send_command(ser, ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) ble.check_activity(ser, 1) # start scanning now print "Scanning for BLE peripherals..." ble.send_command(ser, ble.ble_cmd_gap_discover(1)) ble.check_activity(ser, 1) while (1): # check for all incoming data (no timeout, non-blocking) ble.check_activity(ser) # don't burden the CPU time.sleep(0.01)
import bglib import serial import time from UUID import * # This module is designed to be used like a singleton class # It wraps the functions of bglib in an easier to use way ser = 0 ble = bglib.BGLib() ble.packet_mode = False ble.debug = False #global definitions uuid_service = [0x28, 0x00] # 0x2800 #UTILITY CLASSES class Characteristic(object): def __init__(self, parent, handle, uuid): """ :param parent: a Peripheral instance :param args: args returned by ble_evt_attclient_find_information_found :return: """ self.p = parent self.handle = handle self.uuid = uuid self.byte_value = [] self.notify_cb = None
def __init__(self, payload_pipe, dev='/dev/bluegiga', debug=False): self._lock = Lock() self.logr = LagerLogger("") self.logr.console(LagerLogger.DEBUG) self._attributes_status = 0 self._ble = bglib.BGLib() self._ble.packet_mode = False self._connected_addr = None self._conn_handle = None self._notified_handle = None self.adv_data = list( ADV_DATA) # clones list, initially set to be hidden # SHOULD BE STATELESS, WHAT IS THIS??????????? # Used to retrieve: # (for writing) # - The total payload size, we need this at the low-level because the # client requests this before every payload transfer. # - The last batch sent. We need this because we need to resend missed # packets, but we have no knowledge of the payload. # # (for receiving) # - sends the received messages self._payload_pipe = payload_pipe # SHOULD BE STATELESS, WHAT IS THIS??????????? # Used to signal when the (bga server -> client) client signals the # entire batch was received successfully. self._is_batch_transfer_complete = False self._reading_batch = False self._batch_builder = None self._ser = serial.Serial(port=dev, baudrate=115200, timeout=1) self._ser.flushInput() self._ser.flushOutput() self._on_connect_cbs = [] self._on_transfer_cbs = [] self._on_receive_batch_cbs = [] self._on_disconnect_cbs = [] #self._ble.ble_evt_attributes_user_read_request += self._read_cb #self._ble.ble_evt_attributes_value += self._write_cb #self._ble.ble_evt_attributes_status += self._attributes_status_cb #self._ble.ble_evt_connection_disconnected += self._disconnect_cb #self._ble.ble_evt_connection_status += self._conn_interval_cb self._ble.ble_evt_attributes_user_read_request += lambda x, y: threaderized( self._read_cb, x, y) self._ble.ble_evt_attributes_value += lambda x, y: threaderized( self._write_cb, x, y) self._ble.ble_evt_attributes_status += lambda x, y: threaderized( self._attributes_status_cb, x, y) self._ble.ble_evt_connection_disconnected += lambda x, y: threaderized( self._disconnect_cb, x, y) self._ble.ble_evt_connection_status += lambda x, y: threaderized( self._conn_interval_cb, x, y) # if debug == True: # self._setup_debug_callbacks() self.stop() self._start_advertising()
def main(): global tag_data # welcome message print "[Tag Scanner]" # Switch to API Mode time.sleep(1) ser_xbee.write("+++") # enter command mode time.sleep(1) if (ser_xbee.read(3) == "OK\r"): ser_xbee.write("ATAP 1\r") # switch to API mode ser_xbee.write("ATAC\r") # apply settings ser_xbee.write("ATCN\r") # exit command mode # Configure Xbee xbee.at(command="CE", parameter="0") # router mode xbee.at(command="ID", parameter=XBEE_MESH_ID) # mesh id xbee.at(command="CH", parameter=XBEE_MESH_CH) # mesh channel xbee.at(command="DH", parameter=XBEE_MESH_DH) # mesh id xbee.at(command="DL", parameter=XBEE_MESH_DL) # mesh channel xbee.at(command="AC") # apply # create BGLib object ble = bglib.BGLib() ble.packet_mode = False # add handler for BGAPI timeout condition ble.on_timeout += ble_parser_timeout # add handler for gap_scan_response event ble.ble_evt_gap_scan_response += ble_evt_gap_scan_response # flush serial buffers ser_ble.flushInput() ser_ble.flushOutput() # disconnect if connected already ble.send_command(ser_ble, ble.ble_cmd_connection_disconnect(0)) ble.check_activity(ser_ble, 1) # stop advertising if advertising already ble.send_command(ser_ble, ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser_ble, 1) # set scan parameters (scan_interval, scan_window, active) ble.send_command(ser_ble, ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) ble.check_activity(ser_ble, 1) # start scanning now (mode) ble.send_command(ser_ble, ble.ble_cmd_gap_discover(1)) ble.check_activity(ser_ble, 1) while (1): # check for all incoming data (no timeout, non-blocking) ble.check_activity(ser_ble) if (len(tag_data) > 30): print "Sending data..." packet_send(packb(create_packet())) tag_data = [] time.sleep(0.01)
def main_loop(self): # create and setup BGLib object self.ble = bglib.BGLib() self.ble.packet_mode = False self.ble.debug = False # add handler for BGAPI timeout condition (hopefully won't happen) self.ble.on_timeout += self.my_timeout # add handlers for BGAPI events self.ble.ble_evt_gap_scan_response += self.my_ble_evt_gap_scan_response self.ble.ble_evt_connection_status += self.my_ble_evt_connection_status self.ble.ble_evt_attclient_group_found += self.my_ble_evt_attclient_group_found self.ble.ble_evt_attclient_find_information_found += self.my_ble_evt_attclient_find_information_found self.ble.ble_evt_attclient_procedure_completed += self.my_ble_evt_attclient_procedure_completed self.ble.ble_evt_attclient_attribute_value += self.my_ble_evt_attclient_attribute_value self.ble.ble_evt_connection_disconnected += self.my_ble_evt_connection_disconnected # flush buffers self.ser.flushInput() self.ser.flushOutput() # print address self.ble.send_command(self.ser, self.ble.ble_cmd_system_address_get()) self.ble.check_activity(self.ser, 1) # disconnect if we are connected already self.ble.send_command(self.ser, self.ble.ble_cmd_connection_disconnect(0)) self.ble.check_activity(self.ser, 1) # stop advertising if we are advertising already self.ble.send_command(self.ser, self.ble.ble_cmd_gap_set_mode(0, 0)) self.ble.check_activity(self.ser, 1) # stop scanning if we are scanning already self.ble.send_command(self.ser, self.ble.ble_cmd_gap_end_procedure()) self.ble.check_activity(self.ser, 1) # set scan parameters self.ble.send_command( self.ser, self.ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) self.ble.check_activity(self.ser, 1) # start scanning now self.dprint("Scanning for DigiCue Blue") self.ble.send_command(self.ser, self.ble.ble_cmd_gap_discover(1)) self.ble.check_activity(self.ser, 1) init_byte_sent = False while (self.disconnected == 0): # check for all incoming data (no timeout, non-blocking) self.ble.check_activity(self.ser) # don't burden the CPU time.sleep(0.01) if self.crp_link_ready and not self.pending_write: if not self.init_sent and self.dcb.pendACONF0 is not None: # send configuration data (16 bytes) self.init_sent = True configuration_data = [ self.dcb.pendACONF0, self.dcb.pendACONF1, self.dcb.pendACONF2, self.dcb.pendACONF3 ] chksum = 0 for i in configuration_data: chksum += i chksum &= 0xff configuration_data.append(chksum) self.dprint("Connected") self.ble.send_command( self.ser, self.ble.ble_cmd_attclient_attribute_write( self.connection_handle, self.att_handle_data, configuration_data)) self.pending_write = True
def main(): print "Entered main" global ble, ser, ppg_arr, livedata, num_data_points, timeoflastmessage, timesavg, socket, packnum, alldata, alldataclocked packnum = 0 timetorun = 600 # Time to gather data in seconds # create option parser p = optparse.OptionParser(description='BGLib Demo: Heart Rate Collector v' + __version__) # set defaults for options p.set_defaults(port=bluegiga_com_port, baud=9600, packet=False, debug=False) # create serial port options argument group group = optparse.OptionGroup(p, "Connection Options") group.add_option('--port', '-p', type="string", help="Serial port device name (default /dev/ttyACM0)", metavar="PORT") group.add_option('--baud', '-b', type="int", help="Serial port baud rate (default 115200)", metavar="BAUD") group.add_option('--packet', '-k', action="store_true", help="Packet mode (prefix API packets with <length> byte)") group.add_option('--debug', '-d', action="store_true", help="Debug mode (show raw RX/TX API packets)") p.add_option_group(group) # actually parse all of the arguments options, arguments = p.parse_args() # create and setup BGLib object ble = bglib.BGLib() ble.packet_mode = options.packet ble.debug = options.debug # add handler for BGAPI timeout condition (hopefully won't happen) ble.on_timeout += my_timeout # add handlers for BGAPI events ble.ble_evt_gap_scan_response += my_ble_evt_gap_scan_response ble.ble_evt_connection_status += my_ble_evt_connection_status ble.ble_evt_attclient_group_found += my_ble_evt_attclient_group_found ble.ble_evt_attclient_find_information_found += my_ble_evt_attclient_find_information_found ble.ble_evt_attclient_procedure_completed += my_ble_evt_attclient_procedure_completed ble.ble_evt_attclient_attribute_value += my_ble_evt_attclient_attribute_value # create serial port object try: print "Opening serial port" ser = serial.Serial(port=options.port, baudrate=options.baud, timeout=1, writeTimeout=1) except serial.SerialException as e: print "\n================================================================" print "Port error (name='%s', baud='%ld'): %s" % (options.port, options.baud, e) print "================================================================" #exit(2) print "Closing serial port" ser.close() time.sleep(1) return # flush buffers ser.flushInput() ser.flushOutput() print "1" # disconnect if we are connected already ble.send_command(ser, ble.ble_cmd_connection_disconnect(0)) print "1.5" try: ble.check_activity(ser, 1) except: "what?" print "2" # stop advertising if we are advertising already ble.send_command(ser, ble.ble_cmd_gap_set_mode(0, 0)) ble.check_activity(ser, 1) print "3" # stop scanning if we are scanning already ble.send_command(ser, ble.ble_cmd_gap_end_procedure()) try: print "4" ble.check_activity(ser, 1) except Exception as e: print "Bluetooth error:", e ser.close() time.sleep() return print "5" # set scan parameters ble.send_command(ser, ble.ble_cmd_gap_set_scan_parameters(0xC8, 0xC8, 1)) ble.check_activity(ser, 1) # start scanning now print "Scanning for BLE peripherals..." ble.send_command(ser, ble.ble_cmd_gap_discover(1)) ble.check_activity(ser, 1) timeoflastmessage = time.time() timesavg = [] for x in range(5): timesavg.append(0) # ZeroMQ Context context = zmq.Context() # Define the socket using the "Context" socket = context.socket(zmq.REQ) socket.connect("tcp://127.0.0.1:5678") # socket = context.socket(zmq.PUB) # socket.bind("tcp://*:5556") socket.RCVTIMEO = 3000 alldata = [] alldataclocked = [] starttime = time.time() print "Starting!" while ((time.time() - starttime) <= timetorun): # check for all incoming data (no timeout, non-blocking) try: ble.check_activity(ser) except Exception as e: print "(A) Encountered error:",e try: ble.send_command(ser, ble.ble_cmd_connection_disconnect(0)) except: pass time.sleep(1) ser.close() time.sleep(1) return endtime = time.time() starttimeformated = time.strftime('%m-%d-%Y_%H %M %S', time.localtime(starttime)) filename = time.strftime('%m-%d-%Y_%H %M %S', time.localtime(time.time())) num_samples = len(alldata) f = open(filename + ".txt", 'wb') f.write("Python script, testing gathering of data.\nTest started at: " + starttimeformated + ", test concluded at: " + filename + ", for a total of " + str(timetorun) + " seconds.\n") f.write("Number of samples collected: " + str(num_samples) + "\nAverage hz: " + str((float(num_samples)/float(timetorun))) + "\n") f.write("\nData:\n\n") for data in alldata: f.write(str(data) + "\n")
def __init__(self, port=None, baud_rate=115200, mac_addrs=None): if not port or not mac_addrs: raise ValueError('You need to have a port name adn a mac_addrs') self.port = port self.baud_rate = baud_rate self.board = bglib.BGLib() self.mac = mac_addrs self.board.debug = False self.state = STATE_STANDBY self.connected = False self.disconnecting = False self.received_found = False self.zero_packet = False self.last_values = np.array([0, 0, 0, 0]) # create serial port object try: self.ser = Serial(port=self.port, baudrate=self.baud_rate, timeout=1, writeTimeout=1) except serial.SerialException as e: print "\n================================================================" print "Port error (name='%s', baud='%ld'): %s" % (self.port, self.baud_rate, e) print "================================================================" exit(2) # BGAPI Events responses def my_ble_evt_gap_scan_response(sender, args): uuid_gang_service = [0xfe, 0x84] # pull all advertised service info from ad packet ad_services = [] this_field = [] bytes_left = 0 for b in args['data']: if bytes_left == 0: bytes_left = b this_field = [] else: this_field.append(b) bytes_left = bytes_left - 1 if bytes_left == 0: if this_field[0] == 0x02 or this_field[0] == 0x03: # partial or complete list of 16-bit UUIDs for i in xrange((len(this_field) - 1) / 2): ad_services.append(this_field[-1 - i*2 : -3 - i*2 : -1]) if this_field[0] == 0x04 or this_field[0] == 0x05: # partial or complete list of 32-bit UUIDs for i in xrange((len(this_field) - 1) / 4): ad_services.append(this_field[-1 - i*4 : -5 - i*4 : -1]) if this_field[0] == 0x06 or this_field[0] == 0x07: # partial or complete list of 128-bit UUIDs for i in xrange((len(this_field) - 1) / 16): ad_services.append(this_field[-1 - i*16 : -17 - i*16 : -1]) # connect to Ganglion based on MAC address if not self.connected and ''.join(['%02X' % b for b in args["sender"][::-1]]) == self.mac: self.board.send_command(self.ser, self.board.ble_cmd_gap_connect_direct(args['sender'], args['address_type'], 0x20, 0x30, 0x100, 0)) self.board.check_activity(self.ser, 1) self.state = STATE_CONNECTING # connection_status handler def my_ble_evt_connection_status(sender, args): if (args['flags'] & 0x05) == 0x05: # connected, now perform characteristic discovery print "Connected to %s" % ':'.join(['%02X' % b for b in args['address'][::-1]]) self.connection_handle = args['connection'] self.board.send_command(self.ser, self.board.ble_cmd_attclient_find_information(args['connection'], 0x0001, 0xFFFF)) self.board.check_activity(self.ser, 1) self.state = STATE_FINDING_ATTRIBUTES # attclient_group_found handler def ble_evt_attclient_find_information_found(sender, args): # check for OpenBCI characteristics if BLE_CHAR_RECEIVE.upper() == ''.join(['%02X' % b for b in args['uuid'][::-1]]): print('Receive characteristic found!') self.received_found = True self.receive_handle = args['chrhandle'] elif '2902' == ''.join(['%02X' % b for b in args['uuid'][::-1]]) and self.received_found: print('Receive ccc characteristic found!') self.receive_handle_ccc = args['chrhandle'] self.received_found = False elif BLE_CHAR_SEND.upper() == ''.join(['%02X' % b for b in args['uuid'][::-1]]): print('Send characteristic found!') self.send_handle = args['chrhandle'] elif BLE_CHAR_DISCONNECT.upper() == ''.join(['%02X' % b for b in args['uuid'][::-1]]): print('Disconnect characteristic found!') self.disconnect_handle = args['chrhandle'] self.connected = True # attclient_attribute_value handler def my_ble_evt_attclient_attribute_value(sender, args): # check for a new value from the connected peripheral's heart rate measurement attribute if args['connection'] == self.connection_handle and args['atthandle'] == self.receive_handle: self.save_to_csv(self.bytes2data(args['value'])) # add handlers for BGAPI events self.board.ble_evt_gap_scan_response += my_ble_evt_gap_scan_response self.board.ble_evt_connection_status += my_ble_evt_connection_status self.board.ble_evt_attclient_find_information_found += ble_evt_attclient_find_information_found self.board.ble_evt_attclient_attribute_value += my_ble_evt_attclient_attribute_value
def main(): global ble, ser # create option parser p = optparse.OptionParser(description='BGLib Demo: Health Thermometer \ Collector v' + __version__) # set defaults for options p.set_defaults(port="/dev/ttyACM0", baud=115200, packet=False, debug=False, rtscts=True) # create serial port options argument group group = optparse.OptionGroup(p, "Connection Options") group.add_option('--port', '-p', type="string", help="Serial port device name \ (default /dev/ttyACM0)", metavar="PORT") group.add_option('--baud', '-b', type="int", help="Serial port baud rate \ (default 115200)", metavar="BAUD") group.add_option('--debug', '-d', action="store_true", help="Debug mode \ (show raw RX/TX API packets)") group.add_option('--rtscts', '-r', type="int", help="RTS/CTS hw flow control \ enable=1/disable=0 (default enabled=1)") p.add_option_group(group) # actually parse all of the arguments options, arguments = p.parse_args() # create and setup BGLib object ble = bglib.BGLib() ble.packet_mode = options.packet ble.debug = options.debug # add handler for BGAPI timeout condition (hopefully won't happen) ble.on_timeout += my_timeout # add handlers for BGAPI events ble.gecko_evt_le_gap_scan_response += my_gecko_evt_le_gap_scan_response ble.gecko_evt_le_connection_opened += my_gecko_evt_le_connection_opened ble.gecko_evt_le_connection_closed += my_gecko_evt_le_connection_closed ble.gecko_evt_gatt_service += my_gecko_evt_gatt_service ble.gecko_evt_gatt_characteristic += my_gecko_evt_gatt_characteristic ble.gecko_evt_gatt_procedure_completed += my_gecko_evt_gatt_procedure_completed ble.gecko_evt_gatt_characteristic_value += my_gecko_evt_gatt_characteristic_value ble.gecko_evt_system_boot += my_gecko_evt_system_boot # create serial port object try: ser = serial.Serial(port=options.port, baudrate=options.baud, rtscts=options.rtscts, timeout=1, writeTimeout=1) except serial.SerialException as e: print( "\n================================================================" ) print("Port error (name='%s', baud='%ld'): %s" % (options.port, options.baud, e)) print( "================================================================") exit(2) # flush buffers ser.flushInput() ser.flushOutput() # Reboot NCP (will generate boot event) ble.send_command(ser, ble.gecko_cmd_system_reset(0)) ble.check_activity(ser, 1) # set discovery timing parameters ble.send_command(ser, ble.gecko_cmd_le_gap_set_discovery_timing(1, 0xC8, 0xC8)) ble.check_activity(ser, 1) # set discovery type parameters ble.send_command(ser, ble.gecko_cmd_le_gap_set_discovery_type(1, 1)) ble.check_activity(ser, 1) # start scanning now print("Scanning for BLE peripherals...") ble.send_command(ser, ble.gecko_cmd_le_gap_start_discovery(1, 1)) ble.check_activity(ser, 1) while (1): # check for all incoming data (no timeout, non-blocking) ble.check_activity(ser) # don't burden the CPU time.sleep(0.01)