class bluetooth:
def __init__(self):
self.bluetooth = Bluetooth()
self.bluetooth.set_advertisement(name=ble_device_name,
manufacturer_data=manufacturer_data,
service_data=None,
service_uuid=private_UUID)
self.bluetooth.advertise(True)
#service_acc
self.service_acc = self.bluetooth.service(uuid=service_acc_UUID,
isprimary=True,
nbr_chars=3,
start=True)
self.character_acc_x = self.service_acc.characteristic(
uuid=character_acc_x_UUID, properties=None, value=33)
self.character_acc_y = self.service_acc.characteristic(
uuid=character_acc_y_UUID, properties=None, value=34)
self.character_acc_z = self.service_acc.characteristic(
uuid=character_acc_z_UUID, properties=None, value=35)
def updateValue(self, accelerate=None, gps=None):
if (accelerate != None):
float_bytes = struct.pack('f', accelerate[0])
#print(float_bytes)
print(accelerate[0], accelerate[1], accelerate[2])
total_bytes = b''
total_bytes = struct.pack('<f', accelerate[0]) + struct.pack(
'<f', accelerate[1]) + struct.pack(
'<f', accelerate[2]) + struct.pack(
'<f', gps[0]) + struct.pack('<f', gps[1])
self.character_acc_x.value(total_bytes)
self.character_acc_y.value(total_bytes)
self.character_acc_z.value(total_bytes)
def init(callback):
bt = Bluetooth()
bt.set_advertisement(name='LoPy', service_uuid=b'1234567890123456')
bt.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=callback)
bt.advertise(True)
def run(self):
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='LoPy',
service_uuid=b'1234567890123456')
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=self.conn_cb)
bluetooth.advertise(True)
#Create a new service on the internal GATT server. Returns a object of type BluetoothServerService.
srv1 = bluetooth.service(
uuid=self.uuid2bytes('00001819-0000-1000-8000-00805f9b34fb'),
isprimary=True)
#Creates a new characteristic on the service. Returns an object of the class GATTSCharacteristic
self.char1 = srv1.characteristic(
uuid=self.uuid2bytes('00002a67-0000-1000-8000-00805f9b34fb'),
properties=Bluetooth.PROP_BROADCAST | Bluetooth.PROP_INDICATE,
value=1)
#Creates a callback that will be executed when any of the triggers occurs
char1_cb = self.char1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=self.char1_cb_handler)
def setup_ble():
bt = Bluetooth()
if C.BLE_ENABLED:
bt.set_advertisement(name="LoPy")
bt.advertise(True)
else:
bt.deinit()
class ble:
def __init__(self):
self.bluetooth = Bluetooth()
self.bluetooth.set_advertisement(name=ble_device_name,
manufacturer_data=manufacturer_data,
service_data=None,
service_uuid=private_UUID)
self.bluetooth.advertise(True)
#service
self.service_acc = self.bluetooth.service(uuid=service_acc_UUID,
isprimary=True,
nbr_chars=3,
start=True)
self.character_acc_x = self.service_acc.characteristic(
uuid=character_acc_x_UUID, properties=None, value=33)
self.character_acc_y = self.service_acc.characteristic(
uuid=character_acc_y_UUID, properties=None, value=34)
self.character_acc_z = self.service_acc.characteristic(
uuid=character_acc_z_UUID, properties=None, value=35)
def updateValue(self, accelerate=None):
if (accelerate != None):
self.character_acc_x.value(accelerate[0])
self.character_acc_y.value(accelerate[1])
self.character_acc_z.value(accelerate[2])
def gatt_connect():
global ble
ble = Bluetooth()
ble.set_advertisement(name='SiPy')
ble.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=con_cb)
ble.advertise(True)
class PyBluetooth:
def __init__(self, name, serviceUUID):
self._bt = Bluetooth()
self.setAdvertisement(name=name, serviceUUID=serviceUUID)
self._bt.callback(trigger=Bluetooth.CLIENT_CONNECTED,
handler=self.onClientConnect,
arg=self)
self._bt.callback(trigger=Bluetooth.CLIENT_DISCONNECTED,
handler=self.onClientConnect,
arg=self)
self._services = {}
def __del__(self):
self._bt.disconnect_client()
def addService(self, uuid, characteristicNumber=0, isPrimary=False):
self._services[uuid] = self._bt.service(self.formatUUID(uuid),
nbr_chars=characteristicNumber,
isprimary=True)
return self._services[uuid]
def getService(self, uuid):
return self._services[uuid]
def setAdvertisement(self,
name,
manufacturerData=None,
serviceData=None,
serviceUUID=None):
self._name = name
if serviceUUID != None:
serviceUUID = self.formatUUID(serviceUUID)
self._bt.set_advertisement(name=name,
manufacturer_data=manufacturerData,
service_data=serviceData,
service_uuid=serviceUUID)
def startAdvertisement(self):
self._bt.advertise(True)
def stopAdvertisement(self):
self._bt.advertise(False)
def formatUUID(self, uuid):
uuid = uuid.encode().replace(b'-', b'')
tmp = binascii.unhexlify(uuid)
return bytes(reversed(tmp))
def onClientConnect(self):
events = self._bt.events()
print("[" + self._name + "]: Client connected")
pycom.heartbeat(False)
pycom.rgbled(0x110011)
def onClientDisconnect(self):
print("[" + self._name + "]: Client disconnected")
pycom.heartbeat(True)
def BlueToothFun():
global deviceID
global connectionCounter
#Also act as a server
pycom.heartbeat(False)
bluetooth = Bluetooth() #create a bluetooth object
bluetooth.set_advertisement(name='LoPyServer1',
service_uuid=b'1234567890123456')
#using callback conn_cb to check client's connection
##Function: conn_cb(callback for bluetooth object events checking)
##Description:check there is any client connected to the service
def conn_cb(bt_o):
events = bt_o.events(
) #using events to check if there is any client connected to the service
if events & Bluetooth.CLIENT_CONNECTED:
print("Client connected")
pycom.rgbled(0x007f00) # green
elif events & Bluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
pycom.rgbled(0x7f0000) # red
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
#
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=b'1234567890123456', isprimary=True)
chr1 = srv1.characteristic(uuid=b'ab34567890123456', value=5)
#char1_read_counter = 0
def char1_cb_handler(chr):
#global char1_read_counter
#char1_read_counter += 1
global connectionCounter
events = chr.events()
if events & Bluetooth.CHAR_WRITE_EVENT:
print("Write request with value = {}".format(chr.value()))
else:
#modify here to send message to other clients
#connectionCounter += 1
return str(deviceID)
#using the callback to send the data to other clients
char1_cb = chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char1_cb_handler)
'''srv2 = bluetooth.service(uuid=1234, isprimary=True)
def BLEServer():
###### Second, set up BLE server service ######
pycom.heartbeat(False)
bluetooth = Bluetooth() #create a bluetooth object
bluetooth.set_advertisement(name='LoPyServer' + str(globalvar.device_id),
service_uuid=b'3333333333333333')
#using callback conn_cb to check client's connection
##Function: conn_cb(callback for bluetooth object events checking)
##Description:check there is any client connected to the service
def conn_cb(bt_o):
events = bt_o.events(
) #using events to check if there is any client connected to the service
if events & Bluetooth.CLIENT_CONNECTED: #2
print("Client connected")
pycom.rgbled(0x007f00) # green
elif events & Bluetooth.CLIENT_DISCONNECTED: #4
bt_o.disconnect_client()
print("Client disconnected")
pycom.rgbled(0x7f0000) # red
time.sleep(3)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
#set up BLE service
srv1 = bluetooth.service(uuid=b'3333333333333333', isprimary=True)
#set up service character
chr1 = srv1.characteristic(uuid=b'3333333333333333',
properties=Bluetooth.PROP_READ
| Bluetooth.PROP_WRITE,
value=5)
#char1_read_counter = 0
def char1_cb_handler(chr):
#global char1_read_counter
#char1_read_counter += 1
global BLEConnectionCounter
events = chr.events()
print('events is ' + str(events))
if events & Bluetooth.CHAR_WRITE_EVENT: #16
print("Write request with value = {}".format(chr.value()))
elif events & Bluetooth.CHAR_READ_EVENT: #8
#modify here to send its device_id to other clients
BLEConnectionCounter += 1
return str(globalvar.device_id) + ' ' + str(BLEConnectionCounter)
#using the callback to send the data to other clients
chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char1_cb_handler)
class BLEGATTS:
def __init__(self):
self.bt_inst = None
self.advert_name = None
self.connect_callback = None
self.is_connected = False
self.services = { }
def _connection_handler(self, bt):
events = bt.events()
if events & Bluetooth.CLIENT_CONNECTED:
self.is_connected = True
if self.connect_callback:
self.connect_callback(self.is_connected)
elif events & Bluetooth.CLIENT_DISCONNECTED:
self.is_connected = False
if self.connect_callback:
self.connect_callback(self.is_connected)
def init(self, advert_name, connect_callback = None):
self.bt_inst = Bluetooth(id=0,antenna=Bluetooth.INT_ANT)
self.advert_name = advert_name
self.connect_callback = connect_callback
self.bt_inst.set_advertisement(name=self.advert_name, manufacturer_data=None, service_data=None, service_uuid=None)
self.bt_inst.callback(trigger=Bluetooth.CLIENT_CONNECTED|Bluetooth.CLIENT_DISCONNECTED, handler=self._connection_handler)
def advertise(self, toggle=True):
self.bt_inst.advertise(toggle)
def disconnect(self):
if self.is_connected:
self.bt_inst.disconnect_client()
def deinit(self):
#TODO: stop services
self.disconnect()
self.bt_inst.deinit()
def addService(self, service_name, uuid):
self.services[service_name] = BLEGATTSService(self.bt_inst, uuid)
return self.services[service_name]
def getService(self, service_name):
return service_name in self.services and self.services[service_name] or None
def setCharValue(self, svc_name, char_name, value):
if self.is_connected and svc_name in self.services and char_name in self.services[svc_name].characteristics:
#print ('%s:%s=%s' % (svc_name,char_name,str(value)))
self.services[svc_name].characteristics[char_name].setValue(value)
def __init__(self, mesh_mac):
self.status = {
'connected' : False
}
bluetooth = Bluetooth(modem_sleep=False)
bluetooth.set_advertisement(name='PyGo (mac:' + str(mesh_mac) + ')', service_uuid=0xec00)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=self.conn_cb)
bluetooth.advertise(True)
srv_rx = bluetooth.service(uuid=0xec00, isprimary=True)
self.chr_rx = srv_rx.characteristic(uuid=0xec0e, value=0)
srv_tx = bluetooth.service(uuid=0xed00, isprimary=True)
self.chr_tx = srv_tx.characteristic(uuid=0xed0e, value=0)
self.unpacker = None
def connect(self):
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='Blynk')
def conn_cb(bt):
events = bt.events()
if events & Bluetooth.CLIENT_CONNECTED:
self.bout = b''
print("Client connected")
elif events & Bluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
BlynkProtocol.disconnect(self)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
nus = bluetooth.service(
uuid=unhex('6E400001-B5A3-F393-E0A9-E50E24DCCA9E'),
isprimary=True,
nbr_chars=2)
self.rx = nus.characteristic(
uuid=unhex('6E400002-B5A3-F393-E0A9-E50E24DCCA9E'),
properties=Bluetooth.PROP_WRITE | Bluetooth.PROP_WRITE_NR,
value='')
self.tx = nus.characteristic(
uuid=unhex('6E400003-B5A3-F393-E0A9-E50E24DCCA9E'),
properties=Bluetooth.PROP_READ | Bluetooth.PROP_NOTIFY,
value='')
bluetooth.advertise(True)
def rx_cb(chr):
data = chr.value()
print('>', data)
self.process(bytes(data))
def tx_subsc(chr):
print("Client subscribed", chr)
BlynkProtocol.connect(self, login=False)
self.tx.callback(trigger=Bluetooth.CHAR_SUBSCRIBE_EVENT,
handler=tx_subsc)
self.rx.callback(trigger=Bluetooth.CHAR_WRITE_EVENT, handler=rx_cb)
def _init(self):
self.status = {'connected': False}
bluetooth = Bluetooth(modem_sleep=False)
adv_name = self.ble_name
bluetooth.set_advertisement(name=adv_name, service_uuid=0xec00)
print("BLE name:", adv_name)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=self.conn_cb)
bluetooth.advertise(True)
srv_rx = bluetooth.service(uuid=0xec00, isprimary=True)
self.chr_rx = srv_rx.characteristic(uuid=0xec0e, value=0)
srv_tx = bluetooth.service(uuid=0xed00, isprimary=True)
self.chr_tx = srv_tx.characteristic(uuid=0xed0e, value=0)
self.unpacker = None
class Blues:
# Initialization method.
def __init__(self):
print('Advertising Bluetooth...')
self.mBluetooth = Bluetooth()
self.mEvents = self.mBluetooth.events()
# self.mBluetooth.init([id=0, mode=Bluetooth.BLE, antenna=Bluetooth.INT_ANT, modem_sleep=False, pin=None, privacy=True, secure_connections=True, mtu=200])
self.mBluetooth.set_advertisement(
name='FiPy', service_uuid=2)
self.mBluetooth.callback(trigger=self.mBluetooth.CLIENT_CONNECTED |
self.mBluetooth.CLIENT_DISCONNECTED, handler=self.Connection)
self.mBluetooth.advertise(True)
# Create Service & Characteristic
self.CreateServChar()
self.mCharacteristic.callback(
trigger=self.mBluetooth.CHAR_WRITE_EVENT | self.mBluetooth.CHAR_READ_EVENT, handler=self.CharCallback)
# Connection method: Used as callback function to detect a BLE connection.
def Connection(self, zResponse):
self.mEvents = zResponse.events()
if self.mEvents & self.mBluetooth.CLIENT_CONNECTED:
print("Client connected")
elif self.mEvents & self.mBluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
def CreateServChar(self):
# Create service and characteristic
self.mService = self.mBluetooth.service(
uuid=3, isprimary=True)
self.mCharacteristic = self.mService.characteristic(
uuid=31, properties=self.mBluetooth.PROP_WRITE | self.mBluetooth.PROP_READ, value=6)
def CharCallback(self, chr, zResponse):
self.mEvents, value = zResponse
if self.mEvents & self.mBluetooth.CHAR_READ_EVENT:
print("Read from Char = {}".format(value))
if self.mEvents & self.mBluetooth.CHAR_WRITE_EVENT:
print("Written to Char = {}".format(value))
def startSending(dataList: list, callback, shouldClear):
global data
global call
global bluetooth
global clear
clear = shouldClear
call = callback
pycom.rgbled(0x70000ff)
data = dataList
print("data" + str(data))
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='Loy', service_uuid=b'1234567890123456')
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=b'serviceA90123456', isprimary=True)
srv2 = bluetooth.service(uuid=b'serviceB90123456', isprimary=True)
srv3 = bluetooth.service(uuid=b'serviceC90123456', isprimary=True)
srv4 = bluetooth.service(uuid=b'serviceD90123456', isprimary=True)
chr1 = srv1.characteristic(uuid=b'temp567890123456', value="")
chr2 = srv2.characteristic(uuid=b'light67890123456', value="")
chr3 = srv3.characteristic(uuid=b'time567890123456', value="")
chr4 = srv4.characteristic(uuid=b'id34567890123456', value="")
chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char1_cb_handler)
chr2.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char2_cb_handler)
chr3.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char3_cb_handler)
chr4.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char4_cb_handler)
def bt_check(self):
av = AV()
av.blue()
bluetooth = Bluetooth()
bluetooth.set_advertisement(name=BLE_DEVICE_NAME,
manufacturer_data=BLE_DEVICE_NAME,
service_uuid=0001)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=0001, isprimary=True)
chr1 = srv1.characteristic(uuid=0002, value=5)
if self.config["state"] == 0:
lock_state = 0
else:
lock_state = 1
def char1_cb_handler(chr):
if chr.value() == bytes(BLE_SECRET_KEY, "utf-8"):
if self.config["state"] == 0:
self.lock()
av.locked()
return 'good'
else:
self.unlock()
av.unlocked()
return 'good'
srv2 = bluetooth.service(uuid=0003, isprimary=True)
chr2 = srv2.characteristic(uuid=0004, value=lock_state)
char1_cb = chr2.callback(trigger=Bluetooth.CHAR_WRITE_EVENT,
handler=char1_cb_handler)
time.sleep(20)
av.off()
bluetooth.advertise(False)
class BLE():
# This class initializes the BLE mode in the fipy and also checks
# if the BLE mode param is on or not
def __init__(self, name, uuid):
self.ble = Bluetooth()
self.ble.set_advertisement(name=name, service_uuid=uuid)
self.setup()
def connect_cb(self, bt_o):
# callback for connection
print('enter connect_cb\n')
events = bt_o.events()
if events & Bluetooth.CLIENT_CONNECTED:
print("Client connected")
elif events & Bluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
self.string = ""
def setup(self):
# sets up all the services and characteristics
print("Enter Setup\n")
self.ble.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=self.connect_cb)
self.ble.advertise(True)
# main service switches
config_service = self.ble.service(uuid=0xfff0, isprimary=True, nbr_chars=1)
# main service
self.message = config_service.characteristic(uuid=0xfff0, value=0)
# nvram declarations
self.string = ""
pycom.nvs_set('id', 0)
pycom.nvs_set('mode', 0)
pycom.nvs_set('wifi', 0)
pycom.nvs_set('mqtt', 0)
pycom.nvs_set('lora', 0)
pycom.nvs_set('ssid', 0)
pycom.nvs_set('pass', 0)
pycom.nvs_set('server', 0)
pycom.nvs_set('port', 0)
pycom.nvs_set('appSkey', 0)
pycom.nvs_set('nwkSkey', 0)
pycom.nvs_set('temp_sensor', 0)
pycom.nvs_set('temp_f', 0)
pycom.nvs_set('accl_sensor', 0)
pycom.nvs_set('accl_f', 0)
pycom.nvs_set('alt_sensor', 0)
pycom.nvs_set('alt_f', 0)
pycom.nvs_set('light_sensor', 0)
pycom.nvs_set('light_f', 0)
# callbacks to deploy_handler which will use the switch_dict to switch between chars
msg_cb = self.message.callback(trigger=Bluetooth.CHAR_WRITE_EVENT | Bluetooth.CHAR_READ_EVENT, handler=self.msg_handler)
# restart details callback)
print("waiting for callback")
def msg_handler(self,chr):
print("Entered msg_handler\n")
# handles write and read requests from the client
print(chr.value())
events = chr.events()
if events & Bluetooth.CHAR_WRITE_EVENT:
msg = chr.value().decode('utf-8')
self.string += msg
print("string is" + self.string)
if msg[len(msg)-2:] == '>e':
self.list = []
self.list = self.string[:len(self.string)-2].split(";")
msg_list = msg[1:len(msg)-2].split(";")
print(self.list)
self.execute(self.list)
return # device should reset after this
elif events & Bluetooth.CHAR_READ_EVENT:
NvsStore('deveui', binascii.hexlify(LoRa().mac()).decode('utf-8'))
return binascii.hexlify(LoRa().mac()).decode('utf-8')
def execute(self, msg_list):
for x in range(len(msg_list)):
if msg_list[x] == '':
msg_list[x] = '0'
print(msg_list)
print("count" + str(len(msg_list)))
if len(msg_list) == 15:
NvsStore('id', msg_list[0])
if msg_list[2] == "1":
NvsStore('wifi', msg_list[2])
NvsStore('ssid', msg_list[5])
NvsStore('pass', msg_list[6])
else:
pycom.nvs_set('wifi', 0)
if msg_list[3] == "1":
NvsStore('mqtt', msg_list[3])
NvsStore('server', msg_list[7])
NvsStore('port', msg_list[8])
else:
pycom.nvs_set('mqtt', 0)
if msg_list[4] == "1":
NvsStore('lora', msg_list[4])
NvsStore('appskey', msg_list[9])
NvsStore('nwkskey', msg_list[10])
else:
pycom.nvs_set('mqtt', 0)
if msg_list[11] != 0:
NvsStore('temp_sensor', '1')
NvsStore('temp_f', msg_list[11])
else:
pycom.nvs_set('temp_sensor', 0)
if msg_list[12] != 0:
NvsStore('alt_sensor', '1')
NvsStore('alt_f', msg_list[12])
else:
pycom.nvs_set('alt_sensor', 0)
if msg_list[13] != 0:
NvsStore('accl_sensor', '1')
NvsStore('accl_f', msg_list[13])
else:
pycom.nvs_set('accl_sensor', 0)
if msg_list[14] != 0:
NvsStore('light_sensor', '1')
NvsStore('light_f', msg_list[14])
else:
pycom.nvs_set('light_sensor', 0)
if int(msg_list[2]) + int(msg_list[4]) == 0:
print("YAS")
NvsStore('mode', 0)
NvsStore('mode', msg_list[1])
pycom.rgbled(0xffffff)
time.sleep(2)
pycom.rgbled(0x000000)
print("ENTERING DEPLOY MODE IN 5 seconds")
time.sleep(5)
machine.reset()
else:
print("INCORRECT DATA STREAM")
self.string = ""
#=============================================================================== # This is a simple script that will provide a value to be read over BLE # # For macOS you can use the LightBlue app to observe # # service characteristics are a maximum 2 bytes in size (i.e. 0xFFFF is the max value) #=============================================================================== from network import Bluetooth import pycom import machine #=============================================================================== pycom.heartbeat(False) #=============================================================================== bluetooth = Bluetooth() bluetooth.set_advertisement(name='LoPy',manufacturer_data='Pycom', service_data='Blutooth Low Energy') bluetooth.start_scan(-1) # scan forever pycom.rgbled(0x00007f) # Blue #=============================================================================== init_value = 0x20 char1_read_counter = 0 #=============================================================================== # UUID are READ LSB first (little endian) # i.e. # b'BLUTOOTH_SERVICE' = b'424c55544f4f54485f53455256494345' # will appear as 45434956-5245-535F-4854-4F4F54554C42 b'BLUTOOTH_SERVICE' srv1 = bluetooth.service(uuid=b'BLUTOOTH_SERVICE', isprimary=True) char1 = srv1.characteristic(uuid=b'CHARACTERISTIC!!', value=40) char1.value(init_value) #=============================================================================== def char1_cb_handler(char1):
from network import Bluetooth
import machine
import socket
import pycom
import binascii
import network
from network import WLAN
from machine import RTC
bluetooth = Bluetooth()
bluetooth.set_advertisement(name="lopy2", manufacturer_data="lopy_v2")
bluetooth.start_scan(
-1) #Change to 10 to have it searching for 10 sec instead if forever
#bluetooth.stop_scan()
adv = None
bluetooth.advertise(True)
while True:
adv = bluetooth.get_adv()
if adv and bluetooth.resolve_adv_data(adv.data,
Bluetooth.ADV_NAME_CMPL) == 'lopy1':
try:
bluetooth.connect(adv.mac)
print(
bluetooth.resolve_adv_data(adv.data, Bluetooth.ADV_APPEARANCE))
print("Connected to device with addr = {}".format(
binascii.hexlify(adv.mac)))
#bluetooth.connect(adv.mac)
elif events & Bluetooth.CHAR_READ_EVENT:
if True:
#if char1_read_counter < 3:
print('Read request on char 2')
else:
return 'ABC DEF'
#
# mkfifo ~/myfifo
# while sleep 1; do socat /dev/ttyACM1,b115200,echo=0,raw ~/myfifo; done &
# minicom -o -D ~/myfifo
bluetooth = Bluetooth()
bluetooth.set_advertisement(
name='gpy4gcam',
service_uuid=uuid2bytes('d9293538-3087-11ea-aec2-2e728ce88125'))
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
# srv1 = bluetooth.service(uuid=uuid2bytes('d9293538-3087-11ea-aec2-2e728ce88125'), isprimary=True, nbr_chars=2)
srv1 = bluetooth.service(uuid=0xAA1, isprimary=True, nbr_chars=2)
cv = '2020-01-01 00:00:00'
chr1 = srv1.characteristic(uuid=0xaaa1, value=cv)
chr2 = srv1.characteristic(uuid=0xaaa2, value=9)
char1_cb = chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char1_cb_handler)
char2_cb = chr2.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
related to a vehicle
- 1. Shows the status of car doors
- 2. It receives the bluetooth cmds to open/close all doors
- 3. It receives the bluetooth cmds to open/close back door throw proximity sensor
"""
# Broadcasting BLE and stablish connection
from network import Bluetooth
import time
import machine
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='PyWagenHub',
manufacturer_data='manufacturer data',
service_uuid=b'1234567890123456')
service = bluetooth.service(b'1234567890123457',
isprimary=True,
nbr_chars=1,
start=True)
def conn_cb(bt_o):
events = bt_o.events(
) # This method returns the flags and clears the internal registry
print(events)
if events & Bluetooth.CLIENT_CONNECTED:
print("Client connected")
elif events & Bluetooth.CLIENT_DISCONNECTED:
global char1_read_counter
char1_read_counter += 1
events = chr.events()
if events & Bluetooth.CHAR_WRITE_EVENT:
print("Write request with value = {}".format(chr.value()))
else:
if True:
#if char1_read_counter < 3:
print('Read request on char 1')
else:
return 'ABC DEF'
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='gpy4gcam', service_uuid=1)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=1, isprimary=True, start=False)
cv = '2020-01-01 00:00:00'
chr1 = srv1.characteristic(uuid=2, value=cv)
char1_cb = chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT
| Bluetooth.CHAR_READ_EVENT,
handler=char1_cb_handler)
srv1.start()
def chr1_update(Now):
end='')
# If an OEM controller is found start by reading the heater data.
if OEM_CONTROLLER_CONNECTED:
start_state = get_heater_data
else:
start_state = send_controller_data
print("Start State:{} ".format(start_state))
main_protocol_thread = _thread.start_new_thread(protocol_state_machine,
(start_state, 1))
bluetooth = Bluetooth()
service_uuid = util.uuid2bytes('00002A6E00001000800000805F9B34FB')
bluetooth.set_advertisement(name='Comfort', service_uuid=service_uuid)
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=service_uuid, isprimary=True, nbr_chars=2)
heater_ch = srv1.characteristic(
uuid=util.uuid2bytes('00001AEF00001000800000805F9B34FB'),
properties=Bluetooth.PROP_NOTIFY,
value=0)
controller_ch = srv1.characteristic(
"big") # get the value from the payload
setServoPwn(currentAngle) # set the servo to the right position
chr1.value(
currentAngle) # update the value that is displayed over Bluetooth
print("Set new angle: ", currentAngle)
# Function to caculate the pwm value for the angle given.
def setServoPwn(angle):
servo.duty_cycle(
((angle / 180) * 0.05) +
0.05) # calculate the right value for PWM based on the angle given
bluetooth = Bluetooth() # Get a bluetooth instance
bluetooth.set_advertisement(name='FyPi') # Set the name
bluetooth.callback(
trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb) # set up the callbacks for connect and disconnect events
bluetooth.advertise(True) # advertise the device
print("Started BLE")
srv1 = bluetooth.service(
uuid=0x1815, isprimary=True
) # set up the service to display the current angle of the servo
chr1 = srv1.characteristic(
uuid=0x2763,
value=currentAngle) # set up the characteristic to get the server angle
char1_cb = chr1.callback(trigger=Bluetooth.CHAR_WRITE_EVENT,
handler=char1_cb_handler
""" Module de la LoPy effe, elle joue le rôle du serveur bluetooth"""
from network import Bluetooth
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='Effe', service_uuid=b'1234567890123456')
def conn_cb(bt_o):
events = bt_o.events(
) # this method returns the flags and clears the internal registry
if events & Bluetooth.CLIENT_CONNECTED:
print("Client connected")
elif events & Bluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED
| Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=b'1234567890123456', isprimary=True)
chr1 = srv1.characteristic(uuid=b'ab34567890123456', value=5)
def char1_cb(chr):
print("Write request with value = {}".format(chr.value()))
from pysense import Pysense
from LIS2HH12 import LIS2HH12
from SI7006A20 import SI7006A20
from LTR329ALS01 import LTR329ALS01
from MPL3115A2 import MPL3115A2,ALTITUDE,PRESSURE
from secrets import WIFISSID, WIFIPASS
wdt = machine.WDT(timeout=300000)
py = Pysense()
mp = MPL3115A2(py,mode=ALTITUDE) # Returns height in meters. Mode may also be set to PRESSURE, returning a value in Pascals
si = SI7006A20(py)
lt = LTR329ALS01(py)
li = LIS2HH12(py)
bt = Bluetooth()
bt.set_advertisement(name="pycom")
bt.advertise(True)
while True:
wdt.feed()
bt.start_scan(10)
while bt.isscanning():
time.sleep_ms(100)
advs = bt.get_advertisements()
devices = set()
devicetypes = dict()
for adv in advs:
if adv.mac in devices:
continue
devices.add(adv.mac)
print("MAC: "+str(ubinascii.hexlify(adv.mac)))
from network import Bluetooth
import binascii
import time
bt = Bluetooth()
bt.set_advertisement(name="lopy1", manufacturer_data="lopy_v1")
# scan until we can connect to any BLE device around
bt.start_scan(-1)
while True:
adv = bt.get_adv()
if adv and bt.resolve_adv_data(adv.data,
Bluetooth.ADV_NAME_CMPL) == 'lopy2':
try:
conn = bt.connect(adv.mac)
services = conn.services()
for service in services:
time.sleep(0.050)
if type(service.uuid()) == bytes:
print('Reading chars from service = {}'.format(
service.uuid()))
else:
print('Reading chars from service = %x' % service.uuid())
chars = service.characteristics()
for char in chars:
if (char.properties() & Bluetooth.PROP_READ):
print('char {} value = {}'.format(
char.uuid(), char.read()))
conn.disconnect()
break
except:
print("Error while connecting or reading from the BLE device")
from machine import Pin
import pycom
import time
from network import Bluetooth
bluetooth = Bluetooth()
bluetooth.set_advertisement(name='FiPy', service_uuid=0xffffff01234)
def conn_cb (bt_o):
events = bt_o.events()
if events & Bluetooth.CLIENT_CONNECTED:
print("Client connected")
elif events & Bluetooth.CLIENT_DISCONNECTED:
print("Client disconnected")
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)
bluetooth.advertise(True)
srv1 = bluetooth.service(uuid=0xfff0, isprimary=True)
chr1 = srv1.characteristic(uuid=0x1000, value="ssid")
def char1_cb_handler(chr):
events = chr.events()
if events & Bluetooth.CHAR_WRITE_EVENT:
chr1.value(chr.value())
print("Write request with value = {}".format(chr.value()))
else:
return chr1.value()
bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=conn_cb)
#BLE
bluetooth.deinit()
wlan.deinit()
lora.power_mode(LoRa.SLEEP)
bluetooth = Bluetooth()
pycom.heartbeat(False)
pycom.rgbled(0x000077)
print('sending BT')
bluetooth.set_advertisement(name='LoPy', service_uuid=b'1234567890abcdef')
bluetooth.advertise(True)
time.sleep(8)
#micro
bluetooth.deinit()
wlan.deinit()
lora.power_mode(LoRa.SLEEP)
pycom.rgbled(0x000000)
h = 0
for i in range (300000):
h = h+1;
#WIFI
# print('.', end='')
def char21_cb_handler(chr, data):
print("char2_cb_handler")
# The value is not used in this callback as the WRITE events are not processed.
events, value = data
if events & Bluetooth.CHAR_READ_EVENT:
print('Read request on char 2')
print("init")
bt = Bluetooth()
bt.set_advertisement(
name='Pycom BT test server5',
service_uuid=666,
manufacturer_data=b'deadbeef',
service_data=b'cafebabe'
) # bytes([0xC0, 0x01, 0xD0, 0x0D, 0xC0, 0x01, 0xD0, 0x0D, 0xC0, 0x01, 0xD0, 0x0D, 0xC0, 0x01, 0xD0, 0x0D, ])) # b'1234567890123456')
bt.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED,
handler=conn_cb)
print("service 1")
srv1 = bt.service(
isprimary=True, uuid=1
) # bytes([0xCA, 0xFE, 0xBA, 0xBE, 0xCA, 0xFE, 0xBA, 0xBE, 0xCA, 0xFE, 0xBA, 0xBE, 0xCA, 0xFE, 0xBA, 0xBE, ]))
chr11 = srv1.characteristic(uuid=11, value=87)
chr11.callback(trigger=Bluetooth.CHAR_WRITE_EVENT | Bluetooth.CHAR_READ_EVENT,
handler=char11_cb_handler)
chr12 = srv1.characteristic(uuid=12, value=99)
# chr13 = srv1.characteristic(uuid=13, value=33)
