IR Controlled RGB LEDs with UNIHIKER and ESP32

```shell
# install esptool
$ pip3 install esptool

# get information about needed Firmware
$ esptool.py -p [SERIAL PORT] --chip auto chip_id
$ esptool.py -p [SERIAL PORT] --chip auto flash_id

# erase flash
$ esptool.py -p [SERIAL PORT] --chip auto erase_flash

# flash firmware (example Generic on ESP32)
$ esptool.py --chip esp32 --port [SERIAL PORT] --baud 460800 write_flash -z 0x1000 [BIN FILE]
```

```shell
# install rshell
$ pip3 install rshell

# connect to ESP32
$ rshell -p [SERIAL PORT]

# copy from file (from local to ESP32)
$ rshell -p [SERIAL PORT] [LOCAL PATH] /pyboard/
```

from machine import Pin
from micropython import const
from neopixel import NeoPixel
from ubluetooth import BLE, UUID, FLAG_WRITE
from utime import sleep, sleep_ms


LED_PIN = const(23)
LED_NUMBER = const(19)

_ADV_TYP_NAME = const(9)
_IRQ_CONNECT = const(1)
_IRQ_DISCONNECT = const(2)
_IRQ_WRITE = const(3)
_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)
_UART_UUID = UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX = (
    UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
    UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)


def fade_out(led: NeoPixel, delay: int = 50) -> None:
    """
    Fades out the LED strip by progressively reducing the brightness.

    :param led: The NeoPixel object representing the LED strip.
    :type led: NeoPixel
    :param delay: The delay (in milliseconds) between each step of the fading (default is 50 ms).
    :type delay: int
    :return: None
    """
    for brightness in range(255, -1, -5):
        for i in range(LED_NUMBER):
            led[i] = (brightness, brightness, brightness)
        led.write()
        sleep_ms(delay)

    led.fill((0, 0, 0))
    led.write()


def circle_led(led: NeoPixel, direction: bool, delay: int = 50) -> None:
    """
    Animates a circular movement of LED strip.

    :param led: The NeoPixel object representing the LED strip.
    :type led: NeoPixel
    :param direction: A boolean value indicating the direction of the LED animation.
    :type direction: bool
    :param delay: The delay (in milliseconds) of the LED animation (default is 50 ms).
    :type delay: int
    :return: None
    """
    global last_color

    led.fill((0, 0, 0))
    led.write()

    if direction:
        for i in range(LED_NUMBER):
            led[i] = last_color
            led.write()
            sleep_ms(delay)
    else:
        for i in range(LED_NUMBER - 1, -1, -1):
            led[i] = last_color
            led.write()
            sleep_ms(delay)

    led.fill(last_color)
    led.write()


def set_led_color(led: NeoPixel, color: tuple) -> None:
    """
    Set the color for all LEDs of the LED strip.

    :param led: A NeoPixel object representing the LED strip.
    :type led: NeoPixel
    :param color: A tuple representing the RGB color values to set the LED strip to.
    :type color: tuple
    :return: None
    """
    global last_color

    if last_color != color:
        last_color = color
        led.fill(color)
        led.write()


def process_ble_msg(message: str) -> None:
    """
    Process BLE message and perform corresponding actions.

    :param message: The BLE message to be processed.
    :type message: str
    :return: None
    """
    global nps

    if str(message).lower() == 'left':
        circle_led(led=nps, direction=True)
    elif str(message).lower() == 'right':
        circle_led(led=nps, direction=False)
    else:
        try:
            tuple_value = tuple(map(int, message.split(',')))
            set_led_color(led=nps, color=tuple_value)
        except ValueError:
            print(f"[WARN] Raw: {repr(message)} not implemented")


def ble_advertiser(name: str) -> None:
    """
    Advertise BLE (Bluetooth Low Energy) devices with a given name.

    :param name: The name of the BLE advertiser. It should be a string.
    :type name: str
    :return: None
    """
    global ble

    adv_data = b'\x02\x01\x06'
    name = bytes(name, 'UTF-8')
    adv_data = adv_data + bytearray((len(name) + 1, _ADV_TYP_NAME)) + name

    print(f'[INFO] BLE advertiser:{adv_data}')
    ble.gap_advertise(500, adv_data)


def ble_services() -> None:
    """
    Perform BLE service registration.

    :return: None
    """
    global ble
    global tx
    global rx

    services = (_UART_SERVICE,)
    ((tx, rx,),) = ble.gatts_register_services(services)


def ble_irq(event: int, data: tuple) -> None:
    """
    Handles interrupts related to Bluetooth Low Energy (BLE) events.

    :param event: An integer representing the event that occurred.
    :type event: int
    :param data: A tuple containing additional data related to the event  (not used).
    :type data: tuple
    :return: None
    """
    global ble
    global rx

    _ = data

    if event == _IRQ_CONNECT:
        print("[INFO] Central connected")
    elif event == _IRQ_DISCONNECT:
        print("[INFO] Central disconnected")
    elif event == _IRQ_WRITE:
        buffer = ble.gatts_read(rx)
        msg = buffer.decode('UTF-8').strip()

        print(f"[INFO] A central has written this: {msg}")
        process_ble_msg(message=str(msg))


