Faça seu Macropad DIY com a Franzininho WiFi LAB

import time
import board
import digitalio
import usb_hid
import json
import storage
import busio
import adafruit_ssd1306
import adafruit_dht
import pwmio
import analogio
import keymap  # Importa o mapeamento de teclas

from adafruit_hid.keyboard import Keyboard
from adafruit_hid.consumer_control import ConsumerControl

# === CONFIGURAÇÃO DO DISPLAY OLED ===
i2c = busio.I2C(scl=board.IO9, sda=board.IO8)
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)

# === BUZZER (Feedback Sonoro) ===
buzzer = pwmio.PWMOut(board.IO17, duty_cycle=0, frequency=880)

def beep(t):
    """Toca um beep curto no buzzer."""
    buzzer.duty_cycle = 440
    time.sleep(t)
    buzzer.duty_cycle = 0

# === SENSOR DE TEMPERATURA E UMIDADE (DHT11) ===
dht = adafruit_dht.DHT11(board.IO15)

# === LED RGB (3 LEDs Independentes) ===
led_red = pwmio.PWMOut(board.IO14, frequency=5000, duty_cycle=0)
led_green = pwmio.PWMOut(board.IO13, frequency=5000, duty_cycle=0)
led_blue = pwmio.PWMOut(board.IO12, frequency=5000, duty_cycle=0)

def set_rgb(r, g, b):
    """Define a cor do LED RGB utilizando valores de 0 a 255."""
    led_red.duty_cycle = int((r / 255) * 65535)
    led_green.duty_cycle = int((g / 255) * 65535)
    led_blue.duty_cycle = int((b / 255) * 65535)

def rgb_animation():
    """Executa uma animação inicial no LED RGB."""
    colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255)]
    for color in colors:
        set_rgb(*color)
        time.sleep(0.2)
    set_rgb(0, 0, 0)

# === SENSOR DE LUMINOSIDADE (LDR) ===
ldr = analogio.AnalogIn(board.IO1)

def is_dark():
    """Verifica se o ambiente está escuro com base no valor do LDR."""
    return ldr.value < 20000  # Ajuste conforme necessário

def apply_night_mode():
    """Ativa o modo noturno se o ambiente estiver escuro."""
    if is_dark():
        oled.contrast(10)  # Reduz brilho do OLED
        set_rgb(50, 50, 50)  # Luz RGB fraca
    else:
        oled.contrast(255)
        set_rgb(255, 0, 255)  # Modo normal (roxo)

# === TECLADO E CONTROLE MIDI ===
kbd = Keyboard(usb_hid.devices)
cc = ConsumerControl(usb_hid.devices)

# === BOTÕES DO MACROPAD ===
keys = [
    digitalio.DigitalInOut(board.IO7),  # BT1
    digitalio.DigitalInOut(board.IO6),  # BT2
    digitalio.DigitalInOut(board.IO5),  # BT3
    digitalio.DigitalInOut(board.IO4),  # BT4
    digitalio.DigitalInOut(board.IO3),  # BT5
    digitalio.DigitalInOut(board.IO2)   # BT6
]

for key in keys:
    key.direction = digitalio.Direction.INPUT
    key.pull = digitalio.Pull.UP

# === CARREGAR CONFIGURAÇÃO DE PERFIS ===
PROFILE_FILE = "/profiles.json"

def load_profiles():
    """Carrega os perfis de atalhos de um arquivo JSON e converte para Keycodes."""
    try:
        with open(PROFILE_FILE, "r") as f:
            profiles_raw = json.load(f)
        
        print("JSON antes da conversão:", profiles_raw)  # 🔥 Verificar se já está errado aqui

        profiles_converted = {}
        for profile_name, key_list in profiles_raw.items():
            profiles_converted[profile_name] = [keymap.convert_keys(keys) for keys in key_list]

        return profiles_converted
    except Exception as e:
        print(f"Erro ao carregar perfis: {e}")
        return {"Padrão": [[]] * 6}  # Configuração de fallback


profiles = load_profiles()
profile_names = list(profiles.keys())
current_profile_index = 0
print("Perfis Carregados:", profiles)


# === TROCA DE PERFIL SEGURANDO BT1 ===
def switch_profile():
    """Alterna entre perfis somente se BT1 for segurado por 2 segundos."""
    global current_profile_index
    start_time = time.monotonic()
    
    while not keys[0].value:  # Enquanto BT1 estiver pressionado
        if time.monotonic() - start_time > 2:  # Se segurou por mais de 2s, troca o perfil
            current_profile_index = (current_profile_index + 1) % len(profile_names)
            oled_display()
            beep(0.1)
            while not keys[0].value:  # Aguarda soltar o botão antes de continuar
                pass
            return True  # Indica que o perfil foi trocado

    return False  # Se soltou antes de 2 segundos, executa a macro normalmente

