def __init__(self, name="esp32-fmpt", led=None):
self.timer = Timer(-1)
self.led = led
self.irq_busy = False
self.buzz = NOTIFYER(25, 13)
self.i = 0
self._is_connected = False
self.alert_level = 0
self._ble = bluetooth.BLE()
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._appear, self._manufact, self._model, self._firm),
(self._alert_handle, )) = self._ble.gatts_register_services(
(_DEV_INF_SERV_SERVICE, _IMMEDIATE_ALERT_SERVICE))
self._connections = set()
self._payload = advertising_payload(
name=name,
services=[_IMMEDIATE_ALERT_SERV_UUID],
appearance=_ADV_APPEARANCE_GENERIC_KEYRING)
# print(len(self._payload))
# First 30 seconds (fast connection) Advertising Interval 20 ms to 30 ms
print('Advertising in fast connection mode for 30 seconds...')
self._advertise(interval_us=30000)
self._ble.gatts_write(
self._appear, struct.pack("h", _ADV_APPEARANCE_GENERIC_KEYRING))
self._ble.gatts_write(self._manufact,
bytes('Espressif Incorporated', 'utf8'))
self._ble.gatts_write(self._model, bytes(_MODEL_NUMBER, 'utf8'))
self._ble.gatts_write(self._firm, bytes(_FIRMWARE_REV, 'utf8'))
# Timeout 30 s
self.start_adv_fast_timeout()
def __init__(self, ble, name="esp32-voltmeter"):
self.ads_dev = MY_ADS(ADS1115, i2c)
self.init_ads()
self.ads_timer = Timer(-1)
self.irq_busy = False
self.min_volt = None
self.typ_volt = None
self.max_volt = None
self.ads_dev.ads.conversion_start(7, channel1=self.ads_dev.channel)
self.i = 0
self._ble = bluetooth.BLE()
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._appear, self._manufact, self._model, self._firm), (self._volt_h,)) = self._ble.gatts_register_services(
(_DEV_INF_SERV_SERVICE, _ADS_SERV_SERVICE))
self._connections = set()
self._payload = advertising_payload(
name=name, services=[
_ENV_SERV_UUID], appearance=_ADV_APPEARANCE_HID_DIGITAL_PEN
)
self._advertise(interval_us=30000)
self._ble.gatts_write(self._appear, struct.pack(
"h", _ADV_APPEARANCE_HID_DIGITAL_PEN))
self._ble.gatts_write(self._manufact, bytes('Espressif Incorporated',
'utf8'))
self._ble.gatts_write(self._model, bytes(_MODEL_NUMBER, 'utf8'))
self._ble.gatts_write(self._firm, bytes(_FIRMWARE_REV, 'utf8'))
volt_sample = (self.ads_dev.ads.raw_to_v(
self.ads_dev.ads.alert_read()))
volt_bin = int(volt_sample / (2**(-6)))
self._ble.gatts_write(self._volt_h, struct.pack(
"H", volt_bin))
def __init__(self, ble, name='mpy-temp'):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
self._connections = set()
self._payload = advertising_payload(name=name, services=[_ENV_SENSE_UUID], appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER)
self._advertise()
def __init__(self, ble, name="ESP32"):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_LED_SERVICE,))
self._connections = set()
self._write_callback = None
self._payload = advertising_payload(name=name, services=[_LED_UUID])
self._advertise()
def __init__(self, ble, name="PenduloSensor"):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle,),) = self._ble.gatts_register_services((_PENDULO_SERVICE,))
self._connections = set()
self._payload = advertising_payload(name=name, services=[_PENDULO_UUID])
self.status = Pin(2,Pin.OUT)
self._advertise()
def __init__(self, ble, name="HCR"):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle, ), ) = self._ble.gatts_register_services(
(_REMOTE_SERVICE, ))
self._connections = set()
self._payload = advertising_payload(name=name, services=[_REMOTE_UUID])
self._advertise()
def __init__(self, ble, name="MicroPy"):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._csc_msr_handle,
self._csc_ftr_handle), ) = self._ble.gatts_register_services(PROFILE)
self._connections = set()
self._write_callback = None
self._payload = advertising_payload(name=name, services=[CSC_UUID])
self._advertise()
def __init__(self, rx_cb, central_name="mpy-uart"):
self._ble = bluetooth.BLE()
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))
self._connections = set()
self._rx_cb = rx_cb
self._payload = advertising_payload(name=central_name, services=[_ADV_APPEARANCE_GENERIC_COMPUTER])
# Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
# self._payload = advertising_payload(name=central_name, services=[_UART_UUID])
self._advertise()
def __init__(self, ble, name='Nodemcu'):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
self._connections = set()
time.sleep_ms(500)
self._payload = advertising_payload(
name=name, services=[_ENV_SENSE_UUID], appearance=_ADV_APPEARANCE_GENERIC_AMBIENT_LIGHT
)
self._sd_adv = None
self._advertise()
def __init__(self, ble, name='mpy-uart', rxbuf=100):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._tx_handle, self._rx_handle,),) = self._ble.gatts_register_services((_UART_SERVICE,))
# Increase the size of the rx buffer.
self._ble.gatts_write(self._rx_handle, bytes(rxbuf))
self._connections = set()
self._rx_buffer = bytearray()
self._handler = None
self._payload = advertising_payload(name=name, appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
self._advertise()
def __init__(self, ble, name="mpy-coffee"):
self._ble = ble
self._ble.active(True)
print('bt activated')
self._ble.irq(self._irq)
((self._weight_handle,), (self._battery_handle,),) = self._ble.gatts_register_services(
(_AUTOMATION_IO_SERVICE, _BATTERY_SERVICE)
)
self._connections = set()
self._payload = advertising_payload(
name=name, services=[_AUTOMATION_IO_UUID, _BATTERY_UUID], appearance=_ADV_APPEARANCE_GENERIC_WEIGHT_SCALE,
)
self._advertise()
def __init__(self, ble, name='mpy-uart', rxbuf=100):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._tx_handle, self._rx_handle,),) = self._ble.gatts_register_services((_UART_SERVICE,))
# Increase the size of the rx buffer and enable append mode.
self._ble.gatts_set_buffer(self._rx_handle, rxbuf, True)
self._connections = set()
self._rx_buffer = bytearray()
self._handler = None
# Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
self._payload = advertising_payload(name=name, appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
self._advertise()
def __init__(self, ble, name='m5stack-speaker'):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._handle_audio, ),
) = self._ble.gatts_register_services(SERVICES)
self._connections = set()
self._payload = advertising_payload(name=name,
services=[_DEVICE_UUID],
appearance=_ADV_APPEARANCE_AUDIO)
self._advertise()
def __init__(self,
ble,
speed_sensor_pin,
cadence_sensor_pin=None,
name="cheapensor",
debug=False):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
self._CSC_FEATURES = _CSC_FEATURE_WHEEL_REV_DATA
if cadence_sensor_pin:
self._CSC_FEATURES = _CSC_FEATURE_WHEEL_REV_DATA | _CSC_FEATURE_CRANK_REV_DATA
((
self._handle_feature,
self._handle_measurement,
), ) = self._ble.gatts_register_services((_CSC_SERVICE, ))
self._connections = set()
self._payload = advertising_payload(
name=name,
services=[_CSC_SERVICE_UUID],
appearance=_ADV_APPEARANCE_CYCLING_SPEED_CADENCE_SENSOR)
# Write the feature
self._ble.gatts_write(self._handle_feature,
struct.pack("<h", self._CSC_FEATURES))
self._advertise()
self._cumulative_wheel_revolutions = 0
self._last_wheel_event_time = 0
self._cumulative_crank_revolutions = 0
self._last_crank_event_time = 0
self._debug = debug
# IR Speed Sensor
self.speed_sensor = Pin(speed_sensor_pin, Pin.IN)
self.speed_sensor.irq(trigger=Pin.IRQ_RISING,
handler=self.speed_sensor_irq)
if cadence_sensor_pin:
self.cadence_sensor = Pin(cadence_sensor_pin, Pin.IN)
self.cadence_sensor.irq(trigger=Pin.IRQ_RISING,
handler=self.cadence_sensor_irq)
# Use a timer to periodically send out data.
self.enable_transmit = False
timer3 = Timer(3)
timer3.init(period=1000,
mode=Timer.PERIODIC,
callback=self.arm_measurement)
if debug:
print("Initialised CSC sensor")
def __init__(self, name, config):
self._config = config
self._ble = bluetooth.BLE()
self._ble.active(True)
self._ble.irq(handler=self._irq)
services = self.constructUUIDList()
((self._variables), ) = self._ble.gatts_register_services(services)
self._connections = set()
self._handler = None
#...
# Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
self._payload = advertising_payload(
name=name, appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
self._advertise()
def __init__(self, opc, name="ybb", rxbuf=1024):
Consumer.__init__(self)
self._ble = BLE()
self._ble.active(True)
self._ble.irq(self._irq)
self._ble.config(gap_name = name[:16])
((self._tx_handle, self._rx_handle),) = self._ble.gatts_register_services((_UART_SERVICE,))
# Increase the size of the rx buffer and enable append mode.
self._ble.gatts_set_buffer(self._rx_handle, rxbuf, True)
self._connections = {}
self._rx_buffer = bytearray()
self._opc = opc
# Optionally add services=[_UART_UUID], but this is likely to make the payload too large.
self._payload = advertising_payload(name=name[:16], appearance=_ADV_APPEARANCE_GENERIC_COMPUTER)
self._advertise()
def build_mi_sdadv(self, density):
uuid = 0xFE95
fc = 0x0010
pid = 0x0002
fcnt = 0x01
mac = self._ble.config('mac')
objid = 0x1007
objlen = 0x03
objval = density
service_data = struct.pack("<3HB",uuid,fc,pid,fcnt)+mac+struct.pack("<H2BH",objid,objlen,0,objval)
print("Service Data:",service_data)
return advertising_payload(service_data=service_data)
def __init__(self, ble, name="covid19"):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((self._handle, ), ) = self._ble.gatts_register_services(
(_ENV_SENSE_SERVICE, ))
self._connections = set()
# name = "covid" + ubinascii.hexlify(b'~\xd8\xc6\x00').decode('utf-8')
name = "covid" + str(urandom.getrandbits(30))
self.name = name
self._payload = advertising_payload(
name=name,
services=[_ENV_SENSE_UUID],
appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER)
self._advertise()
def __init__(self, ble, name="ESP32"):
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle_io, ), ) = self._ble.gatts_register_services(
(_MIDI_SERVICE, ))
# Default setting is to clobber the characteristic value with the latest
# This enables buffering of MIDI messages sent in rapid succession
self._ble.gatts_set_buffer(self._handle_io, 32, True)
self._connections = set()
self._write_callback = None
self._payload = advertising_payload(name=name, services=[_MIDI_UUID])
self._advertise()
def __init__(self, ble, name="mpy-temp"):
self._ble = ble
self._load_secrets()
self._ble.irq(self._irq)
self._ble.config(bond=True)
self._ble.config(le_secure=True)
self._ble.config(mitm=True)
self._ble.config(io=_IO_CAPABILITY_DISPLAY_YESNO)
self._ble.active(True)
self._ble.config(addr_mode=2)
((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
self._connections = set()
self._payload = advertising_payload(
name=name, services=[_ENV_SENSE_UUID], appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER
)
self._advertise()
def __init__(self, ble, name='mpy-m5stack'):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
(
(self._handle_accel, self._handle_mag, self._handle_gyro,
self._handle_temp),
(self._handle_keys, ),
(self._handle_display, ),
) = self._ble.gatts_register_services(SERVICES)
self._connections = set()
self._payload = advertising_payload(name=name,
services=[_DEVICE_UUID],
appearance=_ADV_APPEARANCE_MPU9250)
self._advertise()
def __init__(self, ble, name="ulora"):
self._ble = ble
self._ble.active(True)
self._ble.irq(handler=self._irq)
((
self._handle_tx,
self._handle_rx,
), ) = self._ble.gatts_register_services((_UART_SERVICE, ))
self._ble.gatts_set_buffer(self._handle_tx, 200, True)
self._ble.gatts_set_buffer(self._handle_rx, 200, True)
self._connections = set()
self._write_callback = None
self._payload = advertising_payload(
name=name,
services=[_UART_UUID],
)
self._advertise()
def __init__(self, ble, name):
"""
object constructor
:param ble: instancia de BLE
:param name: (string) nombre con el que se va a publicitar
"""
self._ble = ble
self._ble.active(True)
self._connections = set()
self._ble.irq(self._irq)
((self._handle, ), ) = self._ble.gatts_register_services(
(_ENV_SENSE_SERVICE, ))
self._connections = set()
self._payload = advertising_payload(
name=name,
services=[_ENV_SENSE_UUID],
appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER)
self._advertise()
def build_mi_sdadv(self, density):
uuid = 0xFE95
fc = 0x0010
pid = 0x0002
fcnt = 0x01
# 返回设备的MAC地址
mac = self._ble.config('mac')
objid = 0x1007
objlen = 0x03
objval = density
# struct.pack 按照格式字符串 fmt 压缩参数 v1, v2, ... 。返回值是参数编码后的字节对象。
service_data = struct.pack("<3HB", uuid, fc, pid,
fcnt) + mac + struct.pack(
"<H2BH", objid, objlen, 0, objval)
print("Service Data:", service_data)
return advertising_payload(service_data=service_data)
def __init__(self, ble, name='HEN'): # HiveEyesNode
"""
Start BLE & Advertising
"""
#self._reading = reading # last_reading from datalogger.storage
self._ble = ble
print('Starting BLE')
self.start()
self._ble.irq(handler=self._irq)
((self._BS_handle,),(self._WS_handle,),(self._ES_HUM_handle, self._ES_TEMP_handle,), \
(self._TB_T01_handle, self._TB_T02_handle, self._TB_T03_handle, self._TB_T04_handle, \
self._TB_T05_handle, self._TB_T06_handle, self._TB_T07_handle, self._TB_T08_handle, \
self._TB_T09_handle, self._TB_T10_handle,) ,) \
= self._ble.gatts_register_services(_SERVICES)
self._connections = set()
# advertise that we are here and what services we provide
self._payload = advertising_payload(name=name, services=_ADV_SERVICES, appearance=_ADV_APPEARANCE_GENERIC_WEIGHT_SCALE)
print('Start advertising')
self._advertise()
def _create_advertising_payload():
return advertising_payload(name='micropython-esp32', services=[UUID(0x180F)], appearance=BATTERY_SERVICE_APPEARANCE)
conn_handle, attr_handle = data
value = ble.gatts_read(attr_handle)
value = int.from_bytes(value, "little")
r = value & 0xFF
g = (value >> 8) & 0xFF
b = (value >> 16) & 0xFF
dots[0] = (r, g, b)
# https://docs.micropython.org/en/latest/library/ubluetooth.html#ubluetooth.BLE.gatts_register_services
# No official protocol used, so I need random UUID as a service and
# characteristic
ble_service = (
bluetooth.UUID("aa4a619f-04ea-43ac-854a-7e49cd1437d9"),
((bluetooth.UUID("5cbed0dc-eeb2-4145-a297-a03ccf464563"),
bluetooth.FLAG_WRITE), ),
)
# Initialize the dotstar (pins used by TinyPICO's builtin one)
spi = SPI(baudrate=50000, sck=Pin(12), mosi=Pin(2), miso=Pin(19))
dots = DotStar(spi, 1, brightness=0.5) # Just one DotStar, half brightness
# Initialize bluetooth
ble = bluetooth.BLE()
ble.irq(irq)
ble.active(True)
ble.gatts_register_services((ble_service, ))
ble.gap_advertise(100,
adv_data=advertising_payload(name="BLE-led",
services=(ble_service[0], )))
ble = bluetooth.BLE()
ble.active(True)
ble.irq(bt_irq)
ble.config(gap_name='Bosu')
# configure the services that will be advertised
ACCEL_UUID = bluetooth.UUID('7ED5A5BC-8013-4753-B199-0A364D52E5DE')
ACCEL_CHAR = (
bluetooth.UUID('F477FD95-41F0-4C73-9093-5DA7DC624DF0'),
bluetooth.FLAG_READ | bluetooth.FLAG_NOTIFY,
)
ACCEL_SERVICE = (
ACCEL_UUID,
(ACCEL_CHAR, ),
)
SERVICES = (ACCEL_SERVICE, )
((accel, ), ) = ble.gatts_register_services(SERVICES)
connections = set()
# this advertising payload can't be too long
payload = advertising_payload(name='Bosu Ballers')
ble.gap_advertise(500000, adv_data=payload)
while True:
for conn in connections:
xyz = imu.accel.xyz
ble.gatts_notify(conn, accel, struct.pack('<fff', *xyz))
time.sleep_ms(100)
bluetooth.UUID("9138f9c0-9427-4299-85f3-7aa97b0d0c46"),
_FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
bluetooth.UUID("7a47b14d-04c5-440c-b701-c5ed67789dff"),
_FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
_UART_UUID,
(_UART_TX, _UART_RX),
)
BLE = bluetooth.BLE()
BLE.active(True)
BLE.gatts_register_services((_UART_SERVICE,))
payload = advertising_payload(name="remote", services=[_UART_UUID])
def ble_handler(event: int, data) -> None:
print("Event: {event}, data: {data}".format(event=event, data=data))
# def init_ble() -> None:
# ble = bluetooth.BLE()
# ble.active(True)
# # ble.irq(ble_handler)
# ble.gap_connect()
def main() -> None:
button_pressed = None
def __init__(self, name="esp32-DFU", led=None):
self.timer = Timer(-1)
self.led = led
self.irq_busy = False
self._is_connected = False
self._image_size = 0
self._image_type = 0
self._opcode = 0
self._resp_opcode = 0x10
self._opcodes_dict = {'START_DFU': 0x01,
'Initialize DFU Parameters': 0x02,
'Receive Firmware Image': 0x03,
'Validate Firmware': 0x04,
'Activate Image and Reset': 0x05,
'Reset System': 0x06,
'Report Received Image Size': 0x07,
'Packet Receipt Notification Request': 0x08,
'Response Code': 0x10,
'Packet Receipt Notification': 0x11}
self._opcode_rev = {v: k for k, v in self._opcodes_dict.items()}
self._response_values = {'Success': 0x01,
'Invalid State': 0x02,
'Not Supported': 0x03,
'Data Size Exceeds Limit': 0x04,
'CRC Error': 0x05,
'Operation Failed': 0x06}
self._dfu_image_type_codes = {0x00: 'No Image',
0x01: 'SoftDevice',
0x02: 'Bootloader',
0x03: 'SoftDevice-Bootloader',
0x04: 'Application'}
self._init_packet_codes = {0x00: 'Receive Init Packet',
0x01: 'Init Packet Complete'}
self._init_packet = 0
self._name_file_packet = True
self._filename = b''
self._total_image_size = 0
self._received_image_len = 0
self._n_packet = 0
self._image_checksum = 0
self._ble = bluetooth.BLE()
self._ble.active(True)
self._ble.config(gap_name='ESP32-DFU')
self._ble.irq(handler=self._irq)
((self._appear, self._manufact, self._model, self._firm),
(self._dfu_control_point, self._dfu_packet)) = self._ble.gatts_register_services(
(_DEV_INF_SERV_SERVICE, _DEVICE_FIRMWARE_UPDATE_SERVICE))
self._connections = set()
self._payload = advertising_payload(
name=name, services=[
_DEV_INF_SERV_UUID], appearance=_ADV_APPEARANCE_GENERIC_KEYRING
)
print(len(self._payload))
# 60 seconds (fast connection) Advertising Interval 20 ms to 30 ms
print('Advertising in fast connection mode for 60 seconds...')
self._advertise(interval_us=30000)
self._ble.gatts_write(self._appear, struct.pack(
"h", _ADV_APPEARANCE_GENERIC_KEYRING))
self._ble.gatts_write(self._manufact, bytes('Espressif Incorporated',
'utf8'))
self._ble.gatts_write(self._model, bytes(_MODEL_NUMBER, 'utf8'))
self._ble.gatts_write(self._firm, bytes(_FIRMWARE_REV, 'utf8'))
self._ble.gatts_set_buffer(self._dfu_packet, 512, True)
# Timeout 60 s
self.start_adv_timeout()
