def __init__(self, SerialNumber): self.periph = None self.curr_val_char = None self.MacAddr = None self.SN = SerialNumber self.uuid = UUID("b42e2a68-ade7-11e4-89d3-123b93f75cba")
import binascii import struct import time from bluepy.btle import UUID, Peripheral temp_uuid = UUID(0x0001) p = Peripheral("CA:34:A7:E4:DF:50", "random") try: print("hello") ch = p.getCharacteristics(uuid=temp_uuid) #print(ch) for i in ch: print(i) if (i.supportsRead()): while 1: print("ayyyy") val = binascii.b2a_hex(ch.read()) val = binascii.unhexlify(val) val = struct.unpack('f', val)[0] print(str(val) + " ay") time.sleep(1) print("after") finally: p.disconnect()
for dev in devices: print "%d: Devices %s (%s), RSSI=%d db" % (n, dev.addr, dev.addrType, dev.rssi) n += 1 for (adtype, desc, value) in dev.getScanData(): print "%s = %s" % (desc, value) number = input('Enter your device number: ') print('Device', number) print(devices[number].addr) print "Connecting ..." dev = Peripheral(devices[number].addr, 'random') print "Services ..." for svc in dev.services: print str(svc) try: testService = dev.getServiceByUUID(UUID(0xfff0)) for ch in testService.getCharacteristics(): print str(ch) # ch = dev.getCharacteristics(uuid=UUID(0xfff1))[0] for ch in dev.getCharacteristics(uuid=UUID(0xfff1)): if (ch.supportsRead()): print str(ch.read()) else: print 'Not support read' finally: dev.disconnect()
import binascii import struct import time from bluepy.btle import UUID, Peripheral # Message constants MSG_LOCK = 0x10 MSG_UNLOCK = 0x11 MSG_STATE_REQ = 0x12 # Define read and write UUIDs read_uuid = UUID(0x2221) write_uuid = UUID(0x2222) # Create a connection to the RFduino #p = Peripheral("F9:D8:C2:B9:77:E9", "random") p = Peripheral("D4:2C:92:60:C2:D5", "random") try: # Create handles for read and write characteristics w_ch = p.getCharacteristics(uuid=write_uuid)[0] r_ch = p.getCharacteristics(uuid=read_uuid)[0] # Tell the Lockitron to lock msg = struct.pack('i', MSG_LOCK) print "Writing: " + str(msg) w_ch.write(msg) finally: p.disconnect()
import binascii import struct import time from bluepy.btle import UUID, Peripheral, DefaultDelegate from PyQt5 import QtWidgets, QtCore, QtGui from pyqtgraph import PlotWidget, plot import pyqtgraph as pg from numpy import * import sys # We need sys so that we can pass argv to QApplication import os red_uuid = UUID(0xddd1) app = QtGui.QApplication([]) win = pg.GraphicsWindow(title="Signal from serial port") p = win.addPlot(title="Realtime plot") curve = p.plot() windowWidth = 500 # width of the window displaying the curve Xm = linspace(0,0,windowWidth) # create array that will contain the relevant time series ptr = -windowWidth # set first x position class MyDelegate(DefaultDelegate): def __init__(self): DefaultDelegate.__init__(self) # ... initialise here def handleNotification(self, cHandle, data):
class BLECharacteristicUUIDs: deviceInformation_modelNumber = UUID(0x2A24)
def __init__(self, uuid, characteristics): self.service_uuid = UUID(uuid) self.service = None self.characteristics = characteristics
print(n, ": Device ", dev.addr, "(", dev.addrType, ")", ", RSSI= ", dev.rssi, " dB") n += 1 for (adtype, desc, value) in dev.getScanData(): print(desc, "=", value) number = input('Enter your device number: ') print('Device', number) print(list(devices)[int(number)].addr) print("Connecting...") dev = Peripheral(list(devices)[int(number)].addr, 'random') dev.withDelegate(ScanDelegate()) print("Services...") for svc in dev.services: print(str(svc)) try: testService = dev.getServiceByUUID(UUID(0xa000)) for ch in testService.getCharacteristics(): print(str(ch)) testService = dev.getServiceByUUID(UUID(0xb000)) for ch in testService.getCharacteristics(): print(str(ch)) but_ch = dev.getCharacteristics(uuid=UUID(0xa001))[0] cccd = but_ch.getHandle() + 1 dev.writeCharacteristic(cccd, bytes([0x01, 0x00])) if (but_ch.supportsRead()): print(but_ch.read()) led_ch = dev.getCharacteristics(uuid=UUID(0xb001))[0] if (led_ch.supportsRead()): print(led_ch.read()) led_light = led_ch.read() while True:
def switch_led(self, state): led_control_ch = self.live_service.getCharacteristics( UUID(CONTROLS["LED"]))[0] led_control_ch.write(str.encode(state))
class Nuimo: SERVICE_UUIDS = [ UUID('0000180f-0000-1000-8000-00805f9b34fb'), # Battery UUID('f29b1525-cb19-40f3-be5c-7241ecb82fd2'), # Sensors UUID('f29b1523-cb19-40f3-be5c-7241ecb82fd1') # LED Matrix ] CHARACTERISTIC_UUIDS = { UUID('00002a19-0000-1000-8000-00805f9b34fb'): 'BATTERY', UUID('f29b1529-cb19-40f3-be5c-7241ecb82fd2'): 'BUTTON', UUID('f29b1528-cb19-40f3-be5c-7241ecb82fd2'): 'ROTATION', UUID('f29b1527-cb19-40f3-be5c-7241ecb82fd2'): 'SWIPE', UUID('f29b1526-cb19-40f3-be5c-7241ecb82fd2'): 'FLY', UUID('f29b1524-cb19-40f3-be5c-7241ecb82fd1'): 'LED_MATRIX' } NOTIFICATION_CHARACTERISTIC_UUIDS = [ #'BATTERY', # Uncomment only if you are not using the iOS emulator (iOS does't support battery updates without authentication) 'BUTTON', 'ROTATION', 'SWIPE', 'FLY' ] # Notification data NOTIFICATION_ON = struct.pack("BB", 0x01, 0x00) NOTIFICATION_OFF = struct.pack("BB", 0x00, 0x00) def __init__(self, macAddress): self.macAddress = macAddress def set_delegate(self, delegate): self.delegate = delegate def connect(self): self.peripheral = Peripheral(self.macAddress, addrType='random') # Retrieve all characteristics from desires services and map them from their UUID characteristics = list( itertools.chain(*[ self.peripheral.getServiceByUUID(uuid).getCharacteristics() for uuid in Nuimo.SERVICE_UUIDS ])) characteristics = dict((c.uuid, c) for c in characteristics) # Store each characteristic's value handle for each characteristic name self.characteristicValueHandles = dict( (name, characteristics[uuid].getHandle()) for uuid, name in Nuimo.CHARACTERISTIC_UUIDS.items()) # Subscribe for notifications for name in Nuimo.NOTIFICATION_CHARACTERISTIC_UUIDS: self.peripheral.writeCharacteristic( self.characteristicValueHandles[name] + 1, Nuimo.NOTIFICATION_ON, True) self.peripheral.setDelegate(self.delegate) def waitForNotifications(self): self.peripheral.waitForNotifications(1.0) def displayLedMatrix(self, matrix, timeout, brightness=1.0): matrix = '{:<81}'.format(matrix[:81]) bytes = list( map( lambda leds: reduce( lambda acc, led: acc + (1 << led if leds[led] not in [' ', '0'] else 0), range(0, len(leds)), 0), [matrix[i:i + 8] for i in range(0, len(matrix), 8)])) self.peripheral.writeCharacteristic( self.characteristicValueHandles['LED_MATRIX'], struct.pack('BBBBBBBBBBBBB', bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8], bytes[9], bytes[10], max(0, min(255, int(255.0 * brightness))), max(0, min(255, int(timeout * 10.0)))), True)
def gather_data(self, on_error_flag=None, on_read_flag=None): sensors=[ "sunlight", "soil_temp", "air_temp", \ "vwc", "cal_vwc", "cal_air_temp", \ "cal_dli", "cal_ea", "cal_ecb", \ "cal_ec_porous", "pf_batt" ] tr = transform.DataTransformation() reading = dict.fromkeys(sensors) # Reading battery level from battery service battery_level_ch = self.battery_service.getCharacteristics( UUID(CONTROLS["BATTERY_LEVEL"]))[0] battery_level = 0 try: # conversion from byte to decimal battery_level = ord(battery_level_ch.read()) if "pf_batt" in reading.keys(): reading["pf_batt"] = battery_level except Exception as err: #self.logger.exception(traceback.print_tb(err.__traceback__)) self.logger.error("[{}] Exception occurred: {}".format( self.get_name(), str(err))) return None self.switch_led(FLAG_NOTIF_ENABLE) # iterate over the calibrated sensors characteristics for key, val in CAL_SENSORS.items(): if key not in sensors: # Skip all sensors we aren't reading this time continue svchar_live = self.live_service.getCharacteristics(UUID(val)) if len(svchar_live) <= 0: #self.logger.debug("No characteristic: {}, {}".format(key, val)) continue char = svchar_live[0] if char.supportsRead(): try: if DEBUG_RAW_DATA and (key in [ "sunlight", "soil_ec", "air_temp", "soil_temp", "vwc" ]): reading[key] = tr.unpack_U16(char.read()) elif not DEBUG_RAW_DATA: if key == "sunlight": reading[key] = tr.conv_light( tr.unpack_U16(char.read())) elif key == "soil_ec": reading[key] = tr.conv_ec( tr.unpack_U16(char.read())) # Support cases where firmware is old if reading["cal_dli"] == None: reading["cal_dli"] = reading[key] reading["cal_ea"] = reading[key] reading["cal_ecb"] = reading[key] reading["cal_ec_porous"] = reading[key] elif key in "soil_temp": reading[key] = tr.conv_temp( tr.unpack_U16(char.read())) elif key == "air_temp": reading[key] = tr.conv_temp( tr.unpack_U16(char.read())) # Support cases where firmware is old if reading["cal_air_temp"] == None: reading["cal_air_temp"] = reading[key] elif key == "vwc": reading[key] = tr.conv_moisture( tr.unpack_U16(char.read())) # Support cases where firmware is old if reading["cal_vwc"] == None: reading["cal_vwc"] = reading[key] else: reading[key] = tr.decode_float32(char.read()) except Exception as e: self.logger.exception( "[{}] Failed to read and decode sensor data: {}". format(str(self.get_name()), char.read())) reading['ts'] = int(time.time()) self.switch_led(FLAG_NOTIF_DISABLE) return reading
import struct from bluepy.btle import Scanner, DefaultDelegate, UUID, Peripheral #TARGET_UUID = "4d6fc88bbe756698da486866a36ec78e" TARGET_device_adr = 'b4:e6:2d:d5:a8:57' TARGET_UUID = "4c0002154d6fc88bbe756698da486866a36ec78e0001000100" target_dev = None UART_SERVICE_UUID = UUID("4fafc201-1fb5-459e-8fcc-c5c9c331914b") uart_service = None UART_WRITE_UUID = UUID("beb5483e-36e1-4688-b7f5-ea07361b26a8") write_char = None UART_READ_UUID = UUID("beb5483e-36e1-4688-b7f5-ea07361b26fa") read_char = None read_handle = None read_cccd = None ############################################# # Define scan callback ############################################# class DefaultDelegate0: def __init__(self): pass def handleNotification(self, cHandle, data): DBG("Notification:", cHandle, "sent data", data) def handleDiscovery(self, scanEntry, isNewDev, isNewData): DBG("Discovered device", scanEntry.addr)
import RPi.GPIO as GPIO import struct from bluepy.btle import UUID, Peripheral threshold = 10.05 fromaddr = '*****@*****.**' toaddrs = '*****@*****.**' msg = 'I need immediate service and I wanted you to know!' # Credentials (if needed) username = '******' password = '******' service_uuid = UUID("1493dd8e-8c3e-4e74-a4ff-6f0cd50005f9") char_vibr_uuid = UUID("1493dd8e-8c3e-4e78-a4ff-6f0cd50005f9") v = Peripheral(sys.argv[1]) Testsevice=v.getServiceByUUID(service_uuid) try: ch_vibr = Testsevice.getCharacteristics(char_vibr_uuid)[0] while 1: vibrVal = struct.unpack('<f', ch_temp.read())[0] # The actual mail send if vibrVal > threshold server = smtplib.SMTP('smtp.gmail.com:587') server.starttls() server.login(username,password) server.sendmail(fromaddr, toaddrs, msg)
import struct from bluepy.btle import UUID, Peripheral, DefaultDelegate import numpy as np import matplotlib.pyplot as plt import matplotlib print(matplotlib.get_backend()) # x scale - time t = [] # record the current time t_now = 0 # y scale - muscle current m = [] sensor_service = UUID(0x180D) p = Peripheral('DE:5B:BA:87:4C:F7', 'random') SensorService = p.getServiceByUUID(sensor_service) ch = SensorService.getCharacteristics(0x2A37)[0] print(UUID(ch.uuid).getCommonName()) chC = ch.getHandle() for desc in p.getDescriptors(chC, 0x16): if desc.uuid == 0x2902: chC = desc.handle p.writeCharacteristic(chC, struct.pack('<bb', 0x01, 0x00))
def add_int_to_part_of_uuid(uuid, value, part=0): uuid = UUID(uuid) parts = str(uuid).split('-') fmt = "{:0" + str(len(parts[part])) + "x}" parts[part] = fmt.format(int(parts[part], 16) + value) return UUID("-".join(parts))
class M365(Peripheral): RX_CHARACTERISTIC = UUID('6e400003-b5a3-f393-e0a9-e50e24dcca9e') TX_CHARACTERISTIC = UUID('6e400002-b5a3-f393-e0a9-e50e24dcca9e') def __init__(self, mac_address, callback=None, auto_reconnect=True): Peripheral.__init__(self) self.mac_address = mac_address self._auto_reconnect = auto_reconnect self.cached_state = {} self._callback = callback self._disconnected_callback = None self._connected_callback = None stream_handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') stream_handler.setFormatter(formatter) log.addHandler(stream_handler) def set_connected_callback(self, cb): self._connected_callback = cb def set_disconnected_callback(self, cb): self._disconnected_callback = cb @staticmethod def _find_characteristic(uuid, chars): results = filter(lambda x: x.uuid == uuid, chars) for result in results: # return the first match return result return None def _try_connect(self): log.info('Attempting to {}connect to Scooter: {}'.format('indefinitely ' if self._auto_reconnect else '', self.mac_address)) while True: try: Peripheral.connect(self, self.mac_address, addrType=ADDR_TYPE_RANDOM) log.info('Successfully connected to Scooter: ' + self.mac_address) if self._connected_callback: self._connected_callback(self) # Attach delegate self.withDelegate(M365Delegate(self)) # Turn on notifications, otherwise there won't be any notification self.writeCharacteristic(0xc, b'\x01\x00', True) self.writeCharacteristic(0x12, b'\x01\x00', True) self._all_characteristics = self.getCharacteristics() self._tx_char = M365._find_characteristic(M365.TX_CHARACTERISTIC, self._all_characteristics) self._rx_char = M365._find_characteristic(M365.RX_CHARACTERISTIC, self._all_characteristics) break except Exception as e: if self._auto_reconnect == True: log.warning('{}, retrying'.format(e)) else: raise e def _try_reconnect(self): try: self.disconnect() except: pass if self._disconnected_callback: self._disconnected_callback(self) self._try_connect() def connect(self): self._try_connect() def request(self, message): while True: try: log.debug('Sending message: {}'.format([v for (k,v) in message.__dict__.items()])) log.debug('Sending bytes: {}'.format(phex(message._raw_bytes))) self._tx_char.write(message._raw_bytes) self._rx_char.read() break except Exception as e: if self._auto_reconnect == True: log.warning('{}, reconnecting'.format(e)) self._try_reconnect() else: raise e def waitForNotifications(self, timeout): try: Peripheral.waitForNotifications(self, timeout) except Exception as e: if self._auto_reconnect == True: log.warning('{}, reconnecting'.format(e)) self._try_reconnect() else: raise e
import StandardBLEGATTCharacteristics import GenericBTLEDevice # Authentication Keys AUTH_SEND_KEY = b'\x01' AUTH_REQUEST_RANDOM_AUTH_NUMBER = b'\x02' AUTH_SEND_ENCRYPTED_AUTH_NUMBER = b'\x03' AUTH_BYTE = b'\x00' AUTH_RESPONSE = b'\x10' AUTH_SUCCESS = b'\x01' AUTH_FAIL = b'\x04' # Characteristics UUID_SERVICE_MIBAND_SERVICE = UUID("FEE0") UUID_SERVICE_MIBAND2_SERVICE = UUID("FEE1") UUID_CHARACTERISTIC_CHUNKEDTRANSFER = [ UUID_SERVICE_MIBAND_SERVICE, "00000020-0000-3512-2118-0009af100700" ] UUID_CHARACTERISTIC_AUTH = [ UUID_SERVICE_MIBAND2_SERVICE, "00000009-0000-3512-2118-0009af100700" ] UUID_UNKNOWN_CHARACTERISTIC1 = [ UUID_SERVICE_MIBAND_SERVICE, "00000001-0000-3512-2118-0009af100700" ] # Also known as SENS in https://medium.com/machine-learning-world/how-i-hacked-xiaomi-miband-2-to-control-it-from-linux-a5bd2f36d3ad # Commands COMMAND_SET_PERIODIC_HR_MEASUREMENT_INTERVAL = b'\x14' COMMAND_SET_HR_SLEEP = b'\x00'
class Wave(): UUID_DATETIME = UUID(0x2A08) UUID_HUMIDITY = UUID(0x2A6F) UUID_TEMPERATURE = UUID(0x2A6E) UUID_RADON_ST_AVG = UUID("b42e01aa-ade7-11e4-89d3-123b93f75cba") UUID_RADON_LT_AVG = UUID("b42e0a4c-ade7-11e4-89d3-123b93f75cba") def __init__(self, SerialNumber): self.mac_addr = None self.periph = None self.datetime_char = None self.humidity_char = None self.temperature_char = None self.radon_st_avg_char = None self.radon_lt_avg_char = None def scan(self): scanner = Scanner().withDelegate(DefaultDelegate()) deviceFound = False searchCount = 0 while deviceFound is False and searchCount < 50: devices = scanner.scan(0.1) # 0.1 seconds scan period searchCount += 1 for dev in devices: ManuData = dev.getValueText(255) SN = parseSerialNumber(ManuData) if (SN == SerialNumber): MacAddr = dev.addr deviceFound = True # exits the while loop on next conditional check break # exit for loop if (deviceFound is not True): print "ERROR: Could not find device." print "GUIDE: (1) Please verify the serial number. (2) Ensure that the device is advertising. (3) Retry connection." sys.exit(1) else: self.mac_addr = MacAddr print "Found Wave Mac address %s" % (MacAddr) def connect(self): try: self.periph = Peripheral(self.mac_addr) self.datetime_char = self.periph.getCharacteristics( uuid=self.UUID_DATETIME)[0] self.humidity_char = self.periph.getCharacteristics( uuid=self.UUID_HUMIDITY)[0] self.temperature_char = self.periph.getCharacteristics( uuid=self.UUID_TEMPERATURE)[0] self.radon_st_avg_char = self.periph.getCharacteristics( uuid=self.UUID_RADON_ST_AVG)[0] self.radon_lt_avg_char = self.periph.getCharacteristics( uuid=self.UUID_RADON_LT_AVG)[0] except btle.BTLEException as e: print "Connecting error, retry..." time.sleep(60) def read(self, sensor_idx): if (sensor_idx == SENSOR_IDX_DATETIME and self.datetime_char != None): rawdata = self.datetime_char.read() rawdata = struct.unpack('HBBBBB', rawdata) data = datetime(rawdata[0], rawdata[1], rawdata[2], rawdata[3], rawdata[4], rawdata[5]) unit = " " elif (sensor_idx == SENSOR_IDX_HUMIDITY and self.humidity_char != None): rawdata = self.humidity_char.read() data = struct.unpack('H', rawdata)[0] * 1.0 / 100.0 unit = " %rH" elif (sensor_idx == SENSOR_IDX_TEMPERATURE and self.temperature_char != None): rawdata = self.temperature_char.read() data = struct.unpack('h', rawdata)[0] * 1.0 / 100.0 unit = " degC" elif (sensor_idx == SENSOR_IDX_RADON_ST_AVG and self.radon_st_avg_char != None): rawdata = self.radon_st_avg_char.read() data = struct.unpack('H', rawdata)[0] * 1.0 unit = " Bq/m3" elif (sensor_idx == SENSOR_IDX_RADON_LT_AVG and self.radon_lt_avg_char != None): rawdata = self.radon_lt_avg_char.read() data = struct.unpack('H', rawdata)[0] * 1.0 unit = " Bq/m3" else: print "ERROR: Unkown sensor ID or device not paired" print "GUIDE: (1) method connect() must be called first, (2) Ensure correct sensor_idx input value." sys.exit(1) return str(data) + unit def disconnect(self): if self.periph is not None: self.periph.disconnect() self.periph = None self.datetime_char = None self.humidity_char = None self.temperature_char = None self.radon_st_avg_char = None self.radon_lt_avg_char = None
# for each device in the list of devices roehladdress = "" for dev in devices: # print the device's MAC address, its address type, # and Received Signal Strength Indication that shows how strong the signal was when the script received the broadcast. print("Device %s (%s), RSSI=%d dB" % (dev.addr, dev.addrType, dev.rssi)) for (adtype, desc, value) in dev.getScanData(): if (value == "Roehl-M001"): roehladdress = dev.addr print("%s %s = %s" % (roehladdress, desc, value)) print("---hello---") # temp_uuid = UUID(0xff01) service_uuid = UUID(0x00ff) print(roehladdress) print(sys.argv[1]) print(sys.argv[2]) print(sys.argv[3]) if len(roehladdress) < 5: print("device not find") scanner = None p = None ch_name = None ch_result = None ch_write = None continue # sys.exit() print(
class BLEServicesUUIDs: deviceInformation = UUID(0x180A)
number = int(number) n = 0 for dev in devices: print("%d: Device %s (%s), RSSI=%d dB" % (n, dev.addr, dev.addrType, dev.rssi)) if n == number: word = dev.addr n = n + 1 for (adtype, desc, value) in dev.getScanData(): print(" %s = %s" % (desc, value)) print(word) print("Connecting...") dev = Peripheral(word, 'random') print("Services...") for svc in dev.services: print(str(svc)) try: testService = dev.getServiceByUUID(UUID(0xfff0)) for ch in testService.getCharacteristics(): print(str(ch)) for i in range(1, 50): ch = dev.getCharacteristics(uuid=UUID(0xfff1))[0] if (ch.supportsRead()): print(ch.read()) time.sleep(2) finally: dev.disconnect()
import sys import binascii import struct import time from bluepy.btle import UUID, Peripheral button_service_uuid = UUID(0xA000) button_char_uuid = UUID(0xA001) if len(sys.argv) != 2: print "Fatal, must pass device address:", sys.argv[0], "<device address="">" quit() p = Peripheral(sys.argv[1], "random") ButtonService=p.getServiceByUUID(button_service_uuid) try: ch = ButtonService.getCharacteristics(button_char_uuid)[0] if (ch.supportsRead()): while 1: val = binascii.b2a_hex(ch.read()) print ("0x" + val) time.sleep(1) finally: p.disconnect()
train_size = 0 # knn_table = numpy.(shape(,6)) knn_table = pd.DataFrame(columns=B_COLUMNS) # knn_table = pd.Series() # knn_table = np.dot(knn_table,knn_table.T) # knn_table = np.array([B_TABLE.keys().values,len(B_TABLE.keys())]) # print(knn_table) # # The Characteristics and services used # The service is Heart Rate Monitor # For the Characteristics there are the standard Heart Rate and Nbeacons Locations Characteristics # hrm_measure = '---' hrm_char_uuid = UUID(0x2A37) # Heart Rate Characteristic hrm_service_uuid = UUID(0x180D) # Heart Rate Monitor Service location_char_uuid = UUID(0x2A69) # Location Characteristic training_char_uuid = UUID(0x2AAD) # Training Characteristic fig = plt.figure() ax = fig.add_subplot(1,1,1,) hrm_label = plt.gcf().text(0.2, 0.15, "Heart Rate: "+hrm_measure, fontsize=14) # ax2 = fig.add_subplot(2,2,2,) time_prev = 0 #acquire(); release() # threading.Semaphore(0) mutex_access_table = threading.Lock()
def _TI_UUID(val): return UUID("%08X-0451-4000-b000-000000000000" % (0xF0000000 + val))
def update(self): _LOGGER.debug("Flowerpower updating data") from bluepy.btle import UUID, Peripheral, Scanner, DefaultDelegate periph = None try: # Connect to device _LOGGER.debug('Connecting') periph = Peripheral(self._mac) if (periph is None): _LOGGER.debug('Not connected') else: services = periph.getServices() # ['daily_light_integral', 'Daily Light Integral', 'mol/m2/d', None, None], # sensors.append(Sensor("Daily Light Integral" , "39e1fa01-84a8-11e2-afba-0002a5d5c51b", '<H', "mol/m2/d\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa01-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['daily_light_integral'] = struct.unpack( 'H', rawdata)[0] # ['soil_ec', 'Soil EC', 'dS/m', None, None], # sensors.append(Sensor("SOIL_EC" , "39e1fa02-84a8-11e2-afba-0002a5d5c51b", '<H', "\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa02-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['soil_ec'] = struct.unpack('H', rawdata)[0] # ['soil_temperature', 'Soil Temperature', TEMP_CELSIUS, None, DEVICE_CLASS_TEMPERATURE], # sensors.append(Sensor("SOIL_TEMPERATURE" , "39e1fa03-84a8-11e2-afba-0002a5d5c51b", '<H', "C\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa03-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['soil_temperature'] = struct.unpack( 'H', rawdata)[0] / 32.0 # sensors.append(Sensor("AIR_TEMPERATURE" , "39e1fa04-84a8-11e2-afba-0002a5d5c51b", '<H', "C\t", 1.0)) # ['air_temperature', 'Air Temperature', TEMP_CELSIUS, None, DEVICE_CLASS_TEMPERATURE], curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa04-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['air_temperature'] = struct.unpack( 'H', rawdata)[0] / 32.0 # sensors.append(Sensor("SOIL_MOISTURE" , "39e1fa05-84a8-11e2-afba-0002a5d5c51b", '<H', "%\t", 1.0)) # ['soil_moisture', 'Soil Moisture', '%', None, DEVICE_CLASS_HUMIDITY], curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa05-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['soil_moisture'] = struct.unpack( 'H', rawdata)[0] / 32.0 # ['calibrated_soil_moisture', 'Calibrated Soil Moisture', '%', None, DEVICE_CLASS_HUMIDITY], # sensors.append(Sensor("CALIBRATED_SOIL_MOISTURE", "39e1fa09-84a8-11e2-afba-0002a5d5c51b", 'f', "%\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa09-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['calibrated_soil_moisture'] = struct.unpack( 'f', rawdata)[0] # ['calibrated_air_temperature', 'Calibrated Air Temperature', TEMP_CELSIUS, None, DEVICE_CLASS_TEMPERATURE], # sensors.append(Sensor("CALIBRATED_AIR_TEMP" , "39e1fa0a-84a8-11e2-afba-0002a5d5c51b", 'f', "C\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa0a-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['calibrated_air_temperature'] = struct.unpack( 'f', rawdata)[0] # sensors.append(Sensor("Battery" , UUID(0x2A19), 'B', "%\t", 1.0)) # ['battery_level', 'Battery Level', '%', None, DEVICE_CLASS_HUMIDITY], curr_val_char = periph.getCharacteristics(uuid=UUID(0x2A19))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state['battery_level'] = struct.unpack('B', rawdata)[0] # ['calibrated_daily_light_integral', 'calibrated Daily Light Integral', 'mol/m2/d', None, DEVICE_CLASS_ILLUMINANCE], # sensors.append(Sensor("CALIBRATED_DLI" , "39e1fa0b-84a8-11e2-afba-0002a5d5c51b", 'f', "mol/m2/d\t", 1.0)) curr_val_char = periph.getCharacteristics( uuid=UUID("39e1fa0b-84a8-11e2-afba-0002a5d5c51b"))[0] if (curr_val_char is None): _LOGGER.debug('Not connected') else: _LOGGER.debug('Reading data') rawdata = curr_val_char.read() _LOGGER.debug("Data:{}".format(' '.join( map(str, list(rawdata))))) self._state[ 'calibrated_daily_light_integral'] = struct.unpack( 'f', rawdata)[0] # sensors.append(Sensor("LIVE_MODE_PERIOD" , "39e1fa06-84a8-11e2-afba-0002a5d5c51b", '<H', "%\t", 1.0)) # sensors.append(Sensor("LED" , "39e1fa07-84a8-11e2-afba-0002a5d5c51b", '<H', "%\t", 1.0)) # sensors.append(Sensor("LAST_MOVE_DATE" , "39e1fa08-84a8-11e2-afba-0002a5d5c51b", '<H', "%\t", 1.0)) # sensors.append(Sensor("CALIBRATED_DLI" , "39e1fa0b-84a8-11e2-afba-0002a5d5c51b", 'f', "mol/m2/d\t", 1.0)) # sensors.append(Sensor("CALIBRATED_EA" , "39e1fa0c-84a8-11e2-afba-0002a5d5c51b", 'f', "\t", 1.0)) # sensors.append(Sensor("CALIBRATED_ECB" , "39e1fa0d-84a8-11e2-afba-0002a5d5c51b", 'f', "dS/m\t", 1.0)) # sensors.append(Sensor("CALIBRATED_EC_POROUS" , "39e1fa0e-84a8-11e2-afba-0002a5d5c51b", 'f', "dS/m\t", 1.0)) # sensors.append(Sensor("Firmware" , UUID(0x2A26), 'HBBBBB', "\t", 1.0)) except: _LOGGER.debug('Not connected, error') # _LOGGER.debug('Resetting bluetooth') # subprocess.Popen(["sudo", "systemctl", "restart", "bluetooth"]).wait(5) # subprocess.Popen(["sudo", "hciconfig", 'hci0', "reset"]).wait(5) finally: if periph is not None: _LOGGER.debug('Disconnecting') periph.disconnect()
import binascii from bluepy.btle import UUID, Peripheral temp_uuid = UUID(0x2A19) p = Peripheral("6D:E7:DE:A9:7A:7D", "random") try: ch = p.getCharacteristics(uuid=temp_uuid)[0] print binascii.b2a_hex(ch.read()) finally: p.disconnect()
class MyDelegate(DefaultDelegate): def __init__(self): DefaultDelegate.__init__(self) def handleNotification(self, cHandle, data): #for i in range(0,15): # sys.stdout.write(((data[i]))) # sys.stdout.write(',') print ' '.join("{:02x}".format(ord(c)) for c in data) sys.stdout.flush() if __name__ == '__main__': iiot_uuid = UUID(0x2800) p = Peripheral("24:71:89:1A:A9:27") p.setDelegate(MyDelegate()) data_UUID = _TI_UUID(0xAA00) sensor_UUID = _TI_UUID(0xAA01) timestamp_UUID = _TI_UUID(0xAA02) conf_UUID = 0x2902 data_service = p.getServiceByUUID(data_UUID) print data_service sensor_characteristic = data_service.getCharacteristics(sensor_UUID) print sensor_characteristic
def connect(pi): from bluepy.btle import Scanner, DefaultDelegate, Peripheral, ADDR_TYPE_RANDOM, UUID, BTLEException device = None addr = None _LOGGER.debug("Starting plejd connection") disconnect(pi) scanner = Scanner() for i in range(1, 10): devs = sorted(list(scanner.scan(1)), key=lambda d: d.rssi)[::-1] for d in devs: for (adtype, desc, value) in d.getScanData(): if (adtype == 8 and value == "P mesh"): try: dev = Peripheral(d, addrType=ADDR_TYPE_RANDOM) if dev.getServiceByUUID(UUID(PLEJD_SERVICE)): device = dev else: dev.disconnect() break except BTLEException as e: _LOGGER.warning( "failed connecting to device '%s' : '%s'" % (d.addr, e)) if device: break if device is None: _LOGGER.warning("no device found on iteration %d" % (i)) else: break if device == None: _LOGGER.warning("Failed to find a Plejd device to connect to") return _LOGGER.debug("Connected to Plejd device '%s'" % (device.addr)) pi["device"] = device pi["address"] = binascii.a2b_hex(device.addr.replace(':', ''))[::-1] pi["handles"] = {} pi["handles"]["last_data"] = pi["device"].getCharacteristics( uuid=UUID(LAST_DATA_UUID))[0].getHandle() pi["handles"]["auth"] = pi["device"].getCharacteristics( uuid=UUID(AUTH_UUID))[0].getHandle() pi["handles"]["ping"] = pi["device"].getCharacteristics( uuid=UUID(PING_UUID))[0].getHandle() pi["handles"]["data"] = pi["device"].getCharacteristics( uuid=UUID(DATA_UUID))[0].getHandle() class PlejdDelegate(DefaultDelegate): def handleNotification(self, handle, value): if handle == pi["handles"]["last_data"]: dec = plejd_enc_dec(pi["key"], pi["address"], value) # check if this is a device we care about if dec[0] in PLEJD_DEVICES: device = PLEJD_DEVICES[dec[0]] else: _LOGGER.debug("no match for device '%d' (%s)" % (dec[0], binascii.b2a_hex(dec))) return dim = 0xffff state = None if dec[3:5] == b'\x00\xc8' or dec[3:5] == b'\x00\x98': # 00c8 and 0098 both mean state+dim state = dec[5] dim = int.from_bytes(dec[6:8], 'little') elif dec[3:5] == b'\x00\x97': # 0097 is state only state = dec[5] else: _LOGGER.debug("no match for command '%s' (%s)" % (binascii.b2a_hex(dec[3:5], dec))) return if (state == 0): state = False else: state = True device.update_state(state, dim) class PlejdNotificationThread(Thread): def __init__(self): Thread.__init__(self) self.stopped = True _LOGGER.debug("setting up notification thread") def stop(self): _LOGGER.debug("stopping notification thread") self.stopped = True import time def run(self): from bluepy.btle import BTLEInternalError _LOGGER.debug("starting notification thread") self.stopped = False while True: try: pi["device"].waitForNotifications(1) except BTLEInternalError as e: _LOGGER.warning("Encountered bluepy internal error: '%s'" % (e)) if self.stopped: break _LOGGER.debug("exiting notification thread") authenticate(pi) # the notification handle is last_data + 2 pi["device"].writeCharacteristic(pi["handles"]["last_data"] + 2, b'\x02\x00') pi["device"].withDelegate(PlejdDelegate()) pi["thread"] = PlejdNotificationThread() pi["thread"].start() _LOGGER.debug("all plejd setup completed")
from gtts import gTTS import numpy as np import time #常规时间操作模块 import datetime #时间复杂操作模块(定时) from bluepy.btle import UUID, Peripheral import sys import struct import binascii #进制转化模块 import os import signal import skywriter import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import matplotlib.animation as animation ##---------------bluetooth setting------------------------- RX_SERVICE_UUID = UUID( '6e400001-b5a3-f393-e0a9-e50e24dcca9e') ##只有这个是蓝牙插座的UUID RX_CHAR_UUID = UUID('6e400003-b5a3-f393-e0a9-e50e24dcca9e') ##接受设备uuid TX_CHAR_UUID = UUID('6e400002-b5a3-f393-e0a9-e50e24dcca9e') ##发送设备uuid switch_staus = "off" ##---------------bluetooth setting end--------------------- off = 's' on = 'l' X = 'l' window = tk.Tk() window.title("控制界面") T = Text(window, width=50) S = Scrollbar(window) S.pack(side=LEFT, fill=Y) T.pack(side=LEFT, fill=Y) S.config(command=T.yview) T.config(yscrollcommand=S.set)
self.current_index = 0 self.dft = [0] * 256 def handleNotification(self, cHandle, data): # convert data to readable integer fft_input = binascii.b2a_hex(data) fft_input = binascii.unhexlify(fft_input) longueur = len(fft_input) dft_treated = [] for i in range(0, 20): dft_treated.append(ord(fft_input[i])) for i in range(0, longueur, 5): self.read_val(dft_treated, i) if __name__ == "__main__": rx_uuid = UUID(0x2221) sample_size = 128 # p = Peripheral("D9:35:6A:75:9F:9D", "random") # Rfduino sur usb continuer = True while(continuer): try: p = Peripheral("D1:7F:06:ED:66:DC", "random") # Rfduino sur pcb continuer = False except: print "Module bluetooth deja connecte, nouvel essai dans 3 sec..." time.sleep(3) p.withDelegate(MyDelegate()) Analyser.set_p(p) print " device connected..." try:
def main(): config = read_config('/xiaomi/config/config.json') logger = configure_logger(config) client = initialize_db_connection(config=config, logger=logger) uuid_characteristic_temperature_fine = UUID( "00002a6e-0000-1000-8000-00805f9b34fb") #handle 21 uuid_characteristic_temperature_coarse = UUID( "00002a1f-0000-1000-8000-00805f9b34fb") #handle 18 uuid_characteristic_humidity = UUID( "00002a6f-0000-1000-8000-00805f9b34fb") #handle 24 uuid_characteristic_battery = UUID( "00002a19-0000-1000-8000-00805f9b34fb") #handle 14 while True: handle_connections(config=config, logger=logger) if connections is not None: for connection in connections: try: characteristics = connection.getCharacteristics() except BTLEDisconnectError as e: logger.warning("%s device is not connected", connection.addr) connections.remove(connection) #Remove disconnected device continue for p in config['devices']: if connection.addr is config['devices'][p]['mac_address']: perip = p values = [] for characteristic in characteristics: if characteristic.uuid == uuid_characteristic_temperature_coarse: values.insert( 0, int.from_bytes(characteristic.read(), byteorder="little") / 10) if characteristic.uuid == uuid_characteristic_humidity: values.insert( 1, int.from_bytes(characteristic.read(), byteorder="little") / 100) if characteristic.uuid == uuid_characteristic_battery: values.insert( 2, int.from_bytes(characteristic.read(), byteorder="little")) logger.debug("Temp: %sC°\tHum: %s%%\tBat: %s%%\t%s\t%s", str(values[0]), str(values[1]), str(values[2]), connection.addr, perip) data_entry = [{ "measurement": perip, "fields": { "temperature": values[0], "humidity": values[1], "battery": values[2] } }] #print (data_entry) if client.write_points(data_entry) is True: logger.debug('SENT') values.clear() logger.debug('Active connections: %s', len(connections)) #time.sleep(config['update_time']*60) time.sleep(config['update_time'] * 60)