# Armazena o estado dos botões para debounce e repetição automática
last_key_states = [True] * len(keys)  # Começa como True porque os botões estão em Pull-UP
key_press_times = [0] * len(keys)  # Tempo do último acionamento da tecla
repeat_delay = 0.1  # Tempo antes de começar a repetir (segundos)
repeat_rate = 0.005   # Intervalo entre repetições (segundos)

def execute_macro(key_index):
    """Executa o comando configurado para a tecla pressionada, aplicando debounce e repetição."""
    global last_key_states, key_press_times

    current_state = keys[key_index].value  # Lê o estado atual do botão
    now = time.monotonic()  # Obtém o tempo atual

    if current_state == False:  # 🔹 Se o botão está pressionado
        if last_key_states[key_index]:  # 🔹 Foi pressionado pela primeira vez?
            last_key_states[key_index] = False
            key_press_times[key_index] = now  # Registra o tempo da primeira pressão
            
            if key_index == 0:  # Se for BT1, verificar troca de perfil
                if switch_profile():
                    return  

            profile = profile_names[current_profile_index]
            actions = profiles[profile][key_index]

            beep(0.01)
            print(f"⬇ Botão {key_index + 1} pressionado no perfil {profile}: {actions}")

            if isinstance(actions, list) and len(actions) > 0:
                if all(action in keymap.CONSUMER_CONTROL_MAP.values() for action in actions):
                    print(f"🎵 Enviando ConsumerControlCode: {actions[0]}")
                    cc.send(actions[0])
                else:
                    print(f"⌨ Enviando Keycode: {actions}")
                    kbd.send(*actions)

        elif now - key_press_times[key_index] > repeat_delay:  # 🔹 Se passou o tempo do delay inicial
            if (now - key_press_times[key_index]) % repeat_rate < 0.01:  # 🔹 Controla a taxa de repetição
                profile = profile_names[current_profile_index]
                actions = profiles[profile][key_index]

                print(f"🔄 Repetindo comando: {actions}")
                beep(0.01)
                if isinstance(actions, list) and len(actions) > 0:
                    if all(action in keymap.CONSUMER_CONTROL_MAP.values() for action in actions):
                        cc.send(actions[0])
                    else:
                        kbd.send(*actions)

    else:  # 🔹 Se o botão foi solto
        if not last_key_states[key_index]:  # 🔹 Apenas processa se antes estava pressionado
            last_key_states[key_index] = True
            print(f"⬆ Botão {key_index + 1} liberado, soltando teclas")
            kbd.release_all()

def oled_display():
    """Exibe apenas o perfil ativo, temperatura e umidade no OLED."""
    oled.fill(0)
    oled.text(f"Perfil: {profile_names[current_profile_index]}", 0, 0, 1)

    try:
        temp = dht.temperature
        humidity = dht.humidity
        if temp is not None and humidity is not None:
            oled.text(f"T: {temp:.1f}C", 0, 20, 1)
            oled.text(f"U: {humidity:.1f}%", 0, 30, 1)
    except RuntimeError:
        oled.text("Erro DHT", 0, 20, 1)

    oled.show()



rgb_animation()
oled_display()

# === LOOP PRINCIPAL ===
while True:
    apply_night_mode()

    for i, key in enumerate(keys):
        execute_macro(i)  # 🔹 Agora com debounce e repetição automática

    oled_display()
    time.sleep(0.01)  # Pequeno atraso para evitar consumo excessivo de CPU

from adafruit_hid.keycode import Keycode
from adafruit_hid.consumer_control_code import ConsumerControlCode

