feat: add ESP-RainMaker and ESP-Matter frameworks and update existing framework metadata in frameworks.json

lib/diagnosticoData.js

@@ -1,6 +1,7 @@
 /**
  * Base de dados estruturada para o Guia de Diagnóstico, Erros Comuns e Resolução de Problemas no ESP32.
- * Abrange 6 categorias técnicas com causas raízes, comparativos de boas práticas vs gambiarras e exemplos de código.
+ * Abrange 6 categorias técnicas com causas raízes, comparativos de boas práticas vs gambiarras e exemplos de código
+ * em Arduino C++, ESP-IDF (C) e MicroPython.
  */
 
 export const categoriasDiagnostico = [
@@ -102,6 +103,26 @@ void app_main(void) {
     // Para mitigar picos em ambientes com limite de potência:
     esp_wifi_set_max_tx_power(68); // 68 = 17dBm (unidades de 0.25dBm)
 }`,
+		codigoMicroPython: `# Conexão Wi-Fi segura no MicroPython com estabilização:
+import network
+import time
+
+wlan = network.WLAN(network.STA_IF)
+wlan.active(True)
+
+# Aguarda estabilização da alimentação antes de iniciar transmissão
+time.sleep_ms(200)
+wlan.connect("SSID", "SENHA")
+
+tentativas = 0
+while not wlan.isconnected() and tentativas < 30:
+    time.sleep_ms(200)
+    tentativas += 1
+
+if wlan.isconnected():
+    print("Wi-Fi Conectado! IP:", wlan.ifconfig()[0])
+else:
+    print("[ERRO] Falha ao conectar Wi-Fi")`,
 		dicaPro: "Se estiver projetando sua própria PCB, coloque um plano de terra sólido sob o módulo e trilhas de alimentação com largura mínima de 0.5mm a 1mm para suportar os surtos de corrente sem queda resistiva (IR drop).",
 	},
 	{
@@ -139,6 +160,15 @@ void app_main(void) {
 // Se você usa ESP32 clássico e precisa liberar GPIO12, pode queimar o eFuse de 3.3V:
 // espefuse.py --port /dev/ttyUSB0 set_flash_voltage 3.3V
 // Isso desativa a amostragem de hardware no GPIO12 para sempre.`,
+		codigoMicroPython: `# Configuração correta de pinos no MicroPython:
+from machine import Pin
+
+# ✅ Pinos seguros para saídas e botões com pull-up interno:
+led = Pin(2, Pin.OUT)       # GPIO 2
+botao = Pin(4, Pin.IN, Pin.PULL_UP) # GPIO 4 (seguro)
+
+# ⚠️ Pinos 34, 35, 36, 39 são APENAS ENTRADA e não têm pull-up interno:
+sensor_analogico = Pin(36, Pin.IN) # Correto (requer resistor externo se for botão)`,
 		dicaPro: "Lembre-se sempre: pinos 'Input-Only' (GPI 34 a 39 no ESP32 clássico) não possuem circuitos de pull-up/pull-down de silício nem transistores de saída. Sensores analógicos ou botões neles exigem resistores de pull-up externos.",
 	},
 	{
@@ -190,6 +220,23 @@ esp_err_t ler_dado(char* buffer, size_t max_len) {
     // Operação segura...
     return ESP_OK;
 }`,
+		codigoMicroPython: `# Prevenção contra NoneType e exceções de objeto no MicroPython:
+import json
+
+def processar_sensor(dados_raw):
+    # Proteção defensiva contra payload nulo:
+    if dados_raw is None:
+        print("[ERRO] Dados nulos recebidos!")
+        return None
+    
+    try:
+        obj = json.loads(dados_raw)
+        # Uso seguro de .get() com valor padrão para evitar KeyError
+        temperatura = obj.get("temp", 0.0)
+        return temperatura
+    except (ValueError, AttributeError) as e:
+        print("Erro ao processar objeto:", e)
+        return None`,
 		dicaPro: "Se EXCVADDR for algo como 0x3fxxxxxx ou 0x40xxxxxx mas seu código falha, você pode estar acessando um array fora do limite (buffer overflow) que sobrescreveu ponteiros na memória.",
 	},
 	{
@@ -241,6 +288,22 @@ void app_main(void) {
     gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
     gpio_isr_handler_add(GPIO_NUM_4, gpio_isr_handler, NULL);
 }`,
+		codigoMicroPython: `# Tratamento seguro de interrupções (ISR) no MicroPython:
+import micropython
+from machine import Pin
+
+# Aloca buffer de emergência para depurar exceções dentro de ISRs:
+micropython.alloc_emergency_exception_buf(100)
+
+contador_pulsos = 0
+
+# Callback de interrupção: NÃO aloque memória (sem strings, sem floats novos)
+def tratar_pulso(pin):
+    global contador_pulsos
+    contador_pulsos += 1
+
+sensor = Pin(4, Pin.IN, Pin.PULL_UP)
+sensor.irq(trigger=Pin.IRQ_FALLING, handler=tratar_pulso)`,
 		dicaPro: "Se você passar ESP_INTR_FLAG_IRAM ao registrar a interrupção no ESP-IDF, qualquer função chamada por essa interrupção (inclusive funções do FreeRTOS) DEVE suportar IRAM (ex: xQueueSendFromISR).",
 	},
 	{
@@ -293,6 +356,27 @@ void tarefa_processamento(void *pvParameters) {
         vTaskDelay(pdMS_TO_TICKS(50));
     }
 }`,
+		codigoMicroPython: `# Watchdog e laços não-bloqueantes com uasyncio no MicroPython:
+from machine import WDT
+import uasyncio as asyncio
+
+# Inicializa o Watchdog de hardware com timeout de 5 segundos
+wdt = WDT(timeout=5000)
+
+async def tarefa_sensor():
+    while True:
+        # Alimenta o cão de guarda a cada ciclo saudável:
+        wdt.feed()
+        
+        # Cede controle para o escalonador cooperativo:
+        await asyncio.sleep_ms(100)
+
+async def main():
+    asyncio.create_task(tarefa_sensor())
+    while True:
+        await asyncio.sleep(1)
+
+asyncio.run(main())`,
 		dicaPro: "No Arduino, a função delay(ms) na verdade chama internamente o vTaskDelay do FreeRTOS. Porém, loops que usam delayMicroseconds() ou operações puras de CPU não cedem tempo e podem disparar o TWDT se durarem mais de alguns segundos.",
 	},
 	{
@@ -339,6 +423,17 @@ void setup() {
 		codigoEspIdf: `// Habilite a checagem dupla de Stack no menuconfig:
 // Component config -> FreeRTOS -> Set a end of stack check -> Option 2 (Check by Stack Canary)
 // Isso detecta o estouro ANTES que dados sejam corrompidos em tempo de execução.`,
