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)