if __name__ == '__main__':
    tx = None
    rx = None
    last_color = None

    nps = NeoPixel(Pin(LED_PIN), LED_NUMBER)
    set_led_color(led=nps, color=(50, 50, 50))

    ble_name = 'ESP32'
    ble = BLE()
    ble.active(True)

    ble_services()
    ble.irq(ble_irq)

    fade_out(led=nps)

    while True:
        ble_advertiser(name=ble_name)
        sleep(5)

from pinpong.board import Board, Pin, IRRecv
from tkinter import Tk, Canvas
from bluepy.btle import Peripheral


DISPLAY_WIDTH: int = 240
DISPLAY_HEIGHT: int = 320
BTN_MAPPING: dict = {
    '0xff9867': ('black', (0, 0, 0)),
    '0xffa25d': ('white', (255, 255, 255)),
    '0xff629d': ('red', (255, 0, 0)),
    '0xffe21d': ('green', (0, 255, 0)),
    '0xff22dd': ('blue', (0, 0, 255)),
    '0xff02fd': ('cyan', (0, 255, 255)),
    '0xffc23d': ('yellow', (255, 255, 0)),
    '0xffe01f': ('magenta', (255, 0, 255)),
    '0xffa857': ('olive', (128, 128, 0)),
    '0xff906f': ('gold', (255, 215, 0))
}
BTN_RIGHT: str = '0xff5aa5'
BTN_LEFT: str = '0xff10ef'
BLE_ADDRESS: str = "08:3A:F2:B7:A8:4A"
BLE_CHARACTERISTIC_UUID: str = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"


def change_canvas(color_name: str) -> None:
    """
    Change the color of the canvas rectangle and text.

    :param color_name: The name of the color to change to.
    :type color_name: str
    :return: None
    """
    global canvas
    global rect_id
    global text_id

    canvas.itemconfig(rect_id, fill=color_name)
    canvas.itemconfig(text_id, text=color_name.capitalize())


def change_color(rgb: tuple, name: str) -> None:
    """
    Change the color of the connected device using RGB values.

    :param rgb: A tuple containing three integers representing the RGB values of the desired color.
    :type rgb: tuple
    :param name: The name of the color.
    :type name: str
    :return: None
    """
    global ready
    global device
    global rx_char

    if not ready:
        return

    color_data = f"{rgb[0]},{rgb[1]},{rgb[2]}".encode('utf-8')

    try:
        ready = False

        if device is not None and rx_char is not None:
            rx_char.write(color_data, withResponse=True)
            change_canvas(color_name=name)
        else:
            print("[ERROR] Device or characteristic not initialized.")
    except Exception as err_write:
        print(f"[ERROR] {err_write}")
    finally:
        ready = True


def set_direction(direction: str) -> None:
    """
    Sets the direction for the LED circle.

    :param direction: The direction to set (left, right).
    :type direction: str
    :return: None
    """
    global ready

    if not ready:
        return

    direction_data = str(direction).encode('utf-8')

    try:
        ready = False

        if device is not None and rx_char is not None:
            rx_char.write(direction_data, withResponse=True)
        else:
            print("[ERROR] Device or characteristic not initialized.")
    except Exception as err_write:
        print(f"[ERROR] {err_write}")
    finally:
        ready = True



def ir_callback(data: int) -> None:
    """
    Callback method for handling infrared data.

    :param data: The received infrared data as an integer.
    :type data: int
    :return: None
    """
    ir_hex = hex(int(data))

    if ir_hex in BTN_MAPPING:
        name = BTN_MAPPING[ir_hex][0]
        rgb = BTN_MAPPING[ir_hex][1]

        print(f'[INFO] BTN:{ir_hex} - Name:{name} - RGB:{rgb}')
        change_color(rgb=rgb, name=name)
    elif ir_hex in BTN_RIGHT:
        print(f'[INFO] BTN:{ir_hex} - Name:right')
        set_direction(direction='right')
    elif ir_hex in BTN_LEFT:
        print(f'[INFO] BTN:{ir_hex} - Name:left')
        set_direction(direction='left')
    else:
        print(f'[WARN] BTN: {ir_hex} not mapped')


if __name__ == '__main__':
    Board().begin()

    ir = IRRecv(pin_obj=Pin(Pin.P14), callback=ir_callback)

    device = Peripheral(BLE_ADDRESS)
    rx_char = device.getCharacteristics(uuid=BLE_CHARACTERISTIC_UUID)[0]

    ready = True

    window = Tk()
    window.geometry(f'{DISPLAY_WIDTH}x{DISPLAY_HEIGHT}+0+0')

    canvas = Canvas(window, width=DISPLAY_WIDTH, height=DISPLAY_HEIGHT)
    canvas.pack()

    rect_width = DISPLAY_WIDTH - 10
    rect_height = DISPLAY_HEIGHT - 100
    rect_id = canvas.create_rectangle(10, 10, rect_width, rect_height, outline="black", fill="black", width=2)

    txt_width = DISPLAY_WIDTH // 2
    txt_height = DISPLAY_HEIGHT - 50
    txt = 'Please select a color [0 - 9]'
    font = ('Arial', 12)
    text_id = canvas.create_text(txt_width, txt_height, text=txt, font=font, fill="black", anchor='center')

    window.mainloop()

    if device is not None:
        device.disconnect()