def main(in_q, ble_out_q,ant_out_q):
macaddresssmartrower = smartrowreader.connecttosmartrow()
sleep(5)
manager = gatt.DeviceManager(adapter_name='hci1')
smartrow = smartrowreader.SmartRow(mac_address=macaddresssmartrower, manager=manager)
SRtoBLEANT = DataLogger(smartrow)
#sleep(10)
#try:
BC = threading.Thread(target=connectSR, args=(manager,smartrow))
BC.daemon = True
BC.start()
logger.info("SmartRow Ready and sending data to BLE and ANT Thread")
sleep(20)
print("heart beat")
#todo: have a check to see if connection has been etablished
HB = threading.Thread(target=heartbeat, args=([smartrow]))
HB.daemon = True
HB.start()
reset(smartrow)
sleep(1)
while True:
if not in_q.empty():
ResetRequest_ble = in_q.get()
print(ResetRequest_ble)
reset(smartrow)
else:
pass
ble_out_q.append(SRtoBLEANT.WRValues)
ant_out_q.append(SRtoBLEANT.WRValues)
sleep(0.1)
def read_esp32_BLE_data():
manager = gatt.DeviceManager(adapter_name='hci0')
class AnyDevice(gatt.Device):
def services_resolved(self):
super().services_resolved()
device_information_service = next(
s for s in self.services
if s.uuid == '6e400001-b5a3-f393-e0a9-e50e24dcca9e')
firmware_version_characteristic = next(
c for c in device_information_service.characteristics
if c.uuid == '6e400003-b5a3-f393-e0a9-e50e24dcca9e')
firmware_version_characteristic.read_value()
firmware_version_characteristic.enable_notifications()
def characteristic_value_updated(self, characteristic, value):
seconds = int(time.time())
with open('Dataset_MPU6050.csv', 'a') as pyfile: # Dataset_MPU6050.csv
pyfile.write(str(seconds) + ',')
with open("Dataset_MPU6050.csv", 'a') as file:
writer = csv.writer(file,delimiter = '\'')
writer.writerow([value.decode("utf-8")])
device = AnyDevice(mac_address='30:AE:A4:CC:26:12', manager=manager)
device.connect()
manager.run()
def initialize(on_state_change):
manager = gatt.DeviceManager(adapter_name='hci0')
device = GiikerDevice(mac_address='C2:DD:1F:F8:CB:DA', manager=manager, on_state_change=on_state_change)
print("Connecting... ", end="")
device.connect()
print("connected!")
manager.run()
def run_sphero(shared_resources, sphero_num, kill_switch):
shared_resources.get_numpy_resources()
manager = gatt.DeviceManager(adapter_name="hci0")
mac_address = shared_resources.sphero_config["SPHEROMACS"][sphero_num]
device = SpheroDevice(shared_resources, mac_address, manager, sphero_num,
kill_switch)
device.connect()
manager.run()
def thread():
global manager, discovery_manager, Interface
manager = gatt.DeviceManager(
adapter_name=Interface) #Creating Device Manager
discovery_manager = DiscoveryManager(
adapter_name=Interface) #Creating Discovery Manager
discovery_manager.start_discovery() #search for devices
discovery_manager.run()
def init():
L.l.info('BMS module initialising')
thread_pool.add_interval_callable(thread_run, run_interval_second=90)
m.Bms.add_upsert_listener(bms_upsert_listener)
P.manager = gatt.DeviceManager(adapter_name='hci0')
P.bluetooth_manager = threading.Thread(target=bluetooth_manager_thread,
args=[
P.manager,
])
P.bluetooth_manager.start()
P.initialised = True
def main():
p = get_argparser()
args = p.parse_args(sys.argv[1:])
if args.cmd == 'call':
if args.args:
args.args = json.loads(args.args)
manager = gatt.DeviceManager(adapter_name=args.adapter)
device = MosDevice(mac_address=args.address, manager=manager)
device.connect()
device.run_rpc_call(args.method, args.args)
def start_connector(completed_queue, adapter='hci0'):
connect_queue = Queue()
manager = gatt.DeviceManager(adapter)
manager.start_discovery()
Thread(target=manager.run, daemon=True).start()
scheduler = Thread(target=connect_scheduler, args=(connect_queue, completed_queue, manager), daemon=True)
scheduler.start()
return scheduler, connect_queue
def __init__(self, bt_iface_name='hci0'):
super(GattConnection, self).__init__()
self._device = None
self._iface = bt_iface_name
try:
self._manager = gatt.DeviceManager(adapter_name=self._iface)
except TypeError:
raise NotImplementedError("Gatt is not implemented for this platform")
self._manager_thread = threading.Thread(target=self._manager.run)
self._manager_thread.setDaemon(True)
log.debug('Starting DeviceManager...')
def __init__(self, mac):
super().__init__()
self.setWindowTitle('Sonicare')
self.client = SonicareClient(
mac=mac,
device_manager=gatt.DeviceManager(adapter_name='hci0'),
ready_callback=self._on_ready,
error_callback=self._on_error,
disconnect_callback=self._on_disconnect)
self.setCentralWidget(self._build_main_widget())
self.show()
def main():
if len(sys.argv) < 3:
print(f"USAGE: {sys.argv[0]} toggle|introspect macaddress",
file=sys.stderr)
sys.exit(1)
mac_address = sys.argv[2]
# FIXME adapter_name should be configurable
manager = gatt.DeviceManager(adapter_name="hci0")
device = HueLight(sys.argv[1], mac_address=mac_address, manager=manager)
device.connect()
manager.run()
def conn_bluez(self,hub_mac,controller): # Mit internem BLE-Interface verbinden (nur Linux)
self.backend = 'BlueZ'
# vor Instanzierung muss DeviceManger gestartet sein
logging.debug('BlueZ: DeviceManager Instanz erzeugen...')
dev_manager = gatt.DeviceManager(adapter_name=controller)
dman_thread = threading.Thread(target=dev_manager.run)
logging.debug('BlueZ: DeviceManager starten...')
dman_thread.start()
#sleep(1)
self.ble_iface=BlueZInterface(hub_mac,controller,dev_manager,dman_thread)
print('BlueZ-Interface gestartet. Bitte MoveHub einschalten!')
self.ble_iface.client_conn(hub_mac)
print('BlueZ-Interface unter Linux verbunden.')
def server_proc(pipe_to_plotter, pipe_to_cursor, mac_address):
global to_plotter
global to_cursor
to_plotter = pipe_to_plotter
to_cursor = pipe_to_cursor
print("server process started")
manager = gatt.DeviceManager(adapter_name='hci0')
hexiwear = HexiDevice(mac_address=mac_address, manager=manager)
hexiwear.connect()
manager.run()
def __init__(self, mac_address):
logger.debug("Init Gatt Adapter")
super().__init__(mac_address)
self.manager = gatt.DeviceManager("hci0")
self._device = Device(self.packet_collector,
mac_address=self.mac_address,
manager=self.manager)
self._device.connect()
self.ch_api_v2 = self._find_api_v2()
self.ch_api_v2.enable_notifications()
self._executor.submit(self.manager.run)
def __init__(self, mac_address=None, adapter_name='hci0', manager=None):
self.characteristic_changed = threading.Event()
if mac_address is None:
mac_address = self._DiscoveryManager(adapter_name).find_dripper()
if manager is None:
manager = gatt.DeviceManager(adapter_name)
self.manager_thread = threading.Thread(target=manager.run,
daemon=True)
self.manager_thread.start()
super().__init__(mac_address, manager)
self.connect()
self.characteristic_changed.wait()
self.characteristic_changed.clear()
def main():
if len(sys.argv) < 3:
print(f"USAGE: {sys.argv[0]} toggle|brightness|introspect macaddress args...", file=sys.stderr)
sys.exit(1)
mac_address = sys.argv[2]
# FIXME adapter_name should be configurable
manager = gatt.DeviceManager(adapter_name="hci0")
# this is a bit of a hack. gatt blocks indefinitely
b = Barrier(2)
device = HueLight(sys.argv[1], sys.argv[3:], mac_address=mac_address, manager=manager, barrier=b)
def run():
device.connect()
manager.run()
t = Thread(target=run, daemon=True)
t.start()
b.wait()
def connectWs(MACaddress):
class AnyDevice(gatt.Device):
def connect_succeeded(self):
super().connect_succeeded()
global status
status = "[" + self.mac_address + "] connected"
# manager.stop()
def connect_failed(self, error):
ga = 1
super().connect_failed(error)
global status
status = "[" + self.mac_address + "] connection failed: " + str(
error)
print(status)
manager.stop()
def services_resolved(self):
super().services_resolved()
device_information_service = next(
s for s in self.services
if s.uuid == '49535343-fe7d-4ae5-8fa9-9fafd205e455')
firmware_version_characteristic = next(
c for c in device_information_service.characteristics
if c.uuid == '49535343-1e4d-4bd9-ba61-23c647249616')
firmware_version_characteristic.enable_notifications()
firmware_version_characteristic.read_value()
def characteristic_value_updated(self, characteristic, value):
stringData = value.decode('utf-8').rstrip()
out = json.loads(stringData)
print(stringData)
#connectCloud(out)
fs.write(stringData + "\n")
fs.flush()
print("Connecting...")
manager = gatt.DeviceManager(adapter_name='hci0')
device = AnyDevice(manager=manager, mac_address=MACaddress)
device.connect()
manager.run()
return status
def __init__(self, mac_address):
logger.debug("Init Gatt Adapter")
super().__init__(mac_address)
self.manager = gatt.DeviceManager("hci0")
self._device = Device(
self.packet_collector, mac_address=self.mac_address, manager=self.manager)
self._device.connect()
ch_force_band = self._find_characteristic(SpheroCharacteristic.force_band.value)
ch_force_band.write_value(b"usetheforce...band")
self.ch_api_v2 = self._find_characteristic(SpheroCharacteristic.api_v2.value)
self.ch_api_v2.enable_notifications()
self._executor.submit(self.manager.run)
def __init__(self, mac_address, *args, **kwargs):
self.manager = gatt.DeviceManager(adapter_name='hci0')
self.logs = []
self.lock = Lock()
self.serial_master = None
self.serial_slave = None
self.first_read = True
self.device = BLEComm(self.logs,
self.lock,
False,
on_message_received=self.on_message_received,
manager=self.manager,
mac_address=mac_address)
self.device.connect()
self.blecomm_thread = Thread(target=self.manager.run)
self.blecomm_thread.start()
def read_HR_BLE_data(running_time):
manager = gatt.DeviceManager(adapter_name='hci0')
start = time.time()
class AnyDevice(gatt.Device):
def services_resolved(self):
super().services_resolved()
device_information_service = next(
s for s in self.services
if s.uuid == '0000180d-0000-1000-8000-00805f9b34fb')
# 0x2A37
firmware_version_characteristic = next(
c for c in device_information_service.characteristics
if c.uuid == '00002a37-0000-1000-8000-00805f9b34fb')
firmware_version_characteristic.read_value()
firmware_version_characteristic.enable_notifications()
def characteristic_value_updated(self, characteristic, value):
seconds = int(time.time())
rri = value[2] | value[3] << 8
rr = float(rri) / 1000 - 0
#print(str(seconds) + "," )
#print(value[1], " ", rr)
with open('HR_Data.csv', 'a') as pyfile:
pyfile.write(str(seconds) + ',')
with open("HR_Data.csv", 'a') as file:
writer = csv.writer(file, delimiter=',')
writer.writerow([str(value[1]), str(rr)])
end = time.time()
if (end - start) > (running_time):
self.disconnect()
print("Esp32 disconnected.")
self.manager.stop()
device = AnyDevice(mac_address='D0:41:AF:74:F6:F1', manager=manager)
device.connect()
print("Esp32 connected.")
manager.run()
def __init__(self,
mac_address=TOKYDOOR,
adapter_name='hci0',
command="ONCE",
uuid="",
database=None):
"""
Prepare the access to the door's BLE
:param mac_address: the BLE mac address
:param adapter_name: the Raspberry Pi's Bluettoth device name (check with 'hciconfig')
:param command: the coomand to send to the BLE on the characteristic uuid
:param uuid: characteristic to use to send the commad. Must be 'writable'.
:param database: optional - to log errors in table tb_log
"""
self.mac_address = mac_address
self.door_characteristic = uuid or TOKYUUID
self.command = command
self.adapter_name = adapter_name
self.manager = gatt.DeviceManager(adapter_name=self.adapter_name)
self.db = database
def main():
# Connect bluetooth
DEVICE1 = "00:3E:50:04:00:36"
DEVICE2 = "00:40:40:0C:00:4A"
global manager
global sum
manager = gatt.DeviceManager(adapter_name='hci0')
hexiwear1 = HexiDevice(mac_address=DEVICE1, manager=manager)
hexiwear1.connect()
# Multiprocessing client
#cli = Client(('192.168.56.1', 5005))
#cli = Client(('localhost',5005))
manager.run()
print("Gyro end")
return sum
def disconnectWs(MACaddress):
import gatt
class AnyDevice(gatt.Device):
def disconnect_succeeded(self):
super().disconnect_succeeded()
global status
status="[" + MACaddress + "] disconnected"
manager.stop()
print("Disconnecting...")
manager = gatt.DeviceManager(adapter_name='hci0')
device = AnyDevice(manager=manager, mac_address=MACaddress)
device.connect()
device.disconnect()
manager.run()
return status
def main(in_q, ble_out_q, ant_out_q):
# this starts discovery, calls manager.run() and returns manager.smartrowmac
#
macaddresssmartrower = smartrowreader.connecttosmartrow()
manager = gatt.DeviceManager(adapter_name='hci0')
smartrow = smartrowreader.SmartRow(mac_address=macaddresssmartrower,
manager=manager)
SRtoBLEANT = DataLogger(smartrow)
BC = threading.Thread(target=connectSR, args=(manager, smartrow))
BC.daemon = True
BC.start()
logger.info("SmartRow Ready and sending data to BLE and ANT Thread")
while not smartrow.ready():
sleep(0.2)
print("starting heart beat")
HB = threading.Thread(target=heartbeat, args=([smartrow]))
HB.daemon = True
HB.start()
sleep(
3
) # this sleep is needed in order give the user time to putt back the handle after pulling it to activate it.
# The SmartRow device is very sensitive to touches which then triggers 1 m very easy after a reset which then already starts after a restart.
reset(smartrow)
sleep(1)
SRtoBLEANT.Initial_reset = True # this should help to check if the first reset has been performed
while True:
if not in_q.empty():
ResetRequest_ble = in_q.get()
print(ResetRequest_ble)
reset(smartrow)
else:
pass
ble_out_q.append(SRtoBLEANT.WRValues)
ant_out_q.append(SRtoBLEANT.WRValues)
sleep(0.1)
def __init__(self, adapter_name):
# A quick way to test how often are issues causes by adapter naming
logger.debug("Using adapter (self.ble_adapter_name): %s" % adapter_name)
import subprocess
output = subprocess.check_output("hciconfig")
logger.debug("Adapter (from hciconfig): %s " % str(output.split()[0]))
self._adapter_name = adapter_name
self._gatt_manager = gatt.DeviceManager(self._adapter_name)
self._manager = nuimo.ControllerManager(self._adapter_name)
self._manager.listener = self
self._is_running = False # Prevents from considering D-Bus events if we aren't running
self._discovery_timeout_timer = None
self._connect_timeout_timer = None
self._controller = None
self._required_mac_address = None
self._discovery_duration = None
self._connect_duration = None
self._nuimo_connected = False
self._nuimo_onboarding_attempts = 0
# A control flag not to do any action while restart
# is underway
self._bt_restart_underway = False
def _restart_bluetooth(self):
"""
Restarts BlueZ and hard resets the BT module.
Sets the self._bt_restart_underway to false
to signal the end of bt restart.
It also reinitialises the python objects of this class
responsible for interacting with the underlying bt infrastructure.
"""
hard_reset_module_cmd = "systemctl restart enable-bt-module"
restart_bluez_cmd = "systemctl restart bluetooth"
logger.debug("Hard restarting systemd bluetooth related services")
subprocess.run(hard_reset_module_cmd.split())
subprocess.run(restart_bluez_cmd.split())
# Reinitialise the depend on the bt module
# Assumed this is needed, not confirmed
logger.debug("Reinitialisng python object after restart")
del self._gatt_manager
del self._manager
self._gatt_manager = gatt.DeviceManager(self._adapter_name)
self._manager = nuimo.ControllerManager(self._adapter_name)
# This smells like it could cause trouble.
# Do doubt it for it wasn't thought of deeply.
del self._manager.listener
self._manager.listener = self
self._controller = None
logger.debug("Powering BT module after restart")
self._manager.is_adapter_powered = True
self._bt_restart_underway = False
logger.info("Bluetooth restart done")
def init_bt_connect_start(dev_id, dev_address, adapter_dev):
"""
init_bt_connect_start 함수 설명
: Bt_dev에 connect 상태로 저장된 장치의 실제 데이터를 받아 Bt_data DB에 저장함
상세 설명
1. 정상적으로 연결될 경우 : CONNECTING (연결시도) -> CONNECTED (연결됨)
2. Bt_dev status에는 connect 인데 실제로 연결이 안되는 경우 : CONNECTING (연결시도) -> CONNECT FAILED (연결실패)
3. 블루투스 연결이 중간에 종료될 경우 : DISCONNECT (연결종료)
4. 비정상적 종료시 : CONNECT EXIT (연결 강제 종료)
5. services_resolved 함수에서 GATT 프로파일의 서비스를 불러오고 characteristic_value_updated 함수에서 characteristics의 값을 계속 읽는 방식
6. 블루투스 장치에서 예를들어 38.5,46.2,96.5 의 값으로 넘어오면 ','로 파싱해서 DB에 저장
"""
from .models import Bt_dev, Bt_data
from django.db.models import Q
import gatt
global exit_signal
manager = gatt.DeviceManager(adapter_name=adapter_dev)
class AnyDevice(gatt.Device):
def __init__(self, mac_address, manager, auto_reconnect=False):
super().__init__(mac_address=mac_address, manager=manager)
self.auto_reconnect = auto_reconnect
self.init_connect_flag = True
self.init_disconnect_flag = True
def connect(self):
print("[CONNECTING] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결중"))
super().connect()
def connect_succeeded(self):
super().connect_succeeded()
print("[CONNECTED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결완료"))
def connect_failed(self, error):
super().connect_failed(error)
print("[CONNECT FAILED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결실패"))
btdev = Bt_dev.objects.filter(bt_address=self.mac_address)
for btv in btdev: # disconnect 상태로 변경
btv.status='disconnect'
btv.save(update_fields=['status'])
if "{}@{}".format(dev_id, dev_address) in connect_list:
connect_list.remove("{}@{}".format(dev_id, dev_address))
manager.stop()
raise CustomError("{}@{}".format(dev_id, dev_address))
def disconnect_succeeded(self):
super().disconnect_succeeded()
print("[DISCONNECTED] {} : {} {} {}".format(model_dir, dev_id, dev_address, "연결종료"))
btdev = Bt_dev.objects.filter(bt_address=self.mac_address)
for btv in btdev: # disconnect 상태로 변경
btv.status='disconnect'
btv.save(update_fields=['status'])
if "{}@{}".format(dev_id, dev_address) in connect_list:
connect_list.remove("{}@{}".format(dev_id, dev_address))
if self.auto_reconnect:
self.connect()
manager.stop()
# raise CustomError("{}@{}".format(dev_id, dev_address))
# 5. services_resolved 함수에서 GATT 프로파일의 서비스 정보를 볼러옴
def services_resolved(self):
super().services_resolved()
device_information_service = next(
s for s in self.services
if s.uuid == '0000ffe0-0000-1000-8000-00805f9b34fb')
device_bluetooth_data = next(
c for c in device_information_service.characteristics
if c.uuid == '0000ffe1-0000-1000-8000-00805f9b34fb')
device_bluetooth_data.enable_notifications()
device_bluetooth_data.read_value()
# 5-1. 매칭된 서비스의 characteristics의 값을 계속 읽어옴
def characteristic_value_updated(self, characteristic, value):
try:
if value==b'\x01' and self.init_connect_flag==True: # 초기 값 버림
self.init_connect_flag=False
elif value==b'/' and self.init_connect_flag==True: # 초기 값 버림
self.init_connect_flag=False
elif value==b'v' and self.init_connect_flag==True: # 초기 값 버림
self.init_connect_flag=False
elif value==b'\r' and self.init_connect_flag==True: # 초기 값 버림
self.init_connect_flag=False
else:
# 6. 블루투스에서 예를 들어 38.5,46.2,96.5 의 값으로 넘어오면 ','로 파싱해서 Bt_data DB에 저장
new_bt_data = value.decode('utf-8').rstrip().strip()
new_bt_data_sp=new_bt_data.split(',')
new_btd = Bt_data(bt_id=dev_id, temp=float(new_bt_data_sp[0]), bpm=float(new_bt_data_sp[1]), battery=float(new_bt_data_sp[2]))
new_btd.save() # DB에 저장
print("[UPDATE] {} : {} {}".format(model_dir, dev_id, new_bt_data))
except:
print("[UPDATE FAIL] {} {} {}".format(model_dir, dev_id, value )) # 디버깅용
try:
device = AnyDevice(mac_address=dev_address, manager=manager, auto_reconnect=False)
device.connect()
manager.run()
except (CustomError, KeyboardInterrupt, SystemExit):
if "{}@{}".format(dev_id, dev_address) in connect_list:
connect_list.remove("{}@{}".format(dev_id, dev_address))
manager.stop()
def disconnect_succeeded(self):
"""Print the mac adress of the device disconnected
"""
super().disconnect_succeeded()
print("[%s] Disconnected" % (self.mac_address))
def services_resolved(self):
"""Print the services and its characteristics if they are similar to the Lego Hub UUID
"""
super().services_resolved()
print("[%s] Resolved services" % (self.mac_address))
for service in self.services:
if service == LEGO_Hub_Service:
print("[%s] Service [%s]" % (self.mac_address, service.uuid))
for characteristic in service.characteristics:
if str(characteristic.uuid) == LEGO_Hub_Characteristic:
print("[%s] Characteristic [%s]" %
(self.mac_address, characteristic.uuid))
# Initialize the manager with the hci0 adaptater
manager = gatt.DeviceManager(adapter_name='hci0')
# Create the device
device = AnyDevice(mac_address='90:84:2B:50:36:43', manager=manager)
# Connect self to device
device.connect()
# The main loop that is necessary to receive Bluetooth events from the Bluetooth adapter
manager.run()
# It can be stopped by executing the stop() method
def __init__(self, adapter_name, device_mac):
self.manager = gatt.DeviceManager(adapter_name)
self.device_mac = device_mac
self._connect()
import gatt
manager = gatt.DeviceManager(adapter_name='hci0') # defines the device
class AnyDevice(gatt.Device):
def connect_succeeded(self):
super().connect_succeeded()
print("[%s] Connected" % (self.mac_address))
def connect_failed(self, error):
super().connect_failed(error)
print("[%s] Connection failed: %s" % (self.mac_address, str(error)))
def disconnect_succeeded(self):
super().disconnect_succeeded()
print("[%s] Disconnected" % (self.mac_address))
def services_resolved(self):
super().services_resolved()
print("[%s] Resolved services" % (self.mac_address))
for service in self.services:
print("[%s] Service [%s]" % (self.mac_address, service.uuid))
for characteristic in service.characteristics:
print("[%s] Characteristic [%s]" % (self.mac_address, characteristic.uuid))
device = AnyDevice(mac_address='AA:BB:CC:DD:EE:FF', manager=manager)
device.connect()
manager.run()
