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,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, 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, 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):
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, 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)
