Bluetooth Low Energy (BLE) in MicroPython

import bluetooth
import time
from machine import Pin
from micropython import const

# --- Definitions and Constants ---
# BLE system events (IRQ)
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

# Define our UUIDs (Randomly generated)
# Service: 12345678-1234-5678-1234-56789abcdef0
_MI_SERVICIO_UUID = bluetooth.UUID("12345678-1234-5678-1234-56789abcdef0")
# Characteristic (LED): 12345678-1234-5678-1234-56789abcdef1
_MI_CHAR_UUID = bluetooth.UUID("12345678-1234-5678-1234-56789abcdef1")

# Permission flags: Can be read (READ) and written (WRITE)
_FLAG_READ = const(0x0002)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

# --- BLE Peripheral Class ---
class BLELedPeripheral:
    def __init__(self, ble, name="Mi-ESP32"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq_handler)
        
        # Configure the LED
        self._led = Pin(2, Pin.OUT)
        self._led.value(0)

        # Register the service and characteristic
        # ((UUID, FLAGS),) -> Tuple of characteristics
        SERVICES = (
            (_MI_SERVICIO_UUID, ((_MI_CHAR_UUID, _FLAG_READ | _FLAG_WRITE),)),
        )
        
        # gatts_register_services returns the "handles"
        # We need to store them to know which characteristic the phone is writing to
        ((self._handle,),) = self._ble.gatts_register_services(SERVICES)
        
        self._conn_handle = None
        self._payload = self._create_advertising_payload(name=name)
        self._advertise()

    def _irq_handler(self, event, data):
        # This function runs automatically when something happens
        
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("Phone connected!", conn_handle)
            self._conn_handle = conn_handle
            
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Phone disconnected.")
            self._conn_handle = None
            # Important: Re-advertise so another device can connect
            self._advertise()
            
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            # Check if they wrote to our LED characteristic
            if conn_handle == self._conn_handle and value_handle == self._handle:
                # Read the value they wrote
                val = self._ble.gatts_read(self._handle)
                self._update_led(val)

    def _update_led(self, data):
        # If we receive a '1' or 'ON', turn the LED on
        try:
            texto = data.decode().strip()
            print("Received:", texto)
            if texto == "1" or texto == "ON":
                self._led.value(1)
            elif texto == "0" or texto == "OFF":
                self._led.value(0)
        except:
            pass

    def _advertise(self, interval_us=500000):
        print("Advertising...")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    # Helper function to create the advertising packet (GAP)
    # This is technical; it basically packages the name into bytes
    def _create_advertising_payload(self, limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
        import struct
        payload = bytearray()

        def _append(adv_type, value):
            payload.append(len(value) + 1)
            payload.append(adv_type)
            payload.extend(value)

        _append(0x01, struct.pack("B", (0x02 if limited_disc else 0x06) + (0x00 if br_edr else 0x04)))

        if name:
            _append(0x09, name)
            
        return payload

# --- Execution ---
ble = bluetooth.BLE()
p = BLELedPeripheral(ble)

while True:
    time.sleep(1)