+		codigoMicroPython: `# Monitoramento de memória e pilha no MicroPython:
+import gc
+import micropython
+
+# Exibe estatísticas de memória RAM e pilha da VM do Python:
+micropython.mem_info()
+
+# Executa garbage collector para liberar blocos órfãos:
+gc.collect()
+print("Memória Heap Livre:", gc.mem_free(), "bytes")
+print("Memória Heap Alocada:", gc.mem_alloc(), "bytes")`,
 		dicaPro: "Se a sua função precisa processar um JSON ou pacote HTTP esporadicamente, aloque o buffer no Heap apenas durante o processamento e libere-o logo em seguida, em vez de inflar o Stack permanente da tarefa.",
 	},
 	{
@@ -387,6 +482,23 @@ void inspecionar_memoria(void) {
     
     ESP_LOGI("HEAP", "Total livre: %d bytes | Maior bloco continuo: %d bytes", livre_total, maior_bloco);
 }`,
+		codigoMicroPython: `# Prevenção de fragmentação de Heap no MicroPython:
+import gc
+
+# 1. Habilita coleta automática
+gc.enable()
+
+# 2. Pré-aloque bytearrays para reaproveitamento em vez de criar novas strings:
+buffer_leitura = bytearray(256)
+
+def ler_sensor_sem_alocacao(stream):
+    # Lê reutilizando o mesmo espaço em memória (Zero-Allocation):
+    bytes_lidos = stream.readinto(buffer_leitura)
+    return buffer_leitura[:bytes_lidos]
+
+# 3. Dispare o GC antes de abrir conexões pesadas (como HTTPS / TLS):
+gc.collect()
+print(f"Heap Livre: {gc.mem_free()} B | Alocado: {gc.mem_alloc()} B")`,
 		dicaPro: "Se o maior bloco contíguo livre for menor que 35KB ~ 40KB, conexões HTTPS/TLS modernas falharão durante o handshake de certificados.",
 	},
 	{
@@ -431,6 +543,15 @@ void setup() {
 uint8_t* alocar_buffer_spi(size_t len) {
     return (uint8_t*) heap_caps_aligned_alloc(4, len, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
 }`,
+		codigoMicroPython: `# No MicroPython, verifique a memória PSRAM disponível:
+import gc
+import esp32
+
+# Se o firmware foi compilado com suporte a SPIRAM (ex: firmwares com 'SPIRAM'):
+print("Memória total acessível no MicroPython:", gc.mem_free() + gc.mem_alloc(), "bytes")
+
+# Para operações rápidas com periféricos, use bytearrays contíguos:
+buffer_spi = bytearray(1024)`,
 		dicaPro: "No ESP32-P4, a arquitetura avançada de barramento AXI permite DMA em certas regiões externas, mas para toda a linha ESP32/S2/S3/C3 a regra da SRAM interna é estrita.",
 	},
 	{
@@ -463,6 +584,12 @@ uint8_t* alocar_buffer_spi(size_t len) {
 // idf.py -p /dev/ttyUSB0 -b 460800 flash
 // Se o upload falhar em altas velocidades, reduza a taxa de baud rate para 115200:
 // idf.py -p /dev/ttyUSB0 -b 115200 flash`,
+		codigoMicroPython: `# Gravação do firmware MicroPython oficial no ESP32 via terminal:
+# 1. Apague a memória Flash:
+# esptool.py --port /dev/ttyUSB0 erase_flash
+
+# 2. Grave o binário com taxa de baud segura:
+# esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-*.bin`,
 		dicaPro: "Se estiver usando módulos ESP32-S3 ou C3 com USB nativo (Direct USB-JTAG), certifique-se de que a porta correta selecionada é a porta CDC/JTAG e não a UART legada.",
 	},
 	{
@@ -518,6 +645,24 @@ void inicializar_sntp(void) {
     
     // Aguarda sincronização do relógio...
 }`,
+		codigoMicroPython: `# Sincronização SNTP e requisições HTTPS no MicroPython:
+import ntptime
+import time
+import urequests
+
+def sincronizar_e_requisitar():
+    try:
+        print("Sincronizando relógio via NTP...")
+        ntptime.host = "pool.ntp.br"
+        ntptime.settime() # Atualiza o RTC interno do ESP32 via NTP
+        print("Hora sincronizada UTC:", time.localtime())
+        
+        # Agora o handshake TLS validará o certificado sem o erro -0x2700:
+        resposta = urequests.get("https://api.github.com")
+        print("Resposta HTTPS:", resposta.status_code)
+        resposta.close()
+    except Exception as e:
+        print("[ERRO TLS/NTP]:", e)`,
 		dicaPro: "Se seu projeto opera em ambientes sem acesso à internet externa (rede local isolada), configure um servidor NTP local no roteador ou adicione um módulo RTC físico como o DS3231 via I2C.",
 	},
 ];
@@ -584,7 +729,7 @@ export const regrasDecodificadorLog = [
 		explicacao:
 			"O ESP32 tentou autenticar um certificado HTTPS/TLS com a data zerada na época Unix (01/01/1970).",
 		acaoRecomendada:
-			"Sincronize o horário via SNTP (`configTime`) antes de iniciar requisições HTTPS seguras.",
+			"Sincronize o horário via SNTP (`configTime` no Arduino ou `ntptime.settime()` no MicroPython) antes de iniciar requisições HTTPS seguras.",
 	},
 	{
 		padrao: /rst:0x1 \(POWERON_RESET\),boot:0x[0-9a-fA-F]+/i,