# 🔹 Mapeamento de todas as teclas do Keycode
KEYCODE_MAP = {
    "A": Keycode.A,
    "B": Keycode.B,
    "C": Keycode.C,
    "D": Keycode.D,
    "E": Keycode.E,
    "F": Keycode.F,
    "G": Keycode.G,
    "H": Keycode.H,
    "I": Keycode.I,
    "J": Keycode.J,
    "K": Keycode.K,
    "L": Keycode.L,
    "M": Keycode.M,
    "N": Keycode.N,
    "O": Keycode.O,
    "P": Keycode.P,
    "Q": Keycode.Q,
    "R": Keycode.R,
    "S": Keycode.S,
    "T": Keycode.T,
    "U": Keycode.U,
    "V": Keycode.V,
    "W": Keycode.W,
    "X": Keycode.X,
    "Y": Keycode.Y,
    "Z": Keycode.Z,
    "1": Keycode.ONE,
    "2": Keycode.TWO,
    "3": Keycode.THREE,
    "4": Keycode.FOUR,
    "5": Keycode.FIVE,
    "6": Keycode.SIX,
    "7": Keycode.SEVEN,
    "8": Keycode.EIGHT,
    "9": Keycode.NINE,
    "0": Keycode.ZERO,
    "CONTROL": Keycode.CONTROL,
    "ALT": Keycode.ALT,
    "SHIFT": Keycode.SHIFT,
    "TAB": Keycode.TAB,
    "ENTER": Keycode.ENTER,
    "ESCAPE": Keycode.ESCAPE,
    "SPACEBAR": Keycode.SPACEBAR,
    "BACKSPACE": Keycode.BACKSPACE,
    "DELETE": Keycode.DELETE,
    "UP_ARROW": Keycode.UP_ARROW,
    "DOWN_ARROW": Keycode.DOWN_ARROW,
    "LEFT_ARROW": Keycode.LEFT_ARROW,
    "RIGHT_ARROW": Keycode.RIGHT_ARROW,
    "F1": Keycode.F1,
    "F2": Keycode.F2,
    "F3": Keycode.F3,
    "F4": Keycode.F4,
    "F5": Keycode.F5,
    "F6": Keycode.F6,
    "F7": Keycode.F7,
    "F8": Keycode.F8,
    "F9": Keycode.F9,
    "F10": Keycode.F10,
    "F11": Keycode.F11,
    "F12": Keycode.F12
}

# 🎵 Mapeamento de comandos multimídia
CONSUMER_CONTROL_MAP = {
    "VOLUME_INCREMENT": ConsumerControlCode.VOLUME_INCREMENT,
    "VOLUME_DECREMENT": ConsumerControlCode.VOLUME_DECREMENT,
    "MUTE": ConsumerControlCode.MUTE,
    "PLAY_PAUSE": ConsumerControlCode.PLAY_PAUSE,
    "SCAN_NEXT_TRACK": ConsumerControlCode.SCAN_NEXT_TRACK,
    "SCAN_PREVIOUS_TRACK": ConsumerControlCode.SCAN_PREVIOUS_TRACK,
    "BRIGHTNESS_INCREMENT": ConsumerControlCode.BRIGHTNESS_INCREMENT,
    "BRIGHTNESS_DECREMENT": ConsumerControlCode.BRIGHTNESS_DECREMENT
}


print(f"Valor correto de Keycode.ALT: {Keycode.ALT}")  # 🔥 Isso deve imprimir 130!


# 🔹 Função para converter strings em Keycodes ou ConsumerControlCode
def convert_keys(json_keys):
    """Converte os atalhos do JSON para valores corretos de Keycode ou ConsumerControlCode."""
    converted_keys = []
    for key in json_keys:
        print(f"Tentando converter: {key}")  # 🔥 Ver se 'ALT' realmente chega aqui como string

        if isinstance(key, int):
            print(f"⚠️ ERRO: O JSON ainda tem números ({key}), algo está errado!")
        
        if key in KEYCODE_MAP:  
            print(f"✅ Convertendo {key} -> {KEYCODE_MAP[key]}")
            converted_keys.append(KEYCODE_MAP[key])
        elif key in CONSUMER_CONTROL_MAP:
            print(f"🎵 Convertendo {key} -> {CONSUMER_CONTROL_MAP[key]}")
            converted_keys.append(CONSUMER_CONTROL_MAP[key])
        else:
            print(f"⚠️ ERRO: Tecla '{key}' não encontrada no mapeamento!")
    return converted_keys



def reverse_lookup(value):
    """Converte um código numérico de tecla em string legível."""
    for name, code in KEYCODE_MAP.items():
        if code == value:
            return name
    for name, code in CONSUMER_CONTROL_MAP.items():
        if code == value:
            return name
    return f"UNK({value})"  # Retorna um nome desconhecido se não encontrar

{
    "OBS": [
        ["SHIFT", "T"],  
        ["SHIFT", "1"],  
        ["SHIFT", "2"],  
        ["SHIFT", "P"],  
        ["SHIFT", "R"],  
        ["SHIFT", "S"]   
    ],
    "Midia": [
        ["VOLUME_INCREMENT"],
        ["BRIGHTNESS_DECREMENT"],
        ["BRIGHTNESS_INCREMENT"],
        ["VOLUME_DECREMENT"],  
        ["MUTE"],  
        ["PLAY_PAUSE"]  
    ]
}