def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr) if version == AUTODETECT: svcs = self.discoverServices() if _TI_UUID(0xAA70) in svcs: version = SENSORTAG_2650 else: version = SENSORTAG_V1 fwVers = self.getCharacteristics( uuid=AssignedNumbers.firmwareRevisionString) if len(fwVers) >= 1: self.firmwareVersion = fwVers[0].read().decode("utf-8") else: self.firmwareVersion = u'' if version == SENSORTAG_V1: self.accelerometer = AccelerometerSensor(self) # self.magnetometer = MagnetometerSensor(self) self.gyroscope = GyroscopeSensor(self) elif version == SENSORTAG_2650: self._mpu9250 = MovementSensorMPU9250(self) self.accelerometer = AccelerometerSensorMPU9250(self._mpu9250) # self.magnetometer = MagnetometerSensorMPU9250(self._mpu9250) self.gyroscope = GyroscopeSensorMPU9250(self._mpu9250) self.battery = BatterySensor(self)
def __init__(self, peripheral_addr, lock, streamChar, cfgChar, streamCB): try: Peripheral.__init__(self, peripheral_addr) except Exception as e: logging.warning("Problem initializing Peripheral %s", e) raise threading.Thread.__init__(self) self.lock = lock self.msgToWrite = "" # Set up our WRITE characteristic try: self.cfgChar = self.getCharacteristics(uuid=cfgChar)[0] except Exception as e: logging.debug("Problem getting characteristics from %s. %s", self.addr, e) # Create a delegate folr streaming char self.delegate = MyDelegate(peripheral_addr, self.lock) self.delegate.handleNotification = streamCB self.withDelegate(self.delegate) self.connected = True # register on NOTIFICATION for streaming char logging.info("Configuring RX to notify me on change") try: streamChar_Hnd = self.getCharacteristics( uuid=streamChar)[0].getHandle() self.writeCharacteristic(streamChar_Hnd + 1, b"\x01\x00", withResponse=True) except Exception as e: logging.debug("Problem subscribing to RX notifications: %s", e)
def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr) if version == AUTODETECT: svcs = self.discoverServices() if _TI_UUID(0xAA70) in svcs: version = SENSORTAG_2650 else: version = SENSORTAG_V1 if version == SENSORTAG_V1: self.IRtemperature = IRTemperatureSensor(self) self.accelerometer = AccelerometerSensor(self) self.humidity = HumiditySensor(self) self.magnetometer = MagnetometerSensor(self) self.barometer = BarometerSensor(self) self.gyroscope = GyroscopeSensor(self) self.keypress = KeypressSensor(self) self.lightmeter = None elif version == SENSORTAG_2650: self._mpu9250 = MovementSensorMPU9250(self) self.IRtemperature = IRTemperatureSensorTMP007(self) self.accelerometer = AccelerometerSensorMPU9250(self._mpu9250) self.humidity = HumiditySensorHDC1000(self) self.magnetometer = MagnetometerSensorMPU9250(self._mpu9250) self.barometer = BarometerSensorBMP280(self) self.gyroscope = GyroscopeSensorMPU9250(self._mpu9250) self.keypress = KeypressSensor(self) self.lightmeter = OpticalSensorOPT3001(self) self.battery = BatterySensor(self)
def __init__(self, dev): Peripheral.__init__(self) Thread.__init__(self) self.setDaemon(True) self.dev = dev self.isConnected = False self.am = ambient.Ambient(channelID, writeKey)
def __init__(self, mac_address, timeout=0.5, debug=False, accel_max_Q=300): self._stop_getting_real_time = Event() FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=FORMAT) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self._log.info('Connecting to ' + mac_address) Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_RANDOM) self._log.info('Connected') self.timeout = timeout self.mac_address = mac_address self.state = None self.queue = Queue() self.accel_queue = Queue(maxsize=accel_max_Q) self.accel_raw_callback = None self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self._char_auth = self.svc_2.getCharacteristics( UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_sensor_ctrl = self.svc_1.getCharacteristics( UUIDS.CHARACTERISTIC_SENSOR_CONTROL)[0] self._char_sensor_measure = self.svc_1.getCharacteristics( UUIDS.CHARACTERISTIC_SENSOR_MEASURE)[0] self._auth_notif(True) # Enable auth service notifications on startup self.waitForNotifications(0.1) # Let MiBand2 to settle
def __init__(self, mac_address, timeout=0.5, debug=False): FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_RANDOM) self.timeout = timeout self.mac_address = mac_address self.state = None self.queue = Queue() self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self.svc_heart = self.getServiceByUUID(UUIDS.SERVICE_HEART_RATE) self._char_auth = self.svc_2.getCharacteristics( UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_CONTROL)[0] self._char_heart_measure = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_MEASURE)[0] # Enable auth service notifications on startup self._auth_notif(True) # Let MiBand2 to settle self.waitForNotifications(0.1)
def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr, iface=1) # Use plug-in BLE dongle print("Initialized peripheral. Scanning services.") if version == AUTODETECT: svcs = self.discoverServices() print("Service discovery completed.") version = SENSORTAG_1350 # Also works for CC2650 # if _TI_UUID(0xAA70) in svcs: # version = SENSORTAG_2650 # else: # version = SENSORTAG_V1 fwVers = self.getCharacteristics( uuid=AssignedNumbers.firmwareRevisionString) if len(fwVers) >= 1: self.firmwareVersion = fwVers[0].read().decode("utf-8") else: self.firmwareVersion = u'' if version == SENSORTAG_1350: self.mpu9250 = MovementSensorMPU9250(self) # self.IRtemperature = IRTemperatureSensorTMP007(self) self.accelerometer = AccelerometerSensorMPU9250(self.mpu9250) self.humidity = HumiditySensorHDC1000(self) self.magnetometer = MagnetometerSensorMPU9250(self.mpu9250) self.barometer = BarometerSensorBMP280(self) self.gyroscope = GyroscopeSensorMPU9250(self.mpu9250) self.keypress = KeypressSensor(self) self.lightmeter = OpticalSensorOPT3001(self) self.battery = BatterySensor(self)
def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr) self._mpu9250 = MovementSensorMPU9250(self) self.accelerometer = AccelerometerSensorMPU9250(self._mpu9250) self.humidity = HumiditySensorHDC1000(self) self.keypress = KeypressSensor(self) self.battery = BatterySensor(self)
def __init__(self,addr,version=AUTODETECT): Peripheral.__init__(self,addr) if version==AUTODETECT: svcs = self.discoverServices() if _TI_UUID(0xAA70) in svcs: version = SENSORTAG_2650 else: version = SENSORTAG_V1 fwVers = self.getCharacteristics(uuid=AssignedNumbers.firmwareRevisionString) if len(fwVers) >= 1: self.firmwareVersion = fwVers[0].read().decode("utf-8") else: self.firmwareVersion = u'' if version==SENSORTAG_V1: self.IRtemperature = IRTemperatureSensor(self) self.accelerometer = AccelerometerSensor(self) self.humidity = HumiditySensor(self) self.magnetometer = MagnetometerSensor(self) self.barometer = BarometerSensor(self) self.gyroscope = GyroscopeSensor(self) self.keypress = KeypressSensor(self) self.lightmeter = None elif version==SENSORTAG_2650: self._mpu9250 = MovementSensorMPU9250(self) self.IRtemperature = IRTemperatureSensorTMP007(self) self.accelerometer = AccelerometerSensorMPU9250(self._mpu9250) self.humidity = HumiditySensorHDC1000(self) self.magnetometer = MagnetometerSensorMPU9250(self._mpu9250) self.barometer = BarometerSensorBMP280(self) self.gyroscope = GyroscopeSensorMPU9250(self._mpu9250) self.keypress = KeypressSensor(self) self.lightmeter = OpticalSensorOPT3001(self) self.battery = BatterySensor(self)
def __init__(self, addr): Peripheral.__init__(self, addr) self.service = self.getServiceByUUID(GENERAL_SERVICE_UUID) self.control_characteristic = self.service.getCharacteristics( CONTROL_SERVICE_UUID)[0] self.data_characteristic = self.service.getCharacteristics( READ_SERVICE_UUID)[0]
def __init__(self, mac_address, timeout=1, debug=True): FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=FORMAT) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self.is_auth = False self.is_pair = False self.num = b'\x00' self._log.info('Connecting to ' + mac_address) Peripheral.__init__(self, mac_address) self._log.info('Connected') self.timeout = timeout self.mac_address = mac_address self.state = None self.queue = Queue() self.heart_measure_callback = None self.heart_raw_callback = None self.accel_raw_callback = None self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self.svc_heart = self.getServiceByUUID(UUIDS.SERVICE_HEART_RATE) self._char_auth = self.svc_2.getCharacteristics(UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors(forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics(UUIDS.CHARACTERISTIC_HEART_RATE_CONTROL)[0] self._char_heart_measure = self.svc_heart.getCharacteristics(UUIDS.CHARACTERISTIC_HEART_RATE_MEASURE)[0] self.setDelegate(AuthenticationDelegate(self))
def __init__(self, mac_address, zsock, timeout=0.5, debug=False): FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=FORMAT) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self.zsock = zsock self._log.info('Connecting to ' + mac_address) Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_RANDOM) self._log.info('Connected') self.timeout = timeout self.mac_address = mac_address self.auth_state = None # TODO clean this up self.svc_1 = self.getServiceByUUID(UUIDS.svc['MIBAND1']) self.svc_2 = self.getServiceByUUID(UUIDS.svc['MIBAND2']) self.svc_heart = self.getServiceByUUID(UUIDS.svc['HEART_RATE']) self._char_auth = self.svc_2.getCharacteristics(UUIDS.char['AUTH'])[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.notif['DESCRIPTOR'])[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics( UUIDS.char['HEART_RATE_CONTROL'])[0] self._char_heart_measure = self.svc_heart.getCharacteristics( UUIDS.char['HEART_RATE_MEASURE'])[0] # Enable auth service notifications on startup self._auth_notif(True) # Let MiBand2 to settle self.waitForNotifications(0.1)
def __init__(self, addr): Peripheral.__init__(self, addr, addrType="random") # self.battery = BatterySensor(self) self.environment = EnvironmentService(self) self.ui = UserInterfaceService(self) self.motion = MotionService(self) self.sound = SoundService(self)
def __init__(self, addr): Peripheral.__init__(self, addr, addrType="random") #Thingy configuration service not implemented self.battery = BatterySensor(self) self.environment = EnvironmentService(self) self.ui = UserInterfaceService(self) self.motion = MotionService(self)
def __init__(self, mac_address, key, timeout=0.5, debug=False, datapool={}, connect_timeout=10): self._KEY = key self._send_key_cmd = struct.pack('<18s', b'\x01\x00' + self._KEY) datapool["DeviceAddress"] = mac_address.replace(":", "") self.datapool = datapool # logging.config.fileConfig("logging.conf") self._log = logging.getLogger(self.__class__.__name__) self._log.info('Connecting to ' + mac_address) # Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_PUBLIC) self._connect_timeout = connect_timeout #------------------------------------------------------------------------------------ Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_PUBLIC, iface=None) #------------------------------------------------------------------------------------ self._log.info('Connected') self.timeout = timeout self.mac_address = mac_address self.state = None self.queue = Queue() self.heart_measure_callback = None self.heart_raw_callback = None self.accel_raw_callback = None self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self.svc_heart = self.getServiceByUUID(UUIDS.SERVICE_HEART_RATE) self._char_auth = self.svc_2.getCharacteristics( UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_CONTROL)[0] self._char_heart_measure = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_MEASURE)[0] # Enable auth service notifications on startup self._auth_notif(True) # Let band to settle ret = self.waitForNotifications(0.1)
def __init__(self, addr): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_RANDOM) self.service_uuid = "B3F72C28-2618-4E2B-9075-1B17CCA4EC66" self.char_uuid_map = { 'temperature': "E60A00E9-D6A9-430F-959C-872F07E64FCE", 'humidity': "4DF3BB88-C7CB-47B5-B213-CEA3770DB9E8", 'co2-ppm': "6431AF8C-A5B4-47EB-BA73-B69495327E53", }
def __init__(self, addr): print("Press the Angel Sensor's button to continue...") while True: try: Peripheral.__init__(self, addr, addrType=ADDR_TYPE_PUBLIC) except BTLEException: time.sleep(0.5) continue break
def __init__(self, addr): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_RANDOM) # Thingy configuration service not implemented self.battery = BatterySensor(self) self.environment = EnvironmentService(self) self.ui = UserInterfaceService(self) self.motion = MotionService(self) self.sound = SoundService(self)
def __init__(self, addr): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_RANDOM) print("Connected") self.handle = 0 self.raw_data = b'0' self.timeout = 5.0 self.auth = False # Enable auth service notifications on startup self.auth_notif(True)
def __init__(self, mac_address, key=None, timeout=0.5, debug=False): FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=FORMAT) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self._log.info('Connecting to ' + mac_address) Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_PUBLIC) self._log.info('Connected') if not key: self.setSecurityLevel(level="medium") self.timeout = timeout self.mac_address = mac_address self.state = None self.heart_measure_callback = None self.heart_raw_callback = None self.accel_raw_callback = None self.auth_key = key self.queue = Queue() self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self.svc_heart = self.getServiceByUUID(UUIDS.SERVICE_HEART_RATE) self._char_auth = self.svc_2.getCharacteristics( UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_CONTROL)[0] self._char_heart_measure = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_MEASURE)[0] # Recorded information self._char_fetch = self.getCharacteristics( uuid=UUIDS.CHARACTERISTIC_FETCH)[0] self._desc_fetch = self._char_fetch.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_activity = self.getCharacteristics( uuid=UUIDS.CHARACTERISTIC_ACTIVITY_DATA)[0] self._desc_activity = self._char_activity.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] #chunked transfer and music self._char_chunked = self.svc_1.getCharacteristics( UUIDS.CHARACTERISTIC_CHUNKED_TRANSFER)[0] self._char_music_notif = self.svc_1.getCharacteristics( UUIDS.CHARACTERISTIC_MUSIC_NOTIFICATION)[0] self._desc_music_notif = self._char_music_notif.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._auth_notif(True) self.enable_music() self.activity_notif_enabled = False self.waitForNotifications(0.1) self.setDelegate(Delegate(self))
def __init__(self, macAdress): Peripheral.__init__(self, macAdress, ADDR_TYPE_RANDOM) print("Connected") self.authService = self.getServiceByUUID(authServiceUUID) self.authCharacteristics = self.authService.getCharacteristics(authCharUUID)[0] self.notifDescriptor = self.authCharacteristics.getDescriptors(notificationsUUID)[0] self.authenticationsNotif(True) self.waitForNotifications(0.5)
def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr, iface=1) # Use plug-in BLE dongle self.deviceType = None self.mac = None self.position = None self.sensors = [] print("Initialized peripheral. Scanning services.") if version == AUTODETECT: svcs = self.discoverServices() print("Service discovery completed.")
def __init__(self, addr, delegate=None): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_RANDOM) self.battery = BatterySensor(self) self.environment = EnvironmentService(self) self.ui = UserInterfaceService(self) self.motion = MotionService(self) self.sound = SoundService(self) if delegate is not None: self.setDelegate(delegate)
def __init__(self): DeskAddress = "" scanner = Scanner().withDelegate(ScanDelegate()) devices = scanner.scan(1.0) for dev in devices: for (adtype, desc, value) in dev.getScanData(): if (adtype == 9 and "desk" in value): DeskAddress = dev.addr Peripheral.__init__(self, DeskAddress, addrType=ADDR_TYPE_RANDOM) self.position = PositionSensor(self) self.movement = MovementService(self)
def __init__(self, device): Peripheral.__init__(self, device.addr, addrType=device.addrType, iface=device.iface) self.isValid = False self.isChecked = False self.lampService = None self.onOffChar = None self.hsvChar = None self.brightnessChar = None self.presetChar = None
def __init__(self, mac_address, timeout=0.5, debug=False): FORMAT = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=FORMAT) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self._log.info('Connecting to ' + mac_address) Peripheral.__init__(self, mac_address, addrType=ADDR_TYPE_RANDOM) self._log.info('Connected') self.timeout = timeout self.mac_address = mac_address self.state = None self.queue = Queue() self.heart_measure_callback = None self.heart_raw_callback = None self.accel_raw_callback = None self.svc_1 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND1) self.svc_2 = self.getServiceByUUID(UUIDS.SERVICE_MIBAND2) self.svc_heart = self.getServiceByUUID(UUIDS.SERVICE_HEART_RATE) self._char_auth = self.svc_2.getCharacteristics( UUIDS.CHARACTERISTIC_AUTH)[0] self._desc_auth = self._char_auth.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_heart_ctrl = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_CONTROL)[0] self._char_heart_measure = self.svc_heart.getCharacteristics( UUIDS.CHARACTERISTIC_HEART_RATE_MEASURE)[0] #get characteristic of step, calories and meter self.char_step_meter_calories = self.svc_1.getCharacteristics( UUIDS.CHARACTERISTIC_STEPS)[0] # Recorded information self._char_fetch = self.getCharacteristics( uuid=UUIDS.CHARACTERISTIC_FETCH)[0] self._desc_fetch = self._char_fetch.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] self._char_activity = self.getCharacteristics( uuid=UUIDS.CHARACTERISTIC_ACTIVITY_DATA)[0] self._desc_activity = self._char_activity.getDescriptors( forUUID=UUIDS.NOTIFICATION_DESCRIPTOR)[0] # Enable auth service notifications on startup self._auth_notif(True) # Let MiBand2 to settle self.waitForNotifications(0.1)
def __init__(self, addr): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_RANDOM) self.hndSt = 0 self.hndTx = 0 self.hndRx = 0 self.seq = 0 # protocol sequence, 1-byte rolling self.res = {} # numbered boxes for response strings self.mwi = 0 # message waiting indication self.withDelegate(self) # handle notifications ourselves # Bluetooth frame reassembly self.frag = gtBtReAsm() self.frag.packetHandler = self.receivePacket
def __init__(self, addr, version=AUTODETECT): Peripheral.__init__(self, addr, iface=1) # Use plug-in BLE dongle print("Initialized peripheral. Scanning services.") if version == AUTODETECT: svcs = self.discoverServices() print("Service discovery completed.") self.mpu9250 = MovementSensorMPU9250(self) self.accelerometer = AccelerometerSensorMPU9250(self.mpu9250) self.humidity = HumiditySensorHDC1000(self) self.magnetometer = MagnetometerSensorMPU9250(self.mpu9250) self.barometer = BarometerSensorBMP280(self) self.gyroscope = GyroscopeSensorMPU9250(self.mpu9250) self.keypress = KeypressSensor(self) self.lightmeter = OpticalSensorOPT3001(self) self.battery = BatterySensor(self)
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 __init__(self, mac_address=None, timeout=0.5, debug=False): fmt = '%(asctime)-15s %(name)s (%(levelname)s) > %(message)s' logging.basicConfig(format=fmt) log_level = logging.WARNING if not debug else logging.DEBUG self._log = logging.getLogger(self.__class__.__name__) self._log.setLevel(log_level) self.timeout = timeout self.mac_address = mac_address self.state = None self.service_generic = self.service_hw01 = None self.device_char = None self.tx_char = self.rx_char = None self.tx_desc = None Peripheral.__init__(self)
def __init__(self, addr): log.debug('connetion...') Peripheral.__init__(self, addr) log.debug('discovery...') self.discoverServices() self.notify_ch = None s = self.getServiceByUUID('fff0') self.cccd, = s.getCharacteristics('fff2') self.cccn, = s.getCharacteristics('fff1') log.debug('cccd: uuid=%s, commonName=%s, properties=%s' % ( self.cccd.uuid, self.cccd.uuid.getCommonName(), self.cccd.propertiesToString())) log.debug('cccn: uuid=%s, commonName=%s, properties=%s' % ( self.cccn.uuid, self.cccn.uuid.getCommonName(), self.cccn.propertiesToString())) self.cccd.write(b'\x01\x00') self.cccn.write(b'\x01\x00')
def __init__(self, addr ): if addr and len(addr) != 17 : raise Exception( 'ERROR: device address must be in the format NN:NN:NN:NN:NN:NN' ) Peripheral.__init__(self, addr) if addr: logger.info( 'connected to {}'.format( addr ) ) # self.svcs = self.discoverServices() self.name = '' self.modelNumber = None self.serialNumber = None self.firmwareRevision = None self.hardwareRevision = None self.softwareRevision = None self.manufacturer = None self.temperature = None self.humidity = None self.battery = None
def __init__(self, addr): Peripheral.__init__(self, addr, addrType=ADDR_TYPE_PUBLIC)
def __init__(self,addr): Peripheral.__init__(self,addr) # self.discoverServices() self.accelerometer = AccelerometerSensor(self) self.keypress = KeypressSensor(self) self.movement = MovementSensor(self)