feat(i18n): canonical strings, data extraction and validation (phase 2)
Implement Phase 2 of i18n spec: - Extract UI interface strings to messages/pt.json across 15 namespaces - Extract canonical data files to data/pt/ (series, frameworks, conexoes) - Create lib/data/pt/ modules (glossario, diagnostico, componentes, topicos) - Implement lib/data/index.js async data loaders by locale - Add automated check:i18n script to validate key parity and enforce no-book rules Co-Authored-By: Antigravity <noreply@google.com>
This commit is contained in:
Lucas RayanandAntigravity committed
1 parent
83c0ba3e74
commit
fb59015fca
22 files changed
+12766
-2
No files matched your search
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Carregadores de dados organizados por locale (seção 6.2 da spec).
|
||||
* Suporta pt, en, es, fr, de, zh-CN com fallback para pt.
|
||||
*/
|
||||
|
||||
export async function getSeries(locale = "pt") {
|
||||
try {
|
||||
return (await import(`@/data/${locale}/series.json`)).default;
|
||||
} catch {
|
||||
return (await import("@/data/pt/series.json")).default;
|
||||
}
|
||||
}
|
||||
|
||||
export async function getFrameworks(locale = "pt") {
|
||||
try {
|
||||
return (await import(`@/data/${locale}/frameworks.json`)).default;
|
||||
} catch {
|
||||
return (await import("@/data/pt/frameworks.json")).default;
|
||||
}
|
||||
}
|
||||
|
||||
export async function getConexoes(key, locale = "pt") {
|
||||
try {
|
||||
return (await import(`@/data/${locale}/conexoes/${key}.json`)).default;
|
||||
} catch {
|
||||
try {
|
||||
return (await import(`@/data/pt/conexoes/${key}.json`)).default;
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export async function getGlossario(locale = "pt") {
|
||||
try {
|
||||
return await import(`@/lib/data/${locale}/glossario.js`);
|
||||
} catch {
|
||||
return await import("@/lib/data/pt/glossario.js");
|
||||
}
|
||||
}
|
||||
|
||||
export async function getDiagnostico(locale = "pt") {
|
||||
try {
|
||||
return await import(`@/lib/data/${locale}/diagnostico.js`);
|
||||
} catch {
|
||||
return await import("@/lib/data/pt/diagnostico.js");
|
||||
}
|
||||
}
|
||||
|
||||
export async function getComponentes(locale = "pt") {
|
||||
try {
|
||||
return await import(`@/lib/data/${locale}/componentes.js`);
|
||||
} catch {
|
||||
return await import("@/lib/data/pt/componentes.js");
|
||||
}
|
||||
}
|
||||
|
||||
export async function getTopicos(locale = "pt") {
|
||||
try {
|
||||
return await import(`@/lib/data/${locale}/topicos.js`);
|
||||
} catch {
|
||||
return await import("@/lib/data/pt/topicos.js");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,858 @@
|
||||
/**
|
||||
* Base de Dados Oficial Curada: ESP Component Registry & IDF Component Manager
|
||||
*
|
||||
* O ESP Component Registry (https://components.espressif.com) é o ecossistema
|
||||
* central de distribuição de bibliotecas modulares para o ESP-IDF v4.4+ / v5.x+.
|
||||
*/
|
||||
|
||||
export const CATEGORIAS_COMPONENTES = [
|
||||
{
|
||||
id: "todos",
|
||||
nome: "Todos os Componentes",
|
||||
icone: "Layers",
|
||||
descricao: "Explore todo o catálogo curado de bibliotecas e drivers"
|
||||
},
|
||||
{
|
||||
id: "ui_display",
|
||||
nome: "UI, Displays & Gráficos",
|
||||
icone: "Monitor",
|
||||
descricao: "Bibliotecas gráficas (LVGL), drivers de display LCD/OLED, touch e decodificadores"
|
||||
},
|
||||
{
|
||||
id: "cloud_conectividade",
|
||||
nome: "Cloud & Conectividade",
|
||||
icone: "Cloud",
|
||||
descricao: "ESP RainMaker, AWS IoT, MQTT, WebSockets, Mesh-Lite e coprocessamento ESP-Hosted"
|
||||
},
|
||||
{
|
||||
id: "audio_voz_ia",
|
||||
nome: "Áudio, Voz & IA",
|
||||
icone: "Brain",
|
||||
descricao: "Reconhecimento de fala ESP-SR, processamento DSP, codecs, câmeras DVP e TinyML"
|
||||
},
|
||||
{
|
||||
id: "smart_home_mesh",
|
||||
nome: "Smart Home & Mesh",
|
||||
icone: "Home",
|
||||
descricao: "Matter SDK, pilhas Zigbee 3.0 (ZBOSS), Thread e redes ESP-NOW"
|
||||
},
|
||||
{
|
||||
id: "drivers_perifericos",
|
||||
nome: "Drivers & Sensores",
|
||||
icone: "Cpu",
|
||||
descricao: "Botões, encoders, LEDs RGB, Ethernet (W5500/CH390), USB nativo e sensores ambientais/IMU"
|
||||
},
|
||||
{
|
||||
id: "bsp_placas",
|
||||
nome: "BSPs (Board Support Packages)",
|
||||
icone: "CircuitBoard",
|
||||
descricao: "Pacotes de suporte direto para placas oficiais como ESP-BOX-3, Korvo, EYE e M5Stack"
|
||||
},
|
||||
{
|
||||
id: "sistema_utilitarios",
|
||||
nome: "Sistema & Utilitários",
|
||||
icone: "Wrench",
|
||||
descricao: "Sistemas de arquivos LittleFS, wrappers C++ modernos, CBOR e utilitários de rede"
|
||||
}
|
||||
];
|
||||
|
||||
export const COMPONENTES_REGISTRY = [
|
||||
// ==========================================
|
||||
// 1. UI, Displays & Gráficos
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-esp_lvgl_port",
|
||||
namespace: "espressif",
|
||||
name: "esp_lvgl_port",
|
||||
versao: "^2.4.0",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP LVGL Port",
|
||||
descricao: "Port oficial e thread-safe do LVGL (Light and Versatile Graphics Library) para ESP-IDF com aceleração por hardware e suporte multi-display.",
|
||||
tags: ["LVGL", "GUI", "Display", "Touch", "IHM"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-P4", "ESP32-C3", "ESP32-C6"],
|
||||
dependenciasSugeridas: ["lvgl/lvgl^9.1.0"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_lvgl_port",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/components/esp_lvgl_port",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_lvgl_port: "^2.4.0"
|
||||
lvgl/lvgl: "^9.1.0"`
|
||||
},
|
||||
{
|
||||
id: "lvgl-lvgl",
|
||||
namespace: "lvgl",
|
||||
name: "lvgl",
|
||||
versao: "^9.1.0",
|
||||
categoria: "ui_display",
|
||||
oficial: false,
|
||||
popular: true,
|
||||
titulo: "LVGL Graphics Library Core",
|
||||
descricao: "Biblioteca gráfica de código aberto em C mais popular para sistemas embarcados. Fornece widgets ricos, animações fluidas e suporte a layouts modernos.",
|
||||
tags: ["LVGL 9", "Graphics", "Widgets", "GUI", "Embedded UI"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-P4", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/lvgl/lvgl",
|
||||
urlRepo: "https://github.com/lvgl/lvgl",
|
||||
exemploYaml: `dependencies:
|
||||
lvgl/lvgl: "^9.1.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp32_display_panel",
|
||||
namespace: "espressif",
|
||||
name: "esp32_display_panel",
|
||||
versao: "^0.2.0",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP32 Display Panel Driver",
|
||||
descricao: "Driver unificado de controladores LCD (RGB, SPI, QSPI, MIPI-DSI) e touch capacitivo desenhado especialmente para ESP32-S3 e ESP32-P4.",
|
||||
tags: ["LCD", "MIPI-DSI", "QSPI", "Touch", "ST7789", "ILI9341"],
|
||||
chips: ["ESP32-S3", "ESP32-P4", "ESP32-S2", "ESP32"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp32_display_panel",
|
||||
urlRepo: "https://github.com/esp-arduino-libs/ESP32_Display_Panel",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp32_display_panel: "^0.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_lcd_touch",
|
||||
namespace: "espressif",
|
||||
name: "esp_lcd_touch",
|
||||
versao: "^1.1.2",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP LCD Touch Framework",
|
||||
descricao: "Componente central de abstração de painéis touch para telas LCD. Suporta calibragem de coordenadas, leitura de múltiplos toques e integração direta com LVGL.",
|
||||
tags: ["Touchscreen", "Capacitivo", "Resistivo", "I2C Touch", "Coordenadas"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-P4", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_lcd_touch",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/display/touch_panel/esp_lcd_touch",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_lcd_touch: "^1.1.2"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_lcd_touch_gt911",
|
||||
namespace: "espressif",
|
||||
name: "esp_lcd_touch_gt911",
|
||||
versao: "^1.1.2",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "Driver Touch Capacitivo GT911",
|
||||
descricao: "Driver I2C especializado para o controlador de touch capacitivo Goodix GT911, amplamente utilizado em displays de 4.3\", 5\" e 7\" para ESP32-S3 e P4.",
|
||||
tags: ["GT911", "Goodix", "Touch Capacitivo", "Multitouch", "I2C"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-S2"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_lcd_touch_gt911",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/display/touch_panel/esp_lcd_touch_gt911",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_lcd_touch_gt911: "^1.1.2"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_lcd_touch_ft5x06",
|
||||
namespace: "espressif",
|
||||
name: "esp_lcd_touch_ft5x06",
|
||||
versao: "^1.1.0",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "Driver Touch FocalTech FT5x06 / FT6x36",
|
||||
descricao: "Driver de painel touch capacitivo para controladores FocalTech (FT5206, FT5316, FT5436, FT6236, FT6336) com suporte a gestos e interrupções.",
|
||||
tags: ["FT6236", "FT5x06", "FocalTech", "Touch", "I2C"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-S2", "ESP32-C3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_lcd_touch_ft5x06",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/display/touch_panel/esp_lcd_touch_ft5x06",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_lcd_touch_ft5x06: "^1.1.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_jpeg",
|
||||
namespace: "espressif",
|
||||
name: "esp_jpeg",
|
||||
versao: "^1.3.0",
|
||||
categoria: "ui_display",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "ESP JPEG Decoder (TJpgDec)",
|
||||
descricao: "Decodificador e codificador JPEG de alta velocidade com otimizações SIMD em Assembly para exibir imagens e streams de câmeras em displays sem atrasos.",
|
||||
tags: ["JPEG", "TJpgDec", "Câmera", "Imagem", "SIMD"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-C3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_jpeg",
|
||||
urlRepo: "https://github.com/espressif/esp-jpeg",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_jpeg: "^1.3.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 2. Cloud & Conectividade
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-esp_rainmaker",
|
||||
namespace: "espressif",
|
||||
name: "esp_rainmaker",
|
||||
versao: "^1.4.0",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP RainMaker Agent",
|
||||
descricao: "Agente oficial de firmware para a plataforma de nuvem AIoT ESP RainMaker. Habilita controle por app móvel, Alexa, Google Home e OTA.",
|
||||
tags: ["RainMaker", "AWS Cloud", "App iOS/Android", "Alexa", "Google Home", "OTA"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_rainmaker",
|
||||
urlRepo: "https://github.com/espressif/esp-rainmaker",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_rainmaker: "^1.4.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-mesh_lite",
|
||||
namespace: "espressif",
|
||||
name: "mesh_lite",
|
||||
versao: "^1.2.0",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP Mesh-Lite Network Stack",
|
||||
descricao: "Rede em malha Wi-Fi leve onde cada nó possui conectividade IP independente, permitindo comunicação direta na rede local e acesso à nuvem com múltiplos saltos.",
|
||||
tags: ["Mesh", "Wi-Fi Mesh", "Rede em Malha", "IoT Distribuída", "IP Layer"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/mesh_lite",
|
||||
urlRepo: "https://github.com/espressif/esp-mesh-lite",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/mesh_lite: "^1.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_modbus",
|
||||
namespace: "espressif",
|
||||
name: "esp_modbus",
|
||||
versao: "^1.0.15",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-Modbus Industrial Stack",
|
||||
descricao: "Implementação completa da pilha industrial Modbus (Master/Slave) suportando interfaces RS-485 (RTU/ASCII) e Ethernet/Wi-Fi (Modbus TCP).",
|
||||
tags: ["Modbus", "RS-485", "Modbus TCP", "Automação Industrial", "PLC"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_modbus",
|
||||
urlRepo: "https://github.com/espressif/esp-modbus",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_modbus: "^1.0.15"`
|
||||
},
|
||||
{
|
||||
id: "espressif-net_connect",
|
||||
namespace: "espressif",
|
||||
name: "net_connect",
|
||||
versao: "^1.0.0",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "Unified Network Connect",
|
||||
descricao: "Componente unificado de gerenciamento de conexão de rede, alternando e inicializando de forma transparente Wi-Fi, Ethernet, Thread ou PPP móvel.",
|
||||
tags: ["Network", "Wi-Fi", "Ethernet", "Fallback", "Conexão Automática"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/net_connect",
|
||||
urlRepo: "https://github.com/espressif/esp-idf/tree/master/components",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/net_connect: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_hosted",
|
||||
namespace: "espressif",
|
||||
name: "esp_hosted",
|
||||
versao: "^0.0.10",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "ESP-Hosted Coprocessor",
|
||||
descricao: "Transforma o ESP32 em um coprocessador de comunicação sem fio (Wi-Fi + BLE) para hosts Linux (Raspberry Pi, i.MX) ou microcontroladores via SPI/SDIO/UART.",
|
||||
tags: ["Coprocessador", "SDIO", "SPI", "Linux Wi-Fi", "Raspberry Pi"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_hosted",
|
||||
urlRepo: "https://github.com/espressif/esp-hosted",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_hosted: "^0.0.10"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp-now",
|
||||
namespace: "espressif",
|
||||
name: "esp-now",
|
||||
versao: "^2.5.0",
|
||||
categoria: "cloud_conectividade",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-NOW Enhanced & Provisioning",
|
||||
descricao: "Extensão com recursos avançados de emparelhamento por controle remoto, segurança AES-128 e controle de múltiplos dispositivos com protocolo ESP-NOW.",
|
||||
tags: ["ESP-NOW", "Sem Fio", "Baixa Latência", "Broadcast", "Controle Remoto"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-now",
|
||||
urlRepo: "https://github.com/espressif/esp-now",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-now: "^2.5.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 3. Áudio, Voz & IA
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-esp-sr",
|
||||
namespace: "espressif",
|
||||
name: "esp-sr",
|
||||
versao: "^1.5.0",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-SR Speech Recognition",
|
||||
descricao: "Framework de reconhecimento de fala 100% offline com WakeNet (palavra de ativação), MultiNet (comandos locais) e algoritmos acústicos AFE.",
|
||||
tags: ["Voz", "WakeNet", "MultiNet", "Reconhecimento de Fala", "Offline", "AEC"],
|
||||
chips: ["ESP32-S3", "ESP32-P4", "ESP32"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-sr",
|
||||
urlRepo: "https://github.com/espressif/esp-sr",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-sr: "^1.5.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_codec_dev",
|
||||
namespace: "espressif",
|
||||
name: "esp_codec_dev",
|
||||
versao: "^1.3.0",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP Audio Codec Device HAL",
|
||||
descricao: "Camada unificada de abstração de codecs de áudio I2S/I2C (ES8311, ES8388, ES7210, ES7243, TAS5805M) para entrada e saída de som estéreo.",
|
||||
tags: ["Audio Codec", "I2S", "ES8311", "ES8388", "Microfone DAC"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_codec_dev",
|
||||
urlRepo: "https://github.com/espressif/esp-codec-dev",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_codec_dev: "^1.3.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-es8311",
|
||||
namespace: "espressif",
|
||||
name: "es8311",
|
||||
versao: "^1.0.0",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "Driver Codec de Áudio ES8311",
|
||||
descricao: "Driver dedicado de baixo consumo para o codec Everest ES8311 (DAC mono + ADC de microfone) presente no ESP32-S3-BOX e placas de IoT.",
|
||||
tags: ["ES8311", "Áudio", "DAC", "Microfone", "I2S"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-C3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/es8311",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/components/es8311",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/es8311: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp32-camera",
|
||||
namespace: "espressif",
|
||||
name: "esp32-camera",
|
||||
versao: "^2.0.12",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP32 Camera Driver",
|
||||
descricao: "Driver oficial de câmeras CMOS (OV2640, OV3660, OV5640, OV7670, GC0308) com suporte a DMA, DMA-2D, captura JPEG e streaming MJPEG por HTTP/RTSP.",
|
||||
tags: ["Câmera", "OV2640", "OV5640", "DVP", "MIPI-CSI", "Vídeo"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-S2"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp32-camera",
|
||||
urlRepo: "https://github.com/espressif/esp32-camera",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp32-camera: "^2.0.12"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp-dsp",
|
||||
namespace: "espressif",
|
||||
name: "esp-dsp",
|
||||
versao: "^1.5.1",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-DSP Signal Processing",
|
||||
descricao: "Biblioteca oficial de processamento digital de sinais para SoCs ESP32 (FFT, filtros digitais FIR/IIR, matrizes e álgebra linear acelerada).",
|
||||
tags: ["DSP", "FFT", "Filtros", "Matemática", "SIMD", "Assembly"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-P4", "ESP32-C3", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-dsp",
|
||||
urlRepo: "https://github.com/espressif/esp-dsp",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-dsp: "^1.5.1"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp-nn",
|
||||
namespace: "espressif",
|
||||
name: "esp-nn",
|
||||
versao: "^1.2.0",
|
||||
categoria: "audio_voz_ia",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-NN Neural Network Kernels",
|
||||
descricao: "Kernels otimizados em assembly vetorial para aceleração de redes neurais e modelos TensorFlow Lite Micro em chips ESP32.",
|
||||
tags: ["TinyML", "TensorFlow Lite", "Redes Neurais", "Inferência", "Edge AI"],
|
||||
chips: ["ESP32-S3", "ESP32-P4", "ESP32"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-nn",
|
||||
urlRepo: "https://github.com/espressif/esp-nn",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-nn: "^1.2.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 4. Smart Home & Mesh
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-esp-matter",
|
||||
namespace: "espressif",
|
||||
name: "esp-matter",
|
||||
versao: "^1.3.0",
|
||||
categoria: "smart_home_mesh",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP Matter SDK",
|
||||
descricao: "SDK oficial para criar dispositivos interoperáveis com Apple Home, Google Home, Amazon Alexa e Home Assistant sobre Wi-Fi e Thread.",
|
||||
tags: ["Matter", "Smart Home", "Apple HomeKit", "Google Home", "Thread", "CHIP"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-matter",
|
||||
urlRepo: "https://github.com/espressif/esp-matter",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-matter: "^1.3.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp-zigbee-lib",
|
||||
namespace: "espressif",
|
||||
name: "esp-zigbee-lib",
|
||||
versao: "^1.6.0",
|
||||
categoria: "smart_home_mesh",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP Zigbee 3.0 Library",
|
||||
descricao: "Pilha certificada Zigbee 3.0 (ZBOSS) para criação de nós Coordenadores, Roteadores e Dispositivos Finais de baixo consumo em chips 802.15.4.",
|
||||
tags: ["Zigbee 3.0", "ZBOSS", "802.15.4", "Home Automation", "Bateria"],
|
||||
chips: ["ESP32-H2", "ESP32-C6"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-zigbee-lib",
|
||||
urlRepo: "https://github.com/espressif/esp-zigbee-sdk",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-zigbee-lib: "^1.6.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_rcp_update",
|
||||
namespace: "espressif",
|
||||
name: "esp_rcp_update",
|
||||
versao: "^1.0.0",
|
||||
categoria: "smart_home_mesh",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "ESP RCP Thread/Zigbee Gateway",
|
||||
descricao: "Componente para atualização de coprocessador de rádio (RCP) 802.15.4 para construção de Thread Border Routers e gateways Zigbee multiprotocolo.",
|
||||
tags: ["Thread Border Router", "OpenThread", "RCP", "Zigbee Gateway"],
|
||||
chips: ["ESP32-H2", "ESP32-C6", "ESP32-S3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_rcp_update",
|
||||
urlRepo: "https://github.com/espressif/esp-thread-br",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_rcp_update: "^1.0.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 5. Drivers & Sensores
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-led_indicator",
|
||||
namespace: "espressif",
|
||||
name: "led_indicator",
|
||||
versao: "^1.2.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "LED Indicator Driver",
|
||||
descricao: "Driver inteligente para controle de padrões de iluminação de LED (piscar rápido, respiração/fade, códigos de erro e RGB) sem travar o loop principal.",
|
||||
tags: ["LED", "PWM", "RGB", "Blink", "Feedback Visual"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C2", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/led_indicator",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/led/led_indicator",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/led_indicator: "^1.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-button",
|
||||
namespace: "espressif",
|
||||
name: "button",
|
||||
versao: "^3.4.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "IoT Button Handler (iot_button)",
|
||||
descricao: "Gerenciador completo de botões com debounce, eventos de clique único, duplo, múltiplo, pressionamento longo e matrizes de teclado.",
|
||||
tags: ["Botão", "Debounce", "Long Press", "Double Click", "GPIO"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/button",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/button",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/button: "^3.4.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-led_strip",
|
||||
namespace: "espressif",
|
||||
name: "led_strip",
|
||||
versao: "^2.5.4",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "Addressable LED Strip (WS2812/SK6812)",
|
||||
descricao: "Driver de alto desempenho para fitas e matrizes de LED endereçáveis WS2812, WS2813 e SK6812 usando periféricos RMT ou SPI.",
|
||||
tags: ["WS2812B", "Neopixel", "SK6812", "RMT", "Fita de LED", "RGB"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/led_strip",
|
||||
urlRepo: "https://github.com/espressif/idf-extra-components/tree/master/led_strip",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/led_strip: "^2.5.4"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_tinyusb",
|
||||
namespace: "espressif",
|
||||
name: "esp_tinyusb",
|
||||
versao: "^1.5.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP Native USB Device (TinyUSB)",
|
||||
descricao: "Extensão oficial do TinyUSB para ESP32-S2, ESP32-S3 e ESP32-P4, permitindo emular portas seriais USB CDC, Teclado/Mouse HID, Pen Drive MSC, DFU e WebUSB.",
|
||||
tags: ["USB Nativo", "TinyUSB", "USB CDC", "USB HID", "WebUSB", "MSC"],
|
||||
chips: ["ESP32-S2", "ESP32-S3", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_tinyusb",
|
||||
urlRepo: "https://github.com/espressif/esp-tinyusb",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_tinyusb: "^1.5.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-w5500",
|
||||
namespace: "espressif",
|
||||
name: "w5500",
|
||||
versao: "^1.2.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "WIZnet W5500 SPI Ethernet Driver",
|
||||
descricao: "Driver oficial para o chip Ethernet WIZnet W5500 via barramento SPI, integrando perfeitamente a interface física à pilha TCP/IP (lwIP) nativa do ESP-IDF.",
|
||||
tags: ["W5500", "Ethernet", "SPI Ethernet", "RJ45", "lwIP", "Rede Cabeada"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/w5500",
|
||||
urlRepo: "https://github.com/espressif/esp-eth-drivers/tree/master/w5500",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/w5500: "^1.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-ch390",
|
||||
namespace: "espressif",
|
||||
name: "ch390",
|
||||
versao: "^1.0.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "CH390 SPI Ethernet Driver",
|
||||
descricao: "Driver SPI Ethernet 10/100M para o controlador WCH CH390, ideal para adicionar porta de rede RJ45 econômica em placas com ESP32-C3, S3 ou P4.",
|
||||
tags: ["CH390", "Ethernet", "WCH", "SPI Ethernet", "RJ45"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/ch390",
|
||||
urlRepo: "https://github.com/espressif/esp-eth-drivers/tree/master/ch390",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/ch390: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-usb_host_uvc",
|
||||
namespace: "espressif",
|
||||
name: "usb_host_uvc",
|
||||
versao: "^1.0.4",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "USB Host UVC (Webcam Driver)",
|
||||
descricao: "Driver USB Host para conectar webcams USB UVC padrão diretamente na porta USB nativa do ESP32-S2, ESP32-S3 ou ESP32-P4.",
|
||||
tags: ["USB Host", "UVC", "Webcam", "Câmera USB", "Vídeo"],
|
||||
chips: ["ESP32-S2", "ESP32-S3", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/usb_host_uvc",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/usb/usb_host_uvc",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/usb_host_uvc: "^1.0.4"`
|
||||
},
|
||||
{
|
||||
id: "espressif-sensor_hub",
|
||||
namespace: "espressif",
|
||||
name: "sensor_hub",
|
||||
versao: "^1.0.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "ESP Sensor Hub Manager",
|
||||
descricao: "Framework unificado para gerenciamento de sensores heterogêneos (I2C/SPI) com amostragem periódica, fusão de dados e disparo por eventos/interrupções.",
|
||||
tags: ["Sensores", "Sensor Hub", "I2C", "Eventos", "Coleta Periódica"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/sensor_hub",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/sensors/sensor_hub",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/sensor_hub: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-bmi270_sensor",
|
||||
namespace: "espressif",
|
||||
name: "bmi270_sensor",
|
||||
versao: "^1.0.1",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "Driver Sensor IMU Bosch BMI270",
|
||||
descricao: "Driver oficial para o sensor inercial IMU de 6 eixos Bosch BMI270 (Acelerômetro + Giroscópio) com detecção de gestos de movimento e passos.",
|
||||
tags: ["BMI270", "IMU", "Acelerômetro", "Giroscópio", "Bosch", "Gestos"],
|
||||
chips: ["ESP32", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/bmi270_sensor",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/sensors/imu/bmi270",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/bmi270_sensor: "^1.0.1"`
|
||||
},
|
||||
{
|
||||
id: "espressif-ds18b20",
|
||||
namespace: "espressif",
|
||||
name: "ds18b20",
|
||||
versao: "^1.0.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "Driver Sensor de Temperatura DS18B20",
|
||||
descricao: "Driver digital para sensor de temperatura 1-Wire Dallas/Maxim DS18B20 com suporte a múltiplos sensores no mesmo pino GPIO via barramento RMT.",
|
||||
tags: ["DS18B20", "1-Wire", "Temperatura", "Sensor", "Dallas"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/ds18b20",
|
||||
urlRepo: "https://github.com/espressif/esp-iot-solution/tree/master/components/sensors/temperature/ds18b20",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/ds18b20: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "esp-idf-lib-scd4x",
|
||||
namespace: "esp-idf-lib",
|
||||
name: "scd4x",
|
||||
versao: "^1.0.0",
|
||||
categoria: "drivers_perifericos",
|
||||
oficial: false,
|
||||
popular: true,
|
||||
titulo: "Driver Sensor CO2 Sensirion SCD40/SCD41",
|
||||
descricao: "Driver I2C de alta precisão para sensores fotoacústicos de CO2, temperatura e umidade relativa Sensirion SCD40 e SCD41 com auto-calibragem.",
|
||||
tags: ["SCD40", "SCD41", "Sensirion", "CO2", "Qualidade do Ar", "I2C"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/esp-idf-lib/scd4x",
|
||||
urlRepo: "https://github.com/UncleRus/esp-idf-lib/tree/master/components/scd4x",
|
||||
exemploYaml: `dependencies:
|
||||
esp-idf-lib/scd4x: "^1.0.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 6. BSPs (Board Support Packages)
|
||||
// ==========================================
|
||||
{
|
||||
id: "espressif-esp-box-3",
|
||||
namespace: "espressif",
|
||||
name: "esp-box-3",
|
||||
versao: "^1.2.0",
|
||||
categoria: "bsp_placas",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "BSP ESP32-S3-BOX-3",
|
||||
descricao: "Pacote de suporte completo para a placa de desenvolvimento de IA ESP32-S3-BOX-3, inicializando tela touch, codec de áudio, microfones duplos, sensor de movimento e LEDs com uma única função.",
|
||||
tags: ["BSP", "ESP-BOX-3", "Display Touch", "Microfone", "Áudio ES8311", "I2C/SPI"],
|
||||
chips: ["ESP32-S3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-box-3",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/bsp/esp-box-3",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-box-3: "^1.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp32_s3_korvo_2",
|
||||
namespace: "espressif",
|
||||
name: "esp32_s3_korvo_2",
|
||||
versao: "^1.1.0",
|
||||
categoria: "bsp_placas",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "BSP ESP32-S3-Korvo-2",
|
||||
descricao: "Board Support Package para o kit de desenvolvimento de áudio e reconhecimento de voz ESP32-S3-Korvo-2, com suporte a microfones I2S e botões de toque.",
|
||||
tags: ["BSP", "Korvo", "Áudio", "Array de Microfones", "ESP-SR"],
|
||||
chips: ["ESP32-S3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp32_s3_korvo_2",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/bsp/esp32_s3_korvo_2",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp32_s3_korvo_2: "^1.1.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp32_s3_eye",
|
||||
namespace: "espressif",
|
||||
name: "esp32_s3_eye",
|
||||
versao: "^1.1.0",
|
||||
categoria: "bsp_placas",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "BSP ESP32-S3-EYE",
|
||||
descricao: "Board Support Package para a placa de visão computacional oficial ESP32-S3-EYE, configurando câmera OV2640, display LCD SPI redondo e microfone digital.",
|
||||
tags: ["BSP", "ESP32-S3-EYE", "Câmera", "Visão Computacional", "Display"],
|
||||
chips: ["ESP32-S3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp32_s3_eye",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/bsp/esp32_s3_eye",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp32_s3_eye: "^1.1.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-m5stack_core_s3",
|
||||
namespace: "espressif",
|
||||
name: "m5stack_core_s3",
|
||||
versao: "^1.0.0",
|
||||
categoria: "bsp_placas",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "BSP M5Stack CoreS3",
|
||||
descricao: "Board Support Package oficial para o dispositivo M5Stack CoreS3, inicializando tela sensível ao toque, PMIC AXP2101, câmera GC0308 e alto-falante I2S.",
|
||||
tags: ["BSP", "M5Stack", "CoreS3", "Display ILI9342C", "AXP2101", "Câmera"],
|
||||
chips: ["ESP32-S3"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/m5stack_core_s3",
|
||||
urlRepo: "https://github.com/espressif/esp-bsp/tree/master/bsp/m5stack_core_s3",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/m5stack_core_s3: "^1.0.0"`
|
||||
},
|
||||
{
|
||||
id: "waveshare-esp32_p4_wifi6_touch_lcd_7b",
|
||||
namespace: "waveshare",
|
||||
name: "esp32_p4_wifi6_touch_lcd_7b",
|
||||
versao: "^1.0.0",
|
||||
categoria: "bsp_placas",
|
||||
oficial: false,
|
||||
popular: true,
|
||||
titulo: "BSP Waveshare ESP32-P4 Touch LCD 7\"",
|
||||
descricao: "Pacote de suporte para a placa de alta performance Waveshare ESP32-P4 com tela touch capacitiva de 7 polegadas (MIPI-DSI 1024x600) e coprocessador Wi-Fi 6.",
|
||||
tags: ["BSP", "ESP32-P4", "MIPI-DSI", "Waveshare", "Tela 7 Polegadas", "Touch"],
|
||||
chips: ["ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/waveshare/esp32_p4_wifi6_touch_lcd_7b",
|
||||
urlRepo: "https://github.com/waveshare/ESP32-P4-WiFi6-Touch-LCD-7B",
|
||||
exemploYaml: `dependencies:
|
||||
waveshare/esp32_p4_wifi6_touch_lcd_7b: "^1.0.0"`
|
||||
},
|
||||
|
||||
// ==========================================
|
||||
// 7. Sistema & Utilitários
|
||||
// ==========================================
|
||||
{
|
||||
id: "joltwallet-littlefs",
|
||||
namespace: "joltwallet",
|
||||
name: "littlefs",
|
||||
versao: "^1.14.8",
|
||||
categoria: "sistema_utilitarios",
|
||||
oficial: false,
|
||||
popular: true,
|
||||
titulo: "LittleFS Filesystem for ESP-IDF",
|
||||
descricao: "Port robusto do sistema de arquivos LittleFS para memória Flash SPI com wear-leveling dinâmico e proteção contra corrupção por queda de energia.",
|
||||
tags: ["LittleFS", "Flash", "Filesystem", "Wear Leveling", "NVS"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/joltwallet/littlefs",
|
||||
urlRepo: "https://github.com/joltwallet/esp_littlefs",
|
||||
exemploYaml: `dependencies:
|
||||
joltwallet/littlefs: "^1.14.8"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp-idf-cxx",
|
||||
namespace: "espressif",
|
||||
name: "esp-idf-cxx",
|
||||
versao: "^1.2.0",
|
||||
categoria: "sistema_utilitarios",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP-IDF C++ Idiomatic Wrappers",
|
||||
descricao: "Conjunto de classes e wrappers C++ modernos (C++17/C++20/C++23) com semântica RAII para GPIOs, Wi-Fi, timers, filas FreeRTOS e semáforos.",
|
||||
tags: ["C++", "C++20", "RAII", "Modern C++", "Object Oriented", "FreeRTOS"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp-idf-cxx",
|
||||
urlRepo: "https://github.com/espressif/esp-idf-cxx",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp-idf-cxx: "^1.2.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-cbor",
|
||||
namespace: "espressif",
|
||||
name: "cbor",
|
||||
versao: "^0.6.0",
|
||||
categoria: "sistema_utilitarios",
|
||||
oficial: true,
|
||||
popular: false,
|
||||
titulo: "TinyCBOR Serialization",
|
||||
descricao: "Biblioteca ultraleve para serialização e deserialização de dados em formato binário CBOR (Concise Binary Object Representation).",
|
||||
tags: ["CBOR", "Serialização", "Binário", "IoT Protocol", "JSON Compacto"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-H2", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/cbor",
|
||||
urlRepo: "https://github.com/espressif/tinycbor",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/cbor: "^0.6.0"`
|
||||
},
|
||||
{
|
||||
id: "espressif-esp_websocket_client",
|
||||
namespace: "espressif",
|
||||
name: "esp_websocket_client",
|
||||
versao: "^1.2.4",
|
||||
categoria: "sistema_utilitarios",
|
||||
oficial: true,
|
||||
popular: true,
|
||||
titulo: "ESP WebSocket Client",
|
||||
descricao: "Cliente WebSocket bidirecional em tempo real com suporte a TLS/SSL (WSS), reconexão automática, sub-protocolos e ping/pong de heartbeat.",
|
||||
tags: ["WebSocket", "WSS", "TLS", "Tempo Real", "Sockets", "JSON"],
|
||||
chips: ["ESP32", "ESP32-S2", "ESP32-S3", "ESP32-C3", "ESP32-C6", "ESP32-P4"],
|
||||
urlRegistry: "https://components.espressif.com/components/espressif/esp_websocket_client",
|
||||
urlRepo: "https://github.com/espressif/esp-protocols/tree/master/components/esp_websocket_client",
|
||||
exemploYaml: `dependencies:
|
||||
espressif/esp_websocket_client: "^1.2.4"`
|
||||
}
|
||||
];
|
||||
|
||||
export const GUIA_COMPONENT_MANAGER = {
|
||||
titulo: "Como Usar o ESP Component Registry no ESP-IDF",
|
||||
resumo: "A partir do ESP-IDF v4.4 e consolidado no v5.x+, a Espressif adotou a arquitetura de pacotes modulares gerenciada pelo IDF Component Manager. Esqueça submódulos git complexos: agora basta declarar as bibliotecas no arquivo de manifesto idf_component.yml do seu projeto.",
|
||||
vantagens: [
|
||||
{
|
||||
titulo: "Instalação Automática e Desacoplada",
|
||||
descricao: "O compilador baixa, compila e gerencia as versões das bibliotecas automaticamente durante o 'idf.py build' ou 'idf.py reconfigure'."
|
||||
},
|
||||
{
|
||||
titulo: "Versionamento Semântico Rigoroso",
|
||||
descricao: "Controle exatamente quando atualizar com operadores de versão (^ para compatibilidade minor, ~ para patches ou versões exatas fixas)."
|
||||
},
|
||||
{
|
||||
titulo: "Projetos mais Leves e Limpos",
|
||||
descricao: "O repositório do seu projeto fica limpo, sem carregar código de terceiros dentro do histórico do Git."
|
||||
},
|
||||
{
|
||||
titulo: "Compartilhamento Corporativo ou Comunitário",
|
||||
descricao: "Publique seus próprios componentes na nuvem pública da Espressif ou em registros privados locais da sua empresa."
|
||||
}
|
||||
],
|
||||
comandosCli: [
|
||||
{
|
||||
comando: 'idf.py add-dependency "namespace/componente^versao"',
|
||||
exemplo: 'idf.py add-dependency "espressif/esp_lvgl_port^2.4.0"',
|
||||
explicacao: "Cria ou atualiza automaticamente o arquivo 'main/idf_component.yml' adicionando a dependência informada."
|
||||
},
|
||||
{
|
||||
comando: "idf.py reconfigure",
|
||||
exemplo: "idf.py reconfigure",
|
||||
explicacao: "Força o CMake e o Component Manager a resolver novamente a árvore de dependências e baixar pacotes pendentes."
|
||||
},
|
||||
{
|
||||
comando: "compote component upload --name <component_name> --namespace <sua_org>",
|
||||
exemplo: "compote component upload --name meu_driver_sensor --namespace minhadiv",
|
||||
explicacao: "Publica seu componente de código aberto ou proprietário no ESP Component Registry usando a ferramenta oficial Compote CLI."
|
||||
}
|
||||
],
|
||||
sintaxeManifesto: `# Estrutura típica do arquivo: main/idf_component.yml
|
||||
dependencies:
|
||||
# Baixa do registro oficial da Espressif
|
||||
espressif/esp_lvgl_port: "^2.4.0"
|
||||
espressif/button: "~3.4.0"
|
||||
|
||||
# Versão exata
|
||||
espressif/led_indicator: "1.2.0"
|
||||
|
||||
# Dependência da comunidade
|
||||
joltwallet/littlefs: "^1.14.8"
|
||||
|
||||
# Dependência local no seu disco (opcional)
|
||||
# meu_driver_local:
|
||||
# path: "../../components/meu_driver"`
|
||||
};
|
||||
@@ -0,0 +1,743 @@
|
||||
/**
|
||||
* 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
|
||||
* em Arduino C++, ESP-IDF (C) e MicroPython.
|
||||
*/
|
||||
|
||||
export const categoriasDiagnostico = [
|
||||
{
|
||||
id: "alimentacao",
|
||||
nome: "Alimentação & Hardware",
|
||||
icone: "Zap",
|
||||
cor: "amber",
|
||||
descricao: "Quedas de tensão por picos de RF Wi-Fi/BLE, strapping pins conflitantes, ruído eletromagnético e problemas de LDO.",
|
||||
},
|
||||
{
|
||||
id: "cpu-panics",
|
||||
nome: "Pânicos de CPU & Guru Meditation",
|
||||
icone: "Cpu",
|
||||
cor: "red",
|
||||
descricao: "Ponteiros nulos, violações de memória (Load/StoreProhibited), instruções ilegais e cache panics em ISR.",
|
||||
},
|
||||
{
|
||||
id: "freertos",
|
||||
nome: "FreeRTOS & Multitarefa",
|
||||
icone: "Layers",
|
||||
cor: "purple",
|
||||
descricao: "Task Watchdog (TWDT), Interrupt Watchdog (IWDT), estouro de pilha (Stack Overflow) e bloqueios de escalonador.",
|
||||
},
|
||||
{
|
||||
id: "memoria",
|
||||
nome: "Memória, Heap & PSRAM",
|
||||
icone: "Activity",
|
||||
cor: "blue",
|
||||
descricao: "Fragmentação de Heap, vazamento de memória (Memory Leaks), alocações para DMA e limitações de PSRAM.",
|
||||
},
|
||||
{
|
||||
id: "boot-flash",
|
||||
nome: "Bootloader & Gravação",
|
||||
icone: "Terminal",
|
||||
cor: "emerald",
|
||||
descricao: "Falha de comunicação serial (DTR/RTS), erros de leitura SPI Flash, incompatibilidade de clock e partições.",
|
||||
},
|
||||
{
|
||||
id: "conectividade",
|
||||
nome: "Conectividade & Protocolos",
|
||||
icone: "Wifi",
|
||||
cor: "cyan",
|
||||
descricao: "Wi-Fi Beacon Timeout, falhas de handshake TLS/HTTPS por falta de relógio SNTP e instabilidade de sinal.",
|
||||
},
|
||||
];
|
||||
|
||||
export const sintomasRapidos = [
|
||||
{ id: "bootloop", rotulo: "🔄 Reiniciando em loop (Bootloop)", categoria: "todos" },
|
||||
{ id: "wifi-crash", rotulo: "📶 Trava ao ligar Wi-Fi/BLE", categoria: "alimentacao" },
|
||||
{ id: "upload-fail", rotulo: "🔌 Falha ao gravar código (Upload)", categoria: "boot-flash" },
|
||||
{ id: "random-freeze", rotulo: "⏱️ Trava após minutos/horas", categoria: "memoria" },
|
||||
{ id: "null-pointer", rotulo: "💥 Guru Meditation (Crash)", categoria: "cpu-panics" },
|
||||
{ id: "wdt-reset", rotulo: "🐕 Watchdog Triggered", categoria: "freertos" },
|
||||
{ id: "tls-fail", rotulo: "🔒 Falha em HTTPS / SSL", categoria: "conectividade" },
|
||||
];
|
||||
|
||||
export const errosCatalogo = [
|
||||
{
|
||||
id: "brownout-reset",
|
||||
titulo: "Brownout Detector Reset (Queda de Tensão)",
|
||||
categoria: "alimentacao",
|
||||
sintomas: ["bootloop", "wifi-crash"],
|
||||
gravidade: "Alta",
|
||||
logSerial: "Brownout detector was triggered\n\nrst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)",
|
||||
resumo: "A tensão de alimentação do ESP32 caiu abaixo do limiar operacional seguro (aproximadamente 2.8V ~ 2.43V).",
|
||||
causaRaiz:
|
||||
"Quando o rádio Wi-Fi ou BLE é ligado, o estágio de potência (PA) consome pulsos de corrente muito rápidos que podem superar 500mA em menos de 1 milissegundo. Se a fonte de alimentação, os cabos USB longos/finos, os trilhos de protoboard ou o regulador LDO não fornecerem corrente instantânea com baixa impedância, a tensão no pino 3V3 do chip afunda momentaneamente, disparando o circuito comparador interno de Brownout para evitar corrupção de memória Flash e estados indeterminados.",
|
||||
gambiarra: {
|
||||
titulo: "Desativar o Brownout por software",
|
||||
descricao: "Chamar WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) para silenciar o erro no código.",
|
||||
consequencia: "Extremamente perigoso: o ESP32 continuará executando instruções sob subtensão, corrompendo a memória Flash SPI, travando registradores e causando comportamento imprevisível em campo sem aviso.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Dimensionamento correto de hardware e desacoplamento",
|
||||
passos: [
|
||||
"Adicione um capacitor de tântalo ou cerâmico de 10µF a 100µF de baixo ESR (Low-ESR) em paralelo com um cerâmico de 100nF o mais próximo possível dos pinos 3V3 e GND do ESP32.",
|
||||
"Utilize reguladores LDO projetados para picos de no mínimo 600mA a 1A com excelente resposta a transitórios (ex: AP2112K, ME6211, TPS73733 ou XC6206 robusto). Evite clones de baixa qualidade do antigo AMS1117.",
|
||||
"Evite alimentar o ESP32 via trilhos compridos de protoboard com cabos jumper finos quando o Wi-Fi estiver transmitindo em potência máxima.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// NÃO desative o Brownout! Se precisar reduzir o pico em testes:
|
||||
#include <WiFi.h>
|
||||
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
|
||||
// Opcional: Reduzir ligeiramente a potência máxima de transmissão do Wi-Fi
|
||||
// de 20dBm para 17dBm diminui o pico de corrente em ~20%
|
||||
WiFi.setTxPower(WIFI_POWER_17dBm);
|
||||
WiFi.begin("SSID", "SENHA");
|
||||
}`,
|
||||
codigoEspIdf: `// Configuração no ESP-IDF:
|
||||
#include "esp_wifi.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
void app_main(void) {
|
||||
// No menuconfig: Component config -> ESP32-specific -> Hardware Brownout Reset (Mantenha sempre ATIVO)
|
||||
// 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).",
|
||||
},
|
||||
{
|
||||
id: "strapping-pins",
|
||||
titulo: "Conflito de Strapping Pins no Boot",
|
||||
categoria: "alimentacao",
|
||||
sintomas: ["bootloop", "upload-fail"],
|
||||
gravidade: "Crítica",
|
||||
logSerial: "rst:0x1 (POWERON_RESET),boot:0x12 (SPI_FAST_FLASH_BOOT)\nflash read err, 1000\nwaiting for download",
|
||||
resumo: "O ESP32 não inicializa o firmware da Flash ou entra acidentalmente em modo de download porque um pino de strapping foi forçado a um nível lógico incorreto no reset.",
|
||||
causaRaiz:
|
||||
"No momento exato em que o pino EN/CHIP_PU sobe (Power-On Reset), a CPU amostra o estado de pinos específicos (Strapping Pins) para configurar tensão de Flash (1.8V vs 3.3V), modo de boot (Download UART vs SPI Flash) e saída de clock. Se você conectar sensores, relés ou LEDs com pull-up/pull-down nesses pinos, o microcontrolador lerá um nível lógico inválido e travará o boot.",
|
||||
gambiarra: {
|
||||
titulo: "Colocar delays no código ou desconectar na mão toda vez que liga",
|
||||
descricao: "Tentar tratar o problema via software no setup() ou depender de desconectar fios manualmente antes de cada reinicialização.",
|
||||
consequencia: "Inútil: os Strapping Pins são lidos por hardware antes mesmo da CPU carregar qualquer linha do seu código ou do bootloader.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Mapeamento seguro de GPIOs e isolamento no reset",
|
||||
passos: [
|
||||
"ESP32 Clássico: Evite usar GPIO 0 (Boot), GPIO 2 (deve estar LOW ou flutuando no flash), GPIO 12 (define tensão de Flash: se puxado para HIGH no reset, queima/trava a flash de 3.3V) e GPIO 15 (silencia mensagens de log de boot se LOW).",
|
||||
"ESP32-C3: Evite puxar GPIO 8 para LOW ou GPIO 9 para LOW no reset.",
|
||||
"ESP32-S3: Atenção com GPIO 0, GPIO 45 (tensão VDD_SPI) e GPIO 46.",
|
||||
"Se for estritamente necessário usar esses pinos para periféricos, utilize transistores ou buffers para isolá-los até que o sinal EN esteja totalmente estabilizado.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// RECOMENDAÇÃO DE PINAGEM SEGURA (ESP32 Clássico):
|
||||
// Pinos ideais para I2C / SPI / Sensores gerais:
|
||||
// SDA: GPIO 21 | SCL: GPIO 22
|
||||
// SPI: MOSI 23 | MISO 19 | SCK 18 | CS 5
|
||||
|
||||
// ATENÇÃO: GPIOs 34, 35, 36 (VP), 39 (VN) são APENAS ENTRADA (sem pull-up interno).
|
||||
// Nunca tente usá-los como pinMode(..., OUTPUT); nem para I2C/SPI.`,
|
||||
codigoEspIdf: `// No ESP-IDF, proteja a configuração de tensão de Flash via eFuse (CUIDADO: IRREVERSÍVEL):
|
||||
// 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.",
|
||||
},
|
||||
{
|
||||
id: "guru-load-prohibited",
|
||||
titulo: "Guru Meditation: LoadProhibited / StoreProhibited",
|
||||
categoria: "cpu-panics",
|
||||
sintomas: ["bootloop", "null-pointer"],
|
||||
gravidade: "Crítica",
|
||||
logSerial: "Guru Meditation Error: Core 0 panic'ed (LoadProhibited). Exception was unhandled.\nCore 0 register dump:\nPC : 0x400d14bc PS : 0x00060830 A0 : 0x800d1512 A1 : 0x3ffb1f20 \nEXCVADDR: 0x00000000",
|
||||
resumo: "A CPU tentou ler (Load) ou escrever (Store) em um endereço de memória inacessível ou inválido, tipicamente o endereço nulo 0x00000000.",
|
||||
causaRaiz:
|
||||
"Essa é a clássica desreferência de ponteiro nulo (Null Pointer Dereference) ou uso de ponteiro solto (Dangling Pointer). O registrador EXCVADDR indica o endereço que causou a falha: se EXCVADDR for 0x00000000 ou muito próximo de zero (ex: 0x00000008, que é um offset de struct), significa que você tentou acessar membros de um objeto/ponteiro que não foi inicializado ou cujo malloc/criação falhou.",
|
||||
gambiarra: {
|
||||
titulo: "Adicionar delays aleatórios ou reiniciar no loop sem tratar",
|
||||
descricao: "Achar que é problema de temporização e encher o código de delay() ou mascarar o reinício automático sem investigar a causa.",
|
||||
consequencia: "O sistema continuará quebrando aleatoriamente em produção quando a condição de ponteiro nulo se repetir.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Validação defensiva e Decodificação de Backtrace",
|
||||
passos: [
|
||||
"Verifique sempre se retornos de funções de alocação ou busca (malloc, WiFi.client(), JSON parsing, xQueueReceive) não retornaram NULL antes de acessar seus campos.",
|
||||
"Instale o 'Espressif Exception Decoder' na sua IDE (Arduino IDE / PlatformIO) ou use o comando 'xtensa-esp32-elf-addr2line -pfia -e firmware.elf 0x400d14bc' para descobrir exatamente a linha do seu código .c/.cpp onde o crash aconteceu.",
|
||||
"No ESP-IDF, execute 'idf.py monitor' que decodifica o backtrace de pilha automaticamente em tempo real.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// PROGRAMAÇÃO DEFENSIVA:
|
||||
struct SensorData {
|
||||
float temperatura;
|
||||
float umidade;
|
||||
};
|
||||
|
||||
void processarSensor(SensorData* sensor) {
|
||||
// Verificação obrigatória contra LoadProhibited:
|
||||
if (sensor == nullptr) {
|
||||
Serial.println("[ERRO] Ponteiro de sensor nulo!");
|
||||
return;
|
||||
}
|
||||
|
||||
Serial.printf("Temp: %.1f C\\n", sensor->temperatura);
|
||||
}`,
|
||||
codigoEspIdf: `// No ESP-IDF, use ESP_ERROR_CHECK ou assertivas explícitas:
|
||||
#include "esp_log.h"
|
||||
#include "esp_check.h"
|
||||
|
||||
static const char* TAG = "SENSOR";
|
||||
|
||||
esp_err_t ler_dado(char* buffer, size_t max_len) {
|
||||
ESP_RETURN_ON_FALSE(buffer != NULL, ESP_ERR_INVALID_ARG, TAG, "Buffer nulo fornecido!");
|
||||
// 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.",
|
||||
},
|
||||
{
|
||||
id: "guru-iram-cache",
|
||||
titulo: "Cache Error / InstructionFetchError em ISRs",
|
||||
categoria: "cpu-panics",
|
||||
sintomas: ["bootloop", "null-pointer"],
|
||||
gravidade: "Alta",
|
||||
logSerial: "Guru Meditation Error: Core 0 panic'ed (Cache disabled but cached memory region accessed)\nGuru Meditation Error: Core 0 panic'ed (InstructionFetchError)",
|
||||
resumo: "Uma rotina de interrupção (ISR) tentou executar código ou ler dados da Flash SPI enquanto a Flash estava desativada para uma operação de escrita/leitura.",
|
||||
causaRaiz:
|
||||
"Por padrão, o código do ESP32 fica armazenado na memória Flash externa e é carregado sob demanda para a CPU através da memória Cache interna. Quando o ESP32 grava dados na Flash (como em gravações NVS, LittleFS, SPIFFS ou atualização OTA), o controlador desativa o Cache de instruções temporariamente. Se uma interrupção de hardware (timer, GPIO, etc.) disparar nesse instante e a função ISR estiver na Flash, a CPU não consegue buscar a próxima instrução e entra em pânico imediato.",
|
||||
gambiarra: {
|
||||
titulo: "Desativar interrupções antes de gravar na Flash",
|
||||
descricao: "Tentar envolver operações de gravação de arquivos em blocos de noInterrupts() indiscriminadamente.",
|
||||
consequencia: "Gera perda de pulsos de sensores de alta velocidade, instabilidade nos timers do sistema e potenciais estouros de Watchdog.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Alocar ISRs e constantes em IRAM / DRAM",
|
||||
passos: [
|
||||
"Decore TODA função de callback de interrupção com o atributo IRAM_ATTR (ou IRAM_ATTR static void...).",
|
||||
"Garanta que variáveis ou strings acessadas dentro da ISR também residam em DRAM (evite usar strings literais diretas dentro da ISR sem a tag DRAM_ATTR no ESP-IDF).",
|
||||
"Nunca chame funções pesadas de bibliotecas externas (como Serial.print ou cálculos de float pesados) dentro de uma ISR.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// ISR declarada corretamente na IRAM:
|
||||
volatile uint32_t contadorPulsos = 0;
|
||||
|
||||
void IRAM_ATTR tratarInterrupcaoGPIO() {
|
||||
contadorPulsos++;
|
||||
}
|
||||
|
||||
void setup() {
|
||||
pinMode(4, INPUT_PULLUP);
|
||||
attachInterrupt(digitalPinToInterrupt(4), tratarInterrupcaoGPIO, FALLING);
|
||||
}`,
|
||||
codigoEspIdf: `// No ESP-IDF:
|
||||
#include "esp_attr.h"
|
||||
#include "driver/gpio.h"
|
||||
|
||||
static volatile uint32_t pulsos = 0;
|
||||
|
||||
// Função colocada explicitamente na memória interna IRAM:
|
||||
static void IRAM_ATTR gpio_isr_handler(void* arg) {
|
||||
pulsos++;
|
||||
}
|
||||
|
||||
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).",
|
||||
},
|
||||
{
|
||||
id: "freertos-twdt",
|
||||
titulo: "Task Watchdog Timer (TWDT) Timeout",
|
||||
categoria: "freertos",
|
||||
sintomas: ["bootloop", "wdt-reset"],
|
||||
gravidade: "Crítica",
|
||||
logSerial: "E (10532) task_wdt: Task watchdog got triggered. The following tasks/users did not reset the watchdog in time:\nE (10532) task_wdt: - IDLE0 (CPU 0)\nTask watchdog got triggered. System will be reset.",
|
||||
resumo: "Uma tarefa de alta prioridade entrou em um loop bloqueante e não cedeu tempo de CPU, impedindo que a tarefa IDLE alimente o cão de guarda.",
|
||||
causaRaiz:
|
||||
"O FreeRTOS no ESP32 executa uma tarefa essencial de prioridade 0 chamada IDLE em cada núcleo de CPU. O Task Watchdog monitora se a tarefa IDLE consegue rodar periodicamente (por padrão, a cada 5 segundos). Se você criar uma tarefa com prioridade >= 1 que contenha um loop while(1) sem nenhuma chamada bloqueante (vTaskDelay, leitura de fila, semáforo), a CPU fica 100% ocupada e o Watchdog dispara um reset de emergência.",
|
||||
gambiarra: {
|
||||
titulo: "Desabilitar o Task Watchdog no menuconfig ou aumentar para 60s",
|
||||
descricao: "Desligar o TWDT para o código parar de reiniciar.",
|
||||
consequencia: "Se o seu código travar em um loop infinito ou deadlock, o microcontrolador ficará congelado para sempre, exigindo que alguém vá até o local desligar da tomada.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Arquitetura orientada a eventos e concessão de CPU (Yield)",
|
||||
passos: [
|
||||
"Nunca utilize loops de espera ativa vazios while(!condicao); em tarefas FreeRTOS.",
|
||||
"Sempre insira vTaskDelay(pdMS_TO_TICKS(10)) ou espere por um evento através de xQueueReceive(), ulTaskNotifyTake() ou xSemaphoreTake() com timeout.",
|
||||
"Se for necessário executar um processamento matemático contínuo e pesado, alimente o Watchdog explicitamente com esp_task_wdt_reset().",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// FORMA CORRETA NO ARDUINO COM FREERTOS:
|
||||
void minhaTarefa(void *pvParameters) {
|
||||
for (;;) {
|
||||
// Executa a leitura do sensor
|
||||
float valor = analogRead(36);
|
||||
|
||||
// LIBERA a CPU para o FreeRTOS e a tarefa IDLE:
|
||||
vTaskDelay(pdMS_TO_TICKS(100)); // Aguarda 100ms de forma não-bloqueante
|
||||
}
|
||||
}`,
|
||||
codigoEspIdf: `// ESP-IDF com Task Watchdog:
|
||||
#include "esp_task_wdt.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
void tarefa_processamento(void *pvParameters) {
|
||||
// Opcional: Inscrever a própria tarefa no TWDT
|
||||
esp_task_wdt_add(NULL);
|
||||
|
||||
while (1) {
|
||||
// Processamento...
|
||||
|
||||
// Alimenta o Watchdog se o bloco for longo:
|
||||
esp_task_wdt_reset();
|
||||
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.",
|
||||
},
|
||||
{
|
||||
id: "freertos-stack-overflow",
|
||||
titulo: "Stack Overflow (Estouro de Pilha da Tarefa)",
|
||||
categoria: "freertos",
|
||||
sintomas: ["bootloop", "null-pointer"],
|
||||
gravidade: "Crítica",
|
||||
logSerial: "Guru Meditation Error: Core 1 panic'ed (Unhandled debug exception).\nDebug exception reason: Stack canary watchpoint triggered (minha_tarefa)",
|
||||
resumo: "A tarefa consumiu mais memória de pilha (Stack) do que a quantidade alocada em sua criação, corrompendo o canário de proteção do RTOS.",
|
||||
causaRaiz:
|
||||
"Cada tarefa no FreeRTOS recebe um bloco fixo de memória contígua para suas variáveis locais, argumentos de funções e endereços de retorno de chamadas. Se você declarar arrays grandes (ex: char buffer[2048];), instanciar buffers JSON pesados (ex: DynamicJsonDocument doc(4096);), ou fizer chamadas recursivas profundas dentro de uma tarefa configurada com stack padrão de 2048 bytes, a pilha ultrapassa o limite e sobrescreve áreas críticas do sistema.",
|
||||
gambiarra: {
|
||||
titulo: "Colocar 64KB de stack em todas as tarefas sem critério",
|
||||
descricao: "Alocar stacks gigantescas para não se preocupar com estouro.",
|
||||
consequencia: "A memória interna SRAM do ESP32 (cerca de 320KB úteis) se esgotará rapidamente, causando falhas de inicialização do Wi-Fi e alocação de heap.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Dimensionamento consciente e monitoramento com HighWaterMark",
|
||||
passos: [
|
||||
"Meça o consumo real da pilha usando a função uxTaskGetStackHighWaterMark(). Ela retorna o menor número de bytes/words livres restantes que a pilha teve desde o boot.",
|
||||
"Mova buffers volumosos da pilha para a Heap dinâmica (usando malloc/free temporário) ou declare-os como static fora do escopo da função se forem reutilizados.",
|
||||
"Tarefas que utilizam conexões seguras TLS/HTTPS ou MQTT com SSL exigem no mínimo 6KB a 8KB de stack devido à complexidade das rotinas criptográficas do MbedTLS.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// MONITORANDO O STACK NO ARDUINO:
|
||||
void tarefaSensor(void *pvParameters) {
|
||||
for (;;) {
|
||||
// Código da tarefa...
|
||||
|
||||
// Verifica o espaço livre mínimo da pilha (em Words no FreeRTOS clássico / Bytes no ESP32)
|
||||
UBaseType_t espacoLivre = uxTaskGetStackHighWaterMark(NULL);
|
||||
Serial.printf("[STACK] Espaço livre mínimo: %d bytes\\n", (int)espacoLivre);
|
||||
|
||||
vTaskDelay(pdMS_TO_TICKS(5000));
|
||||
}
|
||||
}
|
||||
|
||||
void setup() {
|
||||
Serial.begin(115200);
|
||||
// Aloca 4096 bytes (4KB) de forma equilibrada:
|
||||
xTaskCreatePinnedToCore(tarefaSensor, "tarefaSensor", 4096, NULL, 1, NULL, 1);
|
||||
}`,
|
||||
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.",
|
||||
},
|
||||
{
|
||||
id: "memoria-fragmentacao-heap",
|
||||
titulo: "Fragmentação de Heap e Memory Leaks",
|
||||
categoria: "memoria",
|
||||
sintomas: ["random-freeze", "tls-fail"],
|
||||
gravidade: "Alta",
|
||||
logSerial: "E (45892) mbedtls: mbedtls_ssl_setup returned -0x7f00\nE (45892) esp-tls: create_ssl_handle failed\nE (45893) HTTP_CLIENT: Connection failed, out of memory",
|
||||
resumo: "O microcontrolador falha ao alocar memória mesmo reportando uma quantidade total de memória livre aparentemente alta.",
|
||||
causaRaiz:
|
||||
"A memória Heap fica fragmentada quando ocorrem milhares de alocações e desalocações de tamanhos variados ao longo do tempo (muito comum ao usar objetos String do Arduino com concatenação contínua de texto em loops). O heap se divide em pequenos blocos livres separados por blocos ocupados. Quando o driver de Wi-Fi ou a biblioteca TLS precisa de um único bloco contíguo de 40KB para o buffer de criptografia SSL, o malloc falha mesmo que existam 100KB de memória livre total dispersa.",
|
||||
gambiarra: {
|
||||
titulo: "Reiniciar o ESP32 periodicamente com ESP.restart() a cada X horas",
|
||||
descricao: "Agendar um reboot diário para limpar a memória fragmentada.",
|
||||
consequencia: "Apenas camufla o defeito: em condições de pico de requisições o dispositivo cairá muito antes do reboot programado.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Evitar strings dinâmicas e utilizar buffers estáticos pré-alocados",
|
||||
passos: [
|
||||
"No Arduino, evite a classe String. Utilize buffers de caracteres em estilo C (char buffer[128];) com funções seguras como snprintf().",
|
||||
"Monitore a fragmentação acompanhando a relação entre a memória livre total (heap_caps_get_free_size) e o maior bloco contíguo livre (heap_caps_get_largest_free_block).",
|
||||
"Em firmwares complexos no ESP-IDF, ative o Heap Memory Tracing (CONFIG_HEAP_TRACING) para listar exatamente quais arquivos e linhas esqueceram de chamar free().",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// COMPARAÇÃO:
|
||||
// ❌ EVITE (Gera fragmentação severa de Heap):
|
||||
// String json = "{\\"temp\\":";
|
||||
// json += String(temperatura) + "}";
|
||||
|
||||
// ✅ CORRETO (Sem alocação dinâmica no Heap):
|
||||
char payload[64];
|
||||
snprintf(payload, sizeof(payload), "{\\"temp\\":%.2f,\\"umid\\":%.2f}", temperatura, umidade);
|
||||
|
||||
// Monitoramento:
|
||||
Serial.printf("Heap Livre: %u | Maior Bloco: %u\\n",
|
||||
ESP.getFreeHeap(),
|
||||
ESP.getMaxAllocHeap());`,
|
||||
codigoEspIdf: `// Monitoramento de Heap no ESP-IDF:
|
||||
#include "esp_heap_caps.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
void inspecionar_memoria(void) {
|
||||
size_t livre_total = heap_caps_get_free_size(MALLOC_CAP_8BIT);
|
||||
size_t maior_bloco = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
|
||||
|
||||
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.",
|
||||
},
|
||||
{
|
||||
id: "memoria-dma-psram",
|
||||
titulo: "Falha de Alocação DMA em Memória Externa (PSRAM)",
|
||||
categoria: "memoria",
|
||||
sintomas: ["bootloop", "random-freeze"],
|
||||
gravidade: "Alta",
|
||||
logSerial: "E (1204) spi_master: spi_bus_initialize: DMA channel not compatible with external RAM buffer\nESP_ERROR_CHECK failed: esp_err_t 0x102 (ESP_ERR_INVALID_ARG)",
|
||||
resumo: "O firmware tentou passar um buffer alocado em PSRAM externa para um periférico com DMA (SPI, I2S, LCD, SDMMC) que só tem acesso à SRAM interna.",
|
||||
causaRaiz:
|
||||
"Nos chips da família ESP32 (especialmente ESP32 clássico, ESP32-S2 e ESP32-S3 com barramento padrão), o controlador de DMA dos periféricos não possui barramento físico com acesso direto à memória PSRAM externa conectada via SPI/QSPI. O DMA exige que os buffers de transmissão e recepção estejam obrigatoriamente localizados na SRAM interna do chip.",
|
||||
gambiarra: {
|
||||
titulo: "Desativar o DMA nos periféricos",
|
||||
descricao: "Configurar o barramento SPI/I2S para operar em modo por polling sem DMA.",
|
||||
consequencia: "A taxa de transferência cai drasticamente e a CPU fica 100% ocupada durante o envio de frames para displays ou streaming de áudio.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Alocação explícita com MALLOC_CAP_DMA e MALLOC_CAP_INTERNAL",
|
||||
passos: [
|
||||
"Sempre aloque buffers dedicados a DMA utilizando a função heap_caps_malloc(tamanho, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL).",
|
||||
"Mantenha dados pesados não-DMA (como imagens decodificadas, modelos de machine learning e áudio em repouso) na PSRAM, e copie blocos menores para buffers de DMA internos sob demanda (ping-pong buffering).",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// Alocando buffer para DMA no Arduino ESP32:
|
||||
#include <esp_heap_caps.h>
|
||||
|
||||
uint8_t* dmaBuffer = nullptr;
|
||||
|
||||
void setup() {
|
||||
size_t tamanho = 4096;
|
||||
// Garante que o buffer reside na SRAM interna compatível com DMA:
|
||||
dmaBuffer = (uint8_t*) heap_caps_malloc(tamanho, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
|
||||
|
||||
if (dmaBuffer == nullptr) {
|
||||
Serial.println("[ERRO] Falha ao alocar buffer DMA na memória interna!");
|
||||
}
|
||||
}`,
|
||||
codigoEspIdf: `// ESP-IDF:
|
||||
#include "esp_heap_caps.h"
|
||||
|
||||
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.",
|
||||
},
|
||||
{
|
||||
id: "boot-failed-connect",
|
||||
titulo: "Failed to connect to ESP32: Timed out waiting for packet header",
|
||||
categoria: "boot-flash",
|
||||
sintomas: ["upload-fail"],
|
||||
gravidade: "Média",
|
||||
logSerial: "A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header\nesptool.py v4.6\nConnecting...................",
|
||||
resumo: "A ferramenta de gravação (esptool / Arduino IDE / PlatformIO) não conseguiu colocar o microcontrolador no modo de bootloader UART.",
|
||||
causaRaiz:
|
||||
"Para iniciar a gravação do firmware, o chip de conversão USB-Serial (CH340, CP2102, FTDI) utiliza as linhas DTR e RTS para puxar o pino GPIO 0 para LOW enquanto pulsa o pino EN/RST para LOW e depois HIGH. Em muitas placas de desenvolvimento populares, o circuito de temporização RC (resistor-capacitor) do pino EN não possui capacitância suficiente para segurar o reset durante a transição do sinal DTR.",
|
||||
gambiarra: {
|
||||
titulo: "Ficar segurando o botão BOOT com o dedo a cada upload",
|
||||
descricao: "Pressionar o botão físico BOOT/GPIO0 toda vez que o compilador terminar de gerar o binário.",
|
||||
consequencia: "Inconveniente para desenvolvimento ágil e impossível em placas seladas ou embutidas dentro de gabinetes.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Capacitor de 10µF no pino EN ou verificação do cabo de dados",
|
||||
passos: [
|
||||
"Conecte um capacitor eletrolítico ou cerâmico de 10µF (ou 1µF a 10µF) entre o pino EN (RST) e o GND da placa. Isso estabiliza a rampa de reset automático.",
|
||||
"Verifique se o cabo USB possui linhas de dados (D+ e D-) ativas. Muitos cabos de carregador de celular baratos possuem apenas os fios de alimentação VBUS e GND.",
|
||||
"No Linux, certifique-se de que seu usuário pertence ao grupo 'dialout' (sudo usermod -a -G dialout $USER) e que o serviço 'brltty' não está sequestrando a porta serial.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// Dica de Linha de Comando para testar a comunicação serial com o esptool:
|
||||
// python -m esptool --port /dev/ttyUSB0 chip_id
|
||||
// Se retornar o MAC e o modelo do chip, a comunicação física está perfeita.`,
|
||||
codigoEspIdf: `// No ESP-IDF:
|
||||
// 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.",
|
||||
},
|
||||
{
|
||||
id: "tls-sntp-clock-fail",
|
||||
titulo: "Falha de Handshake TLS/HTTPS por Relógio Desincronizado",
|
||||
categoria: "conectividade",
|
||||
sintomas: ["tls-fail", "random-freeze"],
|
||||
gravidade: "Alta",
|
||||
logSerial: "E (15420) esp-tls-mbedtls: mbedtls_ssl_handshake returned -0x2700\nE (15420) esp-tls: Failed to verify peer certificate!\nE (15421) esp-tls: Verification info: The certificate is not yet valid (or has expired)",
|
||||
resumo: "Conexões seguras HTTPS, AWS IoT, MQTT com TLS ou APIs Web falham porque o relógio interno do ESP32 está na data padrão de 01/01/1970.",
|
||||
causaRaiz:
|
||||
"Certificados de segurança digitais (X.509 SSL/TLS) possuem um período estrito de validade (Not Before e Not After). Como o ESP32 não possui uma bateria de RTC externa por padrão, ao ligar seu relógio interno sempre inicia na época Unix zero (1970). Quando o cliente MbedTLS valida a data do certificado do servidor, considera que o certificado 'ainda não é válido' (pois 2026 é no futuro em relação a 1970) e aborta a conexão criptografada imediatamente com o erro -0x2700 (MBEDTLS_ERR_X509_CERT_VERIFY_FAILED).",
|
||||
gambiarra: {
|
||||
titulo: "Desativar a validação de certificados SSL (Insecure / No-Verify)",
|
||||
descricao: "Usar client.setInsecure() no Arduino ou desabilitar checagem de CA no ESP-IDF.",
|
||||
consequencia: "Abre brecha gravíssima de segurança: seu dispositivo fica vulnerável a ataques de Man-in-the-Middle (MitM), permitindo que invasores interceptem senhas e firmwares.",
|
||||
},
|
||||
solucaoEngenharia: {
|
||||
titulo: "Sincronização obrigatória de data e hora via SNTP antes de conexões TLS",
|
||||
passos: [
|
||||
"Logo após obter IP no Wi-Fi, inicie o cliente SNTP apontando para servidores confiáveis (ex: pool.ntp.br, time.google.com).",
|
||||
"Aguarde o status do relógio atingir o estado sincronizado antes de iniciar a primeira conexão HTTPS/MQTT.",
|
||||
"Configure o fuso horário (Timezone) correto para formatar logs com horários precisos.",
|
||||
],
|
||||
},
|
||||
codigoArduino: `// SINCRONIZAÇÃO SNTP ANTES DO HTTPS NO ARDUINO:
|
||||
#include <WiFi.h>
|
||||
#include <time.h>
|
||||
|
||||
void sincronizarRelogio() {
|
||||
// Configura servidores NTP (NTP Brasil e Google)
|
||||
configTime(-3 * 3600, 0, "a.st1.ntp.br", "time.google.com");
|
||||
|
||||
Serial.print("Aguardando sincronizacao de horario");
|
||||
time_t now = time(nullptr);
|
||||
// Ano 2020 em Unix time é 1577836800. Se for menor, ainda está em 1970:
|
||||
while (now < 1577836800) {
|
||||
delay(500);
|
||||
Serial.print(".");
|
||||
now = time(nullptr);
|
||||
}
|
||||
Serial.println("\\n[OK] Horario sincronizado! Conexoes TLS liberadas.");
|
||||
}`,
|
||||
codigoEspIdf: `// SNTP no ESP-IDF:
|
||||
#include "esp_sntp.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
void inicializar_sntp(void) {
|
||||
ESP_LOGI("SNTP", "Iniciando cliente SNTP...");
|
||||
esp_sntp_setoperatingmode(SNTP_OPMODE_POLL);
|
||||
esp_sntp_setservername(0, "pool.ntp.br");
|
||||
esp_sntp_init();
|
||||
|
||||
// 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.",
|
||||
},
|
||||
];
|
||||
|
||||
export const regrasDecodificadorLog = [
|
||||
{
|
||||
padrao: /Brownout detector was triggered/i,
|
||||
titulo: "Brownout Detector (Subtensão Crítica)",
|
||||
tipo: "Alimentação / Hardware",
|
||||
explicacao:
|
||||
"A tensão no pino 3V3 do ESP32 caiu abaixo do nível seguro (geralmente por pico de corrente do rádio Wi-Fi/BLE ou fonte subdimensionada).",
|
||||
acaoRecomendada:
|
||||
"Adicione capacitor de 10µF a 100µF Low-ESR no VCC, use fonte estável e verifique o regulador LDO.",
|
||||
},
|
||||
{
|
||||
padrao: /LoadProhibited|StoreProhibited/i,
|
||||
titulo: "Guru Meditation: Load/StoreProhibited (Ponteiro Nulo ou Inválido)",
|
||||
tipo: "CPU Panic / Exceção",
|
||||
explicacao:
|
||||
"Tentativa de ler ou gravar em um endereço inválido na memória (quase sempre desreferência de ponteiro NULL ou array fora de limite).",
|
||||
acaoRecomendada:
|
||||
"Decodifique o Backtrace com o Exception Decoder ou 'addr2line' para identificar a linha exata. Adicione checagens defensivas `if (ptr != NULL)`.",
|
||||
},
|
||||
{
|
||||
padrao: /Cache disabled but cached memory region accessed|InstructionFetchError/i,
|
||||
titulo: "Cache Error em Interrupção (ISR fora da IRAM)",
|
||||
tipo: "CPU Panic / Flash",
|
||||
explicacao:
|
||||
"Uma rotina de interrupção (ISR) tentou rodar a partir da memória Flash enquanto ela estava ocupada gravando dados (NVS, LittleFS ou OTA).",
|
||||
acaoRecomendada:
|
||||
"Adicione o atributo `IRAM_ATTR` na função de interrupção e garanta que ela não acesse variáveis na Flash sem DRAM_ATTR.",
|
||||
},
|
||||
{
|
||||
padrao: /Task watchdog got triggered/i,
|
||||
titulo: "Task Watchdog Timer (TWDT) Timeout",
|
||||
tipo: "FreeRTOS / Multitarefa",
|
||||
explicacao:
|
||||
"Uma tarefa de prioridade alta monopolizou a CPU sem ceder tempo (sem vTaskDelay ou bloqueio), impedindo o watchdog da tarefa IDLE.",
|
||||
acaoRecomendada:
|
||||
"Adicione `vTaskDelay(pdMS_TO_TICKS(10))` em loops longos ou use filas/semáforos em vez de loops `while(1)` contínuos.",
|
||||
},
|
||||
{
|
||||
padrao: /Stack canary watchpoint triggered/i,
|
||||
titulo: "Stack Overflow (Estouro de Pilha da Tarefa)",
|
||||
tipo: "FreeRTOS / Memória",
|
||||
explicacao:
|
||||
"A tarefa excedeu a quantidade de memória de pilha (Stack) alocada na sua criação, corrompendo o canário de proteção.",
|
||||
acaoRecomendada:
|
||||
"Aumente o tamanho da pilha no `xTaskCreate` (ex: de 2048 para 4096 bytes) e mova arrays grandes para o Heap ou variáveis estáticas.",
|
||||
},
|
||||
{
|
||||
padrao: /Timed out waiting for packet header|Failed to connect to ESP32/i,
|
||||
titulo: "Falha de Conexão UART / Upload",
|
||||
tipo: "Bootloader / Conexão",
|
||||
explicacao:
|
||||
"O computador não conseguiu colocar o ESP32 em modo de gravação via DTR/RTS ou o cabo USB não possui linhas de dados.",
|
||||
acaoRecomendada:
|
||||
"Coloque um capacitor de 10µF entre o pino EN e o GND, troque o cabo USB por um com fios de dados e teste segurar o botão BOOT durante a conexão.",
|
||||
},
|
||||
{
|
||||
padrao: /The certificate is not yet valid|-0x2700/i,
|
||||
titulo: "Falha de Certificado SSL/TLS (Relógio em 1970)",
|
||||
tipo: "Conectividade / TLS",
|
||||
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` 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,
|
||||
titulo: "Reset por Power-On / Strapping Pins",
|
||||
tipo: "Hardware / Boot",
|
||||
explicacao:
|
||||
"O microcontrolador reiniciou e reportou o registrador de strapping pins. Se travar após isso, um pino de boot pode estar em nível lógico incorreto.",
|
||||
acaoRecomendada:
|
||||
"Verifique se GPIOs como 0, 2, 12, 15 (ESP32) ou 8, 9 (C3) estão conectados a resistores ou periféricos que forçam níveis inadequados no boot.",
|
||||
},
|
||||
];
|
||||
@@ -0,0 +1,408 @@
|
||||
/**
|
||||
* Base de dados estruturada e abrangente de termos técnicos do Glossário ESP32.
|
||||
* Abrange todas as séries de chips da Espressif (ESP32, S2, S3, S31, C2, C3, C5, C6, C61, H2, H4, P4)
|
||||
* e seus recursos de hardware, periféricos, rádio, segurança e software.
|
||||
*/
|
||||
|
||||
export const categoriasGlossario = [
|
||||
{
|
||||
id: "processamento",
|
||||
nome: "Processamento, CPU & Silício",
|
||||
icone: "Cpu",
|
||||
emoji: "🧠",
|
||||
cor: "blue",
|
||||
descricao: "Arquiteturas Xtensa e RISC-V, núcleos, coprocessadores ULP, aceleradores vetoriais de IA e unidades de ponto flutuante.",
|
||||
termos: [
|
||||
{
|
||||
termo: "Arquitetura Xtensa vs RISC-V",
|
||||
definicao: "Conjunto de instruções base do processador. O ESP32 clássico, S2 e S3 usam núcleos proprietários Tensilica Xtensa (LX6/LX7). As séries modernas C (C2, C3, C5, C6, C61), H (H2, H4) e P (P4) adotam a arquitetura aberta, modular e eficiente RISC-V (32-bit).",
|
||||
exemplo: "ESP32-S3 usa Xtensa LX7 dual-core, enquanto ESP32-C6 usa RISC-V single-core e ESP32-P4 usa RISC-V dual-core a 400 MHz.",
|
||||
},
|
||||
{
|
||||
termo: "Núcleos de CPU (Dual-Core vs Single-Core)",
|
||||
definicao: "Unidades centrais de processamento independentes. Chips dual-core permitem dedicar um núcleo (Core 0) exclusivamente ao rádio Wi-Fi/Bluetooth e escalonamento do FreeRTOS, deixando o segundo núcleo (Core 1) 100% livre para a aplicação e cálculos do usuário.",
|
||||
exemplo: "ESP32, ESP32-S3 e ESP32-P4 são dual-core; ESP32-S2, C2, C3, C6 e H2 são single-core.",
|
||||
},
|
||||
{
|
||||
termo: "Frequência de Clock (MHz)",
|
||||
definicao: "Velocidade de processamento medida em Megahertz (MHz). O ESP-IDF ajusta dinamicamente a frequência (Dynamic Frequency Scaling - DFS) para economizar energia em momentos ociosos.",
|
||||
exemplo: "O ESP32-C2 opera a até 120 MHz; ESP32, S2, S3 e C6 chegam a 160/240 MHz; e o ESP32-P4 atinge 400 MHz.",
|
||||
},
|
||||
{
|
||||
termo: "ULP (Ultra Low Power Coprocessor)",
|
||||
definicao: "Processador secundário independente de consumo ultra baixo que continua rodando instruções, lendo sensores analógicos (ADC), I2C e pinos GPIO enquanto os núcleos principais permanecem desligados em Deep Sleep.",
|
||||
exemplo: "O ESP32 original tem ULP FSM; ESP32-S2, S3 e C6 possuem ULP RISC-V programável em C; ESP32-P4 possui ULP de baixa potência dedicado.",
|
||||
},
|
||||
{
|
||||
termo: "Extensões Vetoriais de IA (Vector Extension / ESP-NN)",
|
||||
definicao: "Instruções especializadas de silício que executam operações matemáticas vetoriais e matriciais com inteiros (int8/int16) em paralelo, acelerando redes neurais convolucionais (CNNs) e processamento de sinal.",
|
||||
exemplo: "ESP32-S3 e ESP32-P4 aceleram inferências de reconhecimento facial, detecção de voz e modelos TensorFlow Lite for Microcontrollers.",
|
||||
},
|
||||
{
|
||||
termo: "FPU (Floating Point Unit)",
|
||||
definicao: "Unidade de processamento de ponto flutuante por hardware que realiza somas, multiplicações e divisões com números decimais (`float`) em um único ciclo de clock, sem sobrecarga de software.",
|
||||
exemplo: "Presente nos núcleos Xtensa do ESP32 e ESP32-S3, e nos núcleos RISC-V de alto desempenho do ESP32-P4.",
|
||||
},
|
||||
{
|
||||
termo: "PPA (Pixel Processing Accelerator)",
|
||||
definicao: "Acelerador gráfico 2D por hardware exclusivo do ESP32-P4 para manipulação acelerada de imagens: rotação de frames, redimensionamento (scaling), mistura de canais alfa (alpha blending) e conversão de cores (RGB565, ARGB8888, YUV420).",
|
||||
exemplo: "Renderização de interfaces gráficas complexas (LVGL) a 60 FPS sem ocupar tempo dos núcleos de CPU principais.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "seguranca",
|
||||
nome: "Segurança, Criptografia & eFuses",
|
||||
icone: "ShieldCheck",
|
||||
emoji: "🔒",
|
||||
cor: "red",
|
||||
descricao: "eFuses invioláveis, Secure Boot V2, Criptografia de Flash XTS-AES, Key Manager, ECC e proteção contra DPA.",
|
||||
termos: [
|
||||
{
|
||||
termo: "eFuse (Electronic Fuses)",
|
||||
definicao: "Conjunto de fusíveis microscópicos de silício de gravação única e irreversível (One-Time Programmable - OTP). Armazenam chaves secretas de criptografia, o endereço MAC de fábrica e bloqueiam interfaces de debug em produtos comerciais.",
|
||||
exemplo: "Usado com a ferramenta `espefuse.py` para gravar chaves de Secure Boot e desativar portas JTAG antes do envio ao consumidor.",
|
||||
},
|
||||
{
|
||||
termo: "Secure Boot (V1 e V2)",
|
||||
definicao: "Protocolo de inicialização segura em que o código da ROM verifica criptograficamente a assinatura RSA-3072 ou ECDSA do bootloader e firmware antes de permitir sua execução, impedindo injeção de código adulterado.",
|
||||
exemplo: "ESP32 clássico usa Secure Boot V1; do ESP32-S2 em diante todos adotam o Secure Boot V2 com múltiplas chaves de assinatura.",
|
||||
},
|
||||
{
|
||||
termo: "Criptografia de Flash (Flash Encryption)",
|
||||
definicao: "Mecanismo de hardware que cifra e decifra em tempo real o conteúdo da memória Flash SPI externa usando o algoritmo XTS-AES. Impede a leitura física do firmware caso a placa seja roubada ou a memória dessoldada.",
|
||||
exemplo: "XTS-AES-128 na maioria dos chips; ESP32-S3, C5, P4 e H4 também suportam XTS-AES-256.",
|
||||
},
|
||||
{
|
||||
termo: "Key Manager",
|
||||
definicao: "Módulo de segurança avançado que provisiona, armazena e opera chaves criptográficas em silício sem nunca expô-las à memória SRAM ou ao firmware, impedindo extração de chaves mesmo sob vulnerabilidades de software.",
|
||||
exemplo: "Presente nas séries de alta segurança como ESP32-S31, ESP32-C5 e ESP32-P4.",
|
||||
},
|
||||
{
|
||||
termo: "ECC & ECDSA em Hardware",
|
||||
definicao: "Aceleradores de curvas elípticas (como P-256 e P-384) e algoritmos de assinatura digital ECDSA em silício, fundamentais para conexão rápida e segura com a nuvem e requisitos de atestação do padrão Matter.",
|
||||
exemplo: "ESP32-S31, C5, C61, P4, H2 e H4 possuem acelerador de hardware para ECDSA.",
|
||||
},
|
||||
{
|
||||
termo: "HMAC & Assinatura Digital (DS)",
|
||||
definicao: "Periféricos de autenticação criptográfica que calculam códigos HMAC e assinam mensagens com chaves secretas gravadas em eFuses de forma invisível para o firmware.",
|
||||
exemplo: "Permite autenticação segura e rápida com AWS IoT Core e Microsoft Azure IoT sem armazenar certificados em texto plano.",
|
||||
},
|
||||
{
|
||||
termo: "TRNG (True Random Number Generator)",
|
||||
definicao: "Gerador de números aleatórios verdadeiros baseado no ruído térmico analógico dos circuitos de rádio e silício, essencial para geração de chaves de sessão em handshakes TLS/HTTPS.",
|
||||
exemplo: "Disponível em todas as séries do ESP32 para garantir entropia segura em conexões HTTPS/MbedTLS.",
|
||||
},
|
||||
{
|
||||
termo: "Proteção contra DPA (Differential Power Analysis)",
|
||||
definicao: "Mecanismo físico de hardware que adiciona ruído e balanceamento no consumo de corrente elétrica do chip para impedir que invasores descubram chaves criptográficas medindo o consumo com osciloscópios.",
|
||||
exemplo: "Presente nas séries ESP32-C5, C6, C61 e H2.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "memoria",
|
||||
nome: "Memória, Barramentos & Armazenamento",
|
||||
icone: "Database",
|
||||
emoji: "💾",
|
||||
cor: "purple",
|
||||
descricao: "SRAM interna, ROM de boot, memórias Flash SPI, PSRAM QSPI/Octal, RTC Memory e alocações de DMA.",
|
||||
termos: [
|
||||
{
|
||||
termo: "SRAM Interna",
|
||||
definicao: "Memória volátil ultrarrápida integrada diretamente no silício da CPU. Utilizada para variáveis do programa, estruturas do FreeRTOS, buffers de drivers e pilha de execução. Perde os dados ao desligar a alimentação.",
|
||||
exemplo: "O ESP32 clássico possui 520 KB de SRAM; ESP32-S3 tem 512 KB; ESP32-C3 tem 400 KB; ESP32-C6 tem 512 KB; ESP32-P4 tem 768 KB.",
|
||||
},
|
||||
{
|
||||
termo: "ROM de Boot",
|
||||
definicao: "Memória somente-leitura gravada permanentemente na fábrica da Espressif contendo o First-Stage Bootloader, tabelas matemáticas e rotinas básicas de inicialização que nunca podem ser alteradas.",
|
||||
exemplo: "Ao ligar, a ROM executa primeiro, verifica os Strapping Pins e carrega o bootloader do usuário da Flash.",
|
||||
},
|
||||
{
|
||||
termo: "Flash SPI (Quad-SPI vs Octal-SPI)",
|
||||
definicao: "Memória não-volátil externa onde reside o firmware da aplicação. Conectada via 4 vias (Quad SPI / QSPI) ou 8 vias de dados (Octal SPI / OPI / OSPI) com o dobro de largura de banda e taxas de transferência.",
|
||||
exemplo: "ESP32-S3 e ESP32-P4 suportam memórias Flash e PSRAM em modo Octal SPI de até 120 MHz para máxima velocidade de carregamento de texturas e código.",
|
||||
},
|
||||
{
|
||||
termo: "PSRAM (Pseudo-Static RAM Externa)",
|
||||
definicao: "Memória RAM externa de alta densidade conectada via SPI/QSPI/OPI que estende a memória do microcontrolador em até dezenas de Megabytes para aplicações que demandam buffers gigantescos.",
|
||||
exemplo: "ESP32-WROVER e ESP32-S3-WROOM-1 com 8 MB de PSRAM externa para decodificação JPEG de câmeras e buffers gráficos de displays TFT.",
|
||||
},
|
||||
{
|
||||
termo: "RTC Fast & Slow SRAM",
|
||||
definicao: "Blocos de memória SRAM dedicados ao domínio de energia do Real-Time Clock (RTC). Permanecem alimentados durante o modo Deep Sleep para armazenar código do ULP e variáveis marcadas com `RTC_DATA_ATTR`.",
|
||||
exemplo: "Manter contadores de leituras ou dados de calibração intactos enquanto o ESP32 dorme em Deep Sleep consumindo 10 µA.",
|
||||
},
|
||||
{
|
||||
termo: "Alocação DMA (MALLOC_CAP_DMA)",
|
||||
definicao: "Memória compatível com Direct Memory Access (DMA), permitindo que periféricos (SPI, I2S, LCD, SDMMC) transfiram dados diretamente para a RAM sem consumir tempo da CPU.",
|
||||
exemplo: "Na maioria dos chips ESP32, o DMA exige alocação exclusiva na SRAM interna através da flag `MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL`.",
|
||||
},
|
||||
{
|
||||
termo: "Fragmentação de Heap",
|
||||
definicao: "Fenômeno em que a memória dinâmica fica dividida em blocos pequenos dispersos após múltiplas alocações e desalocações (muito comum ao usar objetos `String` do Arduino), impedindo alocações contíguas grandes para TLS/Wi-Fi.",
|
||||
exemplo: "Monitorado no ESP-IDF através de `heap_caps_get_largest_free_block()` para prevenir falhas de conexão HTTPS.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "conectividade",
|
||||
nome: "Conectividade Sem Fio & Protocolos",
|
||||
icone: "Wifi",
|
||||
emoji: "📡",
|
||||
cor: "emerald",
|
||||
descricao: "Wi-Fi 4/6, Dual-Band 5 GHz, OFDMA, TWT, Bluetooth Classic, BLE 5.x, LE Audio, Zigbee 3.0, Thread e Matter.",
|
||||
termos: [
|
||||
{
|
||||
termo: "Wi-Fi 6 (802.11ax)",
|
||||
definicao: "Padrão moderno de rede sem fio que traz suporte a OFDMA (comunicação paralela com menor latência), modulação 1024-QAM e o recurso TWT (Target Wake Time) para economizar drasticamente a bateria de sensores IoT.",
|
||||
exemplo: "Presente no ESP32-C6, ESP32-C61 e ESP32-C5.",
|
||||
},
|
||||
{
|
||||
termo: "Wi-Fi Dual-Band (2.4 GHz e 5 GHz)",
|
||||
definicao: "Capacidade de operar tanto na faixa tradicional de 2.4 GHz quanto na faixa de 5 GHz com menor congestionamento eletromagnético, canais de 20 MHz / 40 MHz e maior estabilidade de conexão.",
|
||||
exemplo: "O ESP32-C5 é o primeiro chip da Espressif com rádio Wi-Fi 6 Dual-Band integrado.",
|
||||
},
|
||||
{
|
||||
termo: "OFDMA (Orthogonal Frequency Division Multiple Access)",
|
||||
definicao: "Tecnologia do Wi-Fi 6 que divide um único canal de rádio em dezenas de subportadoras menores (Resource Units), permitindo que o roteador atenda múltiplos dispositivos ESP32 simultaneamente sem colisões.",
|
||||
exemplo: "Reduz a latência de resposta em ambientes residenciais ou industriais densos com dezenas de nós conectados.",
|
||||
},
|
||||
{
|
||||
termo: "TWT (Target Wake Time)",
|
||||
definicao: "Protocolo do Wi-Fi 6 onde o ESP32 e o roteador combinam horários exatos para troca de pacotes, permitindo que o microcontrolador mantenha seu rádio totalmente desligado por longos períodos sem se desconectar da rede.",
|
||||
exemplo: "Sensores alimentados por bateria com ESP32-C6 operando por anos conectados ao Wi-Fi 6 sem perder sincronismo.",
|
||||
},
|
||||
{
|
||||
termo: "Bluetooth Classic (BR/EDR)",
|
||||
definicao: "Protocolo Bluetooth tradicional para transmissão contínua de áudio estéreo (A2DP), portas seriais virtuais (SPP) e dispositivos que exigem alta taxa de transferência sustentada.",
|
||||
exemplo: "Implementação de caixas de som Bluetooth, receptores de áudio e teclados HID no ESP32 clássico.",
|
||||
},
|
||||
{
|
||||
termo: "Bluetooth Low Energy (BLE 5.0 a 5.4)",
|
||||
definicao: "Versão de baixo consumo elétrico do Bluetooth com suporte a taxas de 2 Mbps (2M PHY), longo alcance de centenas de metros (Coded PHY / Long Range), extensões de publicidade e redes mesh Bluetooth.",
|
||||
exemplo: "ESP32-S3 suporta BLE 5.0; ESP32-C6 e ESP32-H2 suportam Bluetooth 5.4 LE.",
|
||||
},
|
||||
{
|
||||
termo: "Bluetooth LE Audio & Auracast",
|
||||
definicao: "Nova geração de áudio Bluetooth de alta fidelidade e baixíssimo consumo com o codec LC3 e suporte a transmissões de áudio para múltiplos ouvintes simultâneos (Broadcast Audio / Auracast).",
|
||||
exemplo: "Disponível na série ESP32-H4 para novos ecossistemas de áudio e fones inteligentes.",
|
||||
},
|
||||
{
|
||||
termo: "IEEE 802.15.4 (Zigbee 3.0 & Thread)",
|
||||
definicao: "Padrão de rádio em 2.4 GHz de baixo consumo e baixa taxa de dados que forma a base física das redes em malha (Mesh) industriais e residenciais Zigbee 3.0 e Thread 1.3.",
|
||||
exemplo: "ESP32-C6, ESP32-H2 e ESP32-H4 possuem transceptor IEEE 802.15.4 integrado no silício.",
|
||||
},
|
||||
{
|
||||
termo: "Matter Protocol",
|
||||
definicao: "Padrão universal e aberto de conectividade para automação residencial mantido pela CSA, funcionando sobre redes Wi-Fi, Ethernet e Thread, compatível nativamente com Apple Home, Google Home, Alexa e Home Assistant.",
|
||||
exemplo: "Lâmpadas e tomadas inteligentes desenvolvidas com ESP-Matter no ESP32-C6 ou ESP32-H2 sem depender de nuvens proprietárias.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "perifericos",
|
||||
nome: "Entradas, Saídas & Periféricos",
|
||||
icone: "Sliders",
|
||||
emoji: "🔌",
|
||||
cor: "amber",
|
||||
descricao: "Pinos GPIO, strapping pins, conversores ADC/DAC, PWM/LEDC, MCPWM, RMT, PCNT, TWAI®/CAN, I2C, SPI e I2S.",
|
||||
termos: [
|
||||
{
|
||||
termo: "GPIO (General Purpose Input/Output)",
|
||||
definicao: "Pinos multifuncionais configuráveis como entradas ou saídas digitais, com resistores de pull-up/pull-down internos selecionáveis e suporte a interrupções externas em qualquer pino.",
|
||||
exemplo: "Leitura de botões, chaveamento de relés e controle de LEDs com `gpio_set_level()` ou `digitalWrite()`.",
|
||||
},
|
||||
{
|
||||
termo: "Strapping Pins",
|
||||
definicao: "Pinos GPIO específicos amostrados por hardware no milissegundo em que o chip sai do reset para determinar o modo de boot (Download UART vs SPI Flash) e níveis de tensão.",
|
||||
exemplo: "GPIO 0 no ESP32 clássico/S3 ou GPIO 9 no ESP32-C3: se puxados para LOW durante o reset, colocam o chip em modo de gravação de firmware.",
|
||||
},
|
||||
{
|
||||
termo: "ADC (Analog-to-Digital Converter)",
|
||||
definicao: "Conversor que transforma níveis contínuos de tensão analógica (0 a 3.3V) em valores numéricos digitais de 12 bits (o ESP32-S2 entrega 13 bits, com 12 efetivos) através de atenuadores configuráveis (0dB, 2.5dB, 6dB, 11dB/12dB).",
|
||||
exemplo: "Leitura de sensores LDR, potenciômetros, termistores e medição do nível de carga de baterias de lítio.",
|
||||
},
|
||||
{
|
||||
termo: "DAC (Digital-to-Analog Converter)",
|
||||
definicao: "Conversor que gera tensões analógicas contínuas proporcionais a valores digitais gerados por software sem necessidade de circuitos externos.",
|
||||
exemplo: "Disponível no ESP32 clássico e ESP32-S2 para sintetizar áudio analógico ou sinais de controle direto.",
|
||||
},
|
||||
{
|
||||
termo: "LEDC (LED PWM Controller)",
|
||||
definicao: "Periférico dedicado a gerar múltiplos canais de modulação por largura de pulso (PWM) com controle de frequência, resolução de até 14-20 bits e transições graduais (fade por hardware) sem ocupar a CPU.",
|
||||
exemplo: "Controle suave de brilho de fitas de LED RGBW e posicionamento de servomotores.",
|
||||
},
|
||||
{
|
||||
termo: "MCPWM (Motor Control PWM)",
|
||||
definicao: "Controlador PWM avançado projetado para acionamento de motores elétricos, inversores de frequência trifásicos, pontes H com tempo morto (dead-time) configurável e captura de encoders em quadratura.",
|
||||
exemplo: "Controle preciso de motores sem escovas (BLDC) e robôs móveis no ESP32 clássico, S3 e P4.",
|
||||
},
|
||||
{
|
||||
termo: "RMT (Remote Control Peripheral)",
|
||||
definicao: "Transceptor e gerador de pulsos de temporização precisa em microssegundos projetado originalmente para controles remotos infravermelhos (NEC, RC5, Sony) e amplamente usado para controlar fitas de LED digitais WS2812B / NeoPixel.",
|
||||
exemplo: "Atualização de centenas de LEDs NeoPixel sem desativar interrupções do sistema.",
|
||||
},
|
||||
{
|
||||
termo: "PCNT (Pulse Counter)",
|
||||
definicao: "Contador de pulsos de hardware que mede a contagem de bordas de subida/descida de sinais externos em alta frequência sem gerar interrupções por software para a CPU.",
|
||||
exemplo: "Leitura de encoders rotativos industriais, tacômetros de velocidade e medidores de vazão de água.",
|
||||
},
|
||||
{
|
||||
termo: "TWAI® (Two-Wire Automotive Interface / CAN Bus)",
|
||||
definicao: "Controlador de barramento veicular e industrial CAN 2.0B compatível com a norma ISO 11898-1 integrado no silício, necessitando apenas de um transceptor físico externo (como SN65HVD230).",
|
||||
exemplo: "Diagnóstico automotivo OBD-II, telemetria de veículos elétricos e automação industrial robusta.",
|
||||
},
|
||||
{
|
||||
termo: "Touch Capacitivo",
|
||||
definicao: "Pinos especializados que medem a variação da capacitância eletrostática quando um dedo se aproxima, permitindo criar botões e sliders sensíveis ao toque através de vidro ou acrílico.",
|
||||
exemplo: "Painéis de comando touch modernos com até 14 canais no ESP32-S2 e S3.",
|
||||
},
|
||||
{
|
||||
termo: "PARLIO (Parallel IO Controller)",
|
||||
definicao: "Barramento paralelo configurável de alta velocidade presente nas séries mais novas (C6, H2, P4) para transferir dados síncronos com clock customizado para displays LCD, câmeras e sensores externos.",
|
||||
exemplo: "Comunicação paralela eficiente com chips periféricos sem recorrer a bit-banging na CPU.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "multimidia",
|
||||
nome: "Multimídia, USB & Interfaces Avançadas",
|
||||
icone: "Sparkles",
|
||||
emoji: "✨",
|
||||
cor: "pink",
|
||||
descricao: "USB OTG nativo, USB Serial/JTAG, USB High-Speed 480Mbps, MIPI CSI/DSI, codificador H.264 e Ethernet MAC.",
|
||||
termos: [
|
||||
{
|
||||
termo: "USB OTG (On-The-Go) Nativo",
|
||||
definicao: "Controlador USB Full-Speed (12 Mbps) embutido no chip que permite ao ESP32 operar como dispositivo periférico (teclado HID, mouse, pendrive Mass Storage) ou como USB Host (lendo pen drives ou periféricos).",
|
||||
exemplo: "Nativamente disponível no ESP32-S2 e ESP32-S3 para criação de teclados customizados e emuladores.",
|
||||
},
|
||||
{
|
||||
termo: "USB Serial/JTAG Nativo",
|
||||
definicao: "Interface USB integrada no silício que fornece simultaneamente uma porta serial de comunicação para o console e uma sonda de depuração JTAG completa sem a necessidade de chips conversores externos (CH340/CP2102).",
|
||||
exemplo: "Permite gravar firmware e debugar com breakpoints no VS Code no ESP32-C3, S3, C6 e H2 apenas com o cabo USB conectado aos pinos D+/D-.",
|
||||
},
|
||||
{
|
||||
termo: "USB 2.0 High-Speed (480 Mbps)",
|
||||
definicao: "Controlador USB 2.0 de alta velocidade capaz de transferir até 480 Mbps com PHY integrado, proporcionando largura de banda 40x superior ao USB Full-Speed.",
|
||||
exemplo: "Exclusivo do ESP32-P4 para streaming de vídeo em alta definição e transferência em massa de dados.",
|
||||
},
|
||||
{
|
||||
termo: "MIPI CSI & MIPI DSI",
|
||||
definicao: "Interfaces seriais diferenciais de alta velocidade padrão da indústria de smartphones: MIPI-CSI (Camera Serial Interface) para sensores de câmera de alta resolução e MIPI-DSI (Display Serial Interface) para telas sensíveis ao toque.",
|
||||
exemplo: "Conexão de telas de 1080p e câmeras de alta taxa de quadros no SoC ESP32-P4.",
|
||||
},
|
||||
{
|
||||
termo: "Codificador de Vídeo H.264 por Hardware",
|
||||
definicao: "Bloco acelerador dedicado que comprime fluxos de vídeo brutos de câmeras no formato padrão H.264 (AVC) em tempo real em resoluções de até 1080p a 30 FPS sem sobrecarregar a CPU.",
|
||||
exemplo: "Câmeras de segurança inteligentes e porteiros eletrônicos com compressão eficiente no ESP32-P4.",
|
||||
},
|
||||
{
|
||||
termo: "Ethernet MAC 10/100 Mbps",
|
||||
definicao: "Controlador de camada de enlace de dados (Media Access Control) de rede cabeada integrado no silício, que exige apenas um chip transceptor físico externo (PHY como LAN8720 ou IP101) via interface RMII.",
|
||||
exemplo: "Conexão Ethernet RJ45 estável imune a ruídos de rádio para automação predial no ESP32 clássico e ESP32-P4.",
|
||||
},
|
||||
{
|
||||
termo: "Interface de Câmera DVP (8-bit / 16-bit)",
|
||||
definicao: "Barramento paralelo com sinais VSYNC, HREF, PCLK e barramento de dados com suporte a DMA para captura direta de frames de módulos de câmera populares (OV2640, OV5640).",
|
||||
exemplo: "Usado em placas ESP32-CAM e ESP32-S3-CAM para captura de fotos e streaming de vídeo MJPEG.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "energia",
|
||||
nome: "Gerenciamento de Energia & Sleep Modes",
|
||||
icone: "BatteryCharging",
|
||||
emoji: "🔋",
|
||||
cor: "teal",
|
||||
descricao: "Active Mode, Modem Sleep, Light Sleep, Deep Sleep, Hibernation, Brownout Detector e fontes de despertar.",
|
||||
termos: [
|
||||
{
|
||||
termo: "Active Mode",
|
||||
definicao: "Modo de operação normal onde a CPU executa instruções na frequência máxima e todos os periféricos e rádios estão prontos para uso, com consumo elétrico variando de 30 mA a ~240 mA (durante transmissões Wi-Fi).",
|
||||
exemplo: "ESP32 processando áudio, atualizando displays ou transmitindo dados de sensores em tempo real.",
|
||||
},
|
||||
{
|
||||
termo: "Modem Sleep",
|
||||
definicao: "Modo em que os circuitos de rádio Wi-Fi e Bluetooth são desligados temporariamente nos intervalos entre transmissões enquanto a CPU continua rodando seu código normalmente, reduzindo o consumo para ~20 a 40 mA.",
|
||||
exemplo: "Modo padrão em aplicações conectadas ao Wi-Fi que aguardam eventos de rede sem perder a associação ao roteador.",
|
||||
},
|
||||
{
|
||||
termo: "Light Sleep",
|
||||
definicao: "Modo de economia intermediário: a CPU tem seu clock pausado e os rádios são desligados, mas a memória SRAM interna, os periféricos e o estado das tarefas são preservados intactos. O chip acorda em menos de 1 ms.",
|
||||
exemplo: "Consumo de ~0.8 mA em dispositivos que precisam acordar rapidamente por interrupção de botão ou timer.",
|
||||
},
|
||||
{
|
||||
termo: "Deep Sleep",
|
||||
definicao: "Modo de sono profundo em que todos os domínios digitais e a CPU são desligados, mantendo alimentado apenas o domínio RTC (e opcionalmente a RTC Memory e o ULP). O consumo cai para 5 a 15 µA e o chip reinicia a execução ao acordar.",
|
||||
exemplo: "Estações meteorológicas remotas alimentadas por bateria e painel solar que realizam leituras a cada hora.",
|
||||
},
|
||||
{
|
||||
termo: "Hibernation Mode",
|
||||
definicao: "O estado de menor consumo elétrico do silício: desliga inclusive o oscilador de cristal do RTC e domínios lentos, mantendo apenas um circuito analógico de recuperação que acorda por botão externo ou reset.",
|
||||
exemplo: "Consumo residual de ~5 µA em dispositivos que operam por anos com bateria botão tipo moeda (CR2032).",
|
||||
},
|
||||
{
|
||||
termo: "Fontes de Despertar (Wakeup Sources)",
|
||||
definicao: "Eventos de hardware configurados para tirar o ESP32 do modo Deep Sleep ou Light Sleep: temporizadores RTC, pinos GPIO externos (EXT0 / EXT1), toque capacitivo ou sinal do coprocessador ULP.",
|
||||
exemplo: "`esp_sleep_enable_timer_wakeup(60 * 1000000)` para acordar exatamente a cada 60 segundos.",
|
||||
},
|
||||
{
|
||||
termo: "Brownout Detector",
|
||||
definicao: "Circuito comparador analógico interno de hardware que monitora a tensão de alimentação no pino 3V3 e força um reset de emergência seguro caso a tensão caia abaixo de ~2.8V para prevenir corrupção da memória Flash.",
|
||||
exemplo: "Protege o microcontrolador contra resets parciais causados por fontes fracas durante picos de transmissão de rádio.",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: "desenvolvimento",
|
||||
nome: "Firmware, Boot & Sistema Operacional",
|
||||
icone: "Code2",
|
||||
emoji: "🚀",
|
||||
cor: "rose",
|
||||
descricao: "Bootloader, FreeRTOS, macros IRAM_ATTR, partições da Flash, atualização OTA com Rollback e armazenamento NVS.",
|
||||
termos: [
|
||||
{
|
||||
termo: "Bootloader (First & Second Stage)",
|
||||
definicao: "Código que executa logo após o reset elétrico. O primeiro estágio reside na ROM do chip; o segundo estágio reside na Flash, valida a tabela de partições, checa as assinaturas de segurança e carrega o firmware do usuário.",
|
||||
exemplo: "Controla a alternância entre partições OTA e inicializa a memória PSRAM antes do `app_main`.",
|
||||
},
|
||||
{
|
||||
termo: "FreeRTOS (Sistema Operacional de Tempo Real)",
|
||||
definicao: "Kernel multitarefa preemptivo padrão do ESP-IDF que divide a CPU entre múltiplas tarefas (Tasks), filas de mensagens (Queues), semáforos, mutexes e timers de software com controle de prioridades.",
|
||||
exemplo: "`xTaskCreatePinnedToCore()` para alocar tarefas pesadas em núcleos específicos da CPU.",
|
||||
},
|
||||
{
|
||||
termo: "IRAM_ATTR & DRAM_ATTR",
|
||||
definicao: "Atributos especiais do compilador GCC para o ESP32 que forçam funções e variáveis a residirem na memória interna ultrarrápida IRAM/DRAM em vez da Flash externa, obrigatório para rotinas de interrupção (ISRs).",
|
||||
exemplo: "Evita que uma interrupção cause travamento (*Cache Error*) enquanto a Flash estiver ocupada gravando dados.",
|
||||
},
|
||||
{
|
||||
termo: "Tabela de Partições (partitions.csv)",
|
||||
definicao: "Arquivo de configuração que mapeia o espaço de armazenamento da memória Flash em blocos lógicos dedicados ao bootloader, dados NVS, arquivos LittleFS e múltiplas imagens de firmware (Factory, OTA_0, OTA_1).",
|
||||
exemplo: "Personalizado para acomodar firmwares grandes com bibliotecas de Bluetooth, Wi-Fi e criptografia.",
|
||||
},
|
||||
{
|
||||
termo: "OTA (Over-The-Air Update) com Rollback",
|
||||
definicao: "Atualização sem fio de firmware onde a nova versão é gravada em uma partição secundária. Se o novo firmware falhar ao inicializar, o sistema reverte automaticamente (*Rollback*) para a versão funcional anterior.",
|
||||
exemplo: "`esp_ota_mark_app_valid_cancel_rollback()` confirma que a nova atualização está saudável em campo.",
|
||||
},
|
||||
{
|
||||
termo: "NVS (Non-Volatile Storage) & NVS Encryption",
|
||||
definicao: "Mecanismo estruturado de chave-valor na memória Flash para persistir credenciais de rede, parâmetros de calibração e contadores, com suporte a criptografia em hardware via chave AES nos eFuses.",
|
||||
exemplo: "Salvar nome de rede Wi-Fi e senhas criptografadas para reconexão automática após desligamento.",
|
||||
},
|
||||
{
|
||||
termo: "LittleFS & SPIFFS",
|
||||
definicao: "Sistemas de arquivos desenvolvidos para memórias Flash com nivelamento de desgaste (*wear leveling*), permitindo que a aplicação leia e grave arquivos como páginas HTML, certificados SSL e logs.",
|
||||
exemplo: "Armazenar páginas HTML/CSS do servidor web embutido do ESP32 para configuração de rede via navegador.",
|
||||
},
|
||||
{
|
||||
termo: "JTAG & OpenOCD",
|
||||
definicao: "Padrão de depuração em nível de hardware que permite pausar a CPU, colocar breakpoints e inspecionar registradores e variáveis em tempo real no VS Code ou Eclipse via sondas USB-JTAG.",
|
||||
exemplo: "Depuração de crashes complexos e ponteiros nulos sem depender apenas de comandos `Serial.println()`.",
|
||||
},
|
||||
],
|
||||
},
|
||||
];
|
||||
@@ -0,0 +1,184 @@
|
||||
/**
|
||||
* Conhecimento de domínio da busca inteligente.
|
||||
*
|
||||
* Sem dependências nem alias de import: roda no servidor (montando o índice),
|
||||
* no navegador (interpretando a consulta) e em scripts de teste no Node.
|
||||
*
|
||||
* Todos os textos de `termos` já estão normalizados (minúsculos, sem acento).
|
||||
*/
|
||||
|
||||
export const normalizar = (s = "") =>
|
||||
String(s)
|
||||
.toLowerCase()
|
||||
.normalize("NFD")
|
||||
.replace(/[\u0300-\u036f]/g, "");
|
||||
|
||||
/**
|
||||
* Reconhece pinos ocupados por flash/PSRAM com base no que o diagrama diz.
|
||||
* "forte": o pino é consumido pela memória (ou é a alimentação dela).
|
||||
* "fraco": só é afetado em certos modos (ex.: SPI de 8 linhas/octal).
|
||||
* Avisos genéricos de tensão mínima ("para chips com flash integrada...") não contam.
|
||||
*/
|
||||
const nivelMemoria = (palavra) => (p) => {
|
||||
const citam = p._avs.filter((a) => a.includes(palavra) && !/^para chips (com|sem)/.test(a));
|
||||
if (citam.some((a) => /(utilizad|dedicad|conectad)/.test(a) && !/a menos que/.test(a))) return "forte";
|
||||
if (p._fn.some((f) => /alimentacao/.test(f) && f.includes(palavra))) return "forte";
|
||||
if (citam.length) return "fraco";
|
||||
return null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Assuntos que o usuário pode citar. Cada um sabe:
|
||||
* - termos: como as pessoas escrevem (sinônimos, siglas, plurais comuns);
|
||||
* - pinoCats / pinoRe: como reconhecer os pinos relacionados no diagrama;
|
||||
* - pinoRotulo: frase usada no título do resultado de pinos.
|
||||
* Os dados de especificação ligam-se aos assuntos por SPEC_CAMPOS.
|
||||
*/
|
||||
export const TOPICOS = [
|
||||
{ id: "flash", nome: "Flash", termos: ["flash", "memoria flash", "spi flash", "armazenamento", "firmware", "rom externa"], pinoNivel: nivelMemoria("flash"), pinoRotulo: "ligados à memória flash" },
|
||||
{ id: "psram", nome: "PSRAM", termos: ["psram", "ram externa", "spiram"], pinoNivel: nivelMemoria("psram"), pinoRotulo: "ligados à PSRAM" },
|
||||
{ id: "memoria", nome: "Memória", termos: ["memoria", "sram", "heap", "rtc ram", "kb de ram", "memoria interna", "ram"], pinoRotulo: "" },
|
||||
{ id: "wifi", nome: "Wi-Fi", termos: ["wifi", "wi-fi", "wireless", "sem fio", "802.11", "wifi6", "wifi 6", "wi-fi 6"], pinoCats: ["Antena"], pinoRotulo: "de antena e rádio" },
|
||||
{ id: "bluetooth", nome: "Bluetooth", termos: ["bluetooth", "ble", "bt", "bluetooth le", "mesh"], pinoCats: ["Antena"], pinoRotulo: "de antena e rádio" },
|
||||
{ id: "zigbee", nome: "Zigbee/Thread", termos: ["zigbee", "thread", "802.15.4", "ieee 802.15.4"], pinoRotulo: "" },
|
||||
{ id: "matter", nome: "Matter", termos: ["matter", "casa inteligente", "smart home"], pinoRotulo: "" },
|
||||
{ id: "ethernet", nome: "Ethernet", termos: ["ethernet", "rmii", "cabo de rede", "lan"], pinoCats: ["Ethernet"], pinoRotulo: "de Ethernet" },
|
||||
{ id: "can", nome: "CAN / TWAI", termos: ["can", "twai", "can bus", "canbus", "can fd"], pinoRe: /twai|\bcan\b/, pinoRotulo: "de CAN/TWAI" },
|
||||
{ id: "usb", nome: "USB", termos: ["usb", "otg", "usb serial", "usb otg", "hid", "cdc"], pinoCats: ["USB"], pinoRotulo: "de USB" },
|
||||
{ id: "jtag", nome: "JTAG / Depuração", termos: ["jtag", "debug", "depuracao", "depurar", "openocd", "gdb"], pinoCats: ["JTAG"], pinoRotulo: "de JTAG" },
|
||||
{ id: "adc", nome: "ADC", termos: ["adc", "analogico", "entrada analogica", "conversor analogico", "analogread", "saradc"], pinoCats: ["ADC"], pinoRotulo: "com ADC" },
|
||||
{ id: "dac", nome: "DAC", termos: ["dac", "saida analogica", "conversor digital"], pinoCats: ["DAC"], pinoRotulo: "com DAC" },
|
||||
{ id: "touch", nome: "Touch capacitivo", termos: ["touch", "capacitivo", "toque", "touchpad", "sensor de toque"], pinoCats: ["Touch"], pinoRotulo: "de touch capacitivo" },
|
||||
{ id: "uart", nome: "UART", termos: ["uart", "serial", "tx", "rx", "txd", "rxd", "porta serial"], pinoCats: ["UART"], pinoRotulo: "de UART" },
|
||||
{ id: "spi", nome: "SPI", termos: ["spi", "mosi", "miso", "sclk", "barramento spi"], pinoCats: ["SPI"], pinoRotulo: "de SPI" },
|
||||
{ id: "i2c", nome: "I2C", termos: ["i2c", "sda", "scl", "twi", "iic"], pinoCats: ["I2C"], pinoRotulo: "de I2C" },
|
||||
{ id: "i2s", nome: "I2S", termos: ["i2s", "audio", "som", "microfone", "pdm", "codec"], pinoRe: /i2s|\bpdm\b/, pinoRotulo: "de I2S/áudio" },
|
||||
{ id: "pwm", nome: "PWM", termos: ["pwm", "ledc", "mcpwm", "servo", "dimmer"], pinoRe: /ledc|pwm/, pinoRotulo: "de PWM" },
|
||||
{ id: "sd", nome: "Cartão SD / SDIO", termos: ["sd", "sdio", "sd card", "sdcard", "cartao sd", "microsd", "sdmmc", "mmc"], pinoCats: ["SD"], pinoRe: /sdio|sdmmc|\bsd\b/, pinoRotulo: "de cartão SD/SDIO" },
|
||||
{ id: "camera", nome: "Câmera", termos: ["camera", "cam", "dvp", "csi", "mipi csi", "ov2640", "video"], pinoCats: ["CSI"], pinoRe: /\bcam\b|dvp|cam_/, pinoRotulo: "de câmera" },
|
||||
{ id: "lcd", nome: "Display / LCD", termos: ["lcd", "display", "tela", "dsi", "mipi dsi", "oled", "tft", "lvgl", "rgb"], pinoCats: ["DSI"], pinoRe: /lcd/, pinoRotulo: "de display/LCD" },
|
||||
{ id: "strapping", nome: "Boot / Strapping", termos: ["strapping", "boot", "bootstrap", "modo de boot", "download mode", "modo de gravacao", "inicializacao"], pinoCats: ["Strapping"], pinoRotulo: "de strapping (modo de boot)" },
|
||||
{ id: "energia_pinos", nome: "Alimentação", termos: ["alimentacao", "vdd", "3v3", "3.3v", "tensao", "regulador", "ldo", "fonte"], pinoCats: ["Power"], pinoRotulo: "de alimentação" },
|
||||
{ id: "clock", nome: "Clock / Cristal", termos: ["clock", "xtal", "cristal", "oscilador", "32khz", "40mhz"], pinoCats: ["Clock"], pinoRotulo: "de clock/cristal" },
|
||||
{ id: "gpio", nome: "GPIO", termos: ["gpio", "entradas e saidas"], pinoCats: ["GPIO"], pinoRotulo: "de GPIO" },
|
||||
{ id: "baixo_consumo", nome: "Baixo consumo / ULP", termos: ["ulp", "lp core", "lp cpu", "coprocessador", "lp gpio", "low power", "rtc gpio"], pinoCats: ["Low Power"], pinoRotulo: "de baixo consumo (LP/RTC)" },
|
||||
{ id: "antena", nome: "Antena / RF", termos: ["antena", "rf", "radiofrequencia", "ipex"], pinoCats: ["Antena"], pinoRotulo: "de antena/RF" },
|
||||
{ id: "seguranca", nome: "Segurança", termos: ["seguranca", "secure boot", "criptografia", "encriptacao", "aes", "sha", "rsa", "hmac", "ecdsa", "efuse", "tee", "trng", "rng", "hsm", "protecao"], pinoRotulo: "" },
|
||||
{ id: "consumo", nome: "Consumo de energia", termos: ["consumo", "bateria", "deep sleep", "light sleep", "sleep", "modem sleep", "corrente", "miliamperes", "autonomia", "economia de energia", "low power mode"], pinoRotulo: "" },
|
||||
{ id: "temperatura", nome: "Temperatura", termos: ["temperatura", "calor", "graus", "faixa de temperatura", "industrial"], pinoRotulo: "" },
|
||||
{ id: "ia", nome: "IA / Aceleração", termos: ["ia", "ai", "machine learning", "ml", "tinyml", "vetorial", "inteligencia artificial", "rede neural", "esp-nn", "esp-dl"], pinoRotulo: "" },
|
||||
{ id: "processador", nome: "Processador", termos: ["processador", "cpu", "nucleo", "nucleos", "core", "dual core", "single core", "arquitetura", "xtensa", "risc-v", "riscv"], pinoRotulo: "" },
|
||||
{ id: "frequencia", nome: "Frequência", termos: ["frequencia", "mhz", "velocidade", "desempenho", "performance"], pinoRotulo: "" },
|
||||
{ id: "ferramentas", nome: "Ferramentas / SDK", termos: ["esp-idf", "idf", "arduino", "sdk", "toolchain", "versao do idf"], pinoRotulo: "" },
|
||||
{ id: "encapsulamento", nome: "Módulos e encapsulamento", termos: ["modulo", "modulos", "encapsulamento", "package", "qfn", "wroom", "wrover", "mini-1"], pinoRotulo: "" },
|
||||
];
|
||||
|
||||
/**
|
||||
* Campos de public/series.json que respondem a cada assunto.
|
||||
* `campo` aceita caminho com ponto (seguranca.aes). `secao` é o id da âncora
|
||||
* na página /series/[key].
|
||||
*/
|
||||
export const SPEC_CAMPOS = [
|
||||
{ campo: "arquitetura", label: "Arquitetura", secao: "processador", topicos: ["processador"] },
|
||||
{ campo: "nucleos", label: "Núcleos", secao: "processador", topicos: ["processador"] },
|
||||
{ campo: "frequencia", label: "Frequência", secao: "processador", topicos: ["frequencia", "processador"] },
|
||||
{ campo: "coprocessador_ulp", label: "Coprocessador ULP", secao: "processador", topicos: ["baixo_consumo"] },
|
||||
{ campo: "aceleradores_ia", label: "Aceleradores de IA", secao: "processador", topicos: ["ia"] },
|
||||
|
||||
{ campo: "wifi", label: "Wi-Fi", secao: "conectividade", topicos: ["wifi"] },
|
||||
{ campo: "bluetooth", label: "Bluetooth", secao: "conectividade", topicos: ["bluetooth"] },
|
||||
{ campo: "zigbee_thread", label: "Zigbee/Thread", secao: "conectividade", topicos: ["zigbee"] },
|
||||
{ campo: "matter", label: "Matter", secao: "conectividade", topicos: ["matter"] },
|
||||
{ campo: "ethernet", label: "Ethernet", secao: "conectividade", topicos: ["ethernet"] },
|
||||
{ campo: "ethernet_mac", label: "Ethernet MAC", secao: "conectividade", topicos: ["ethernet"] },
|
||||
{ campo: "can", label: "CAN", secao: "conectividade", topicos: ["can"] },
|
||||
|
||||
{ campo: "memoria_sram", label: "SRAM", secao: "memoria", topicos: ["memoria"] },
|
||||
{ campo: "memoria_sram_rtc", label: "SRAM RTC", secao: "memoria", topicos: ["memoria", "baixo_consumo"] },
|
||||
{ campo: "memoria_rom", label: "ROM", secao: "memoria", topicos: ["memoria"] },
|
||||
{ campo: "flash_externa", label: "Flash externa", secao: "memoria", topicos: ["flash", "memoria"] },
|
||||
{ campo: "psram_externa", label: "PSRAM externa", secao: "memoria", topicos: ["psram", "memoria"] },
|
||||
|
||||
{ campo: "gpio", label: "GPIO", secao: "perifericos", topicos: ["gpio"] },
|
||||
{ campo: "adc", label: "ADC", secao: "perifericos", topicos: ["adc"] },
|
||||
{ campo: "dac", label: "DAC", secao: "perifericos", topicos: ["dac"] },
|
||||
{ campo: "touch", label: "Touch", secao: "perifericos", topicos: ["touch"] },
|
||||
{ campo: "uart", label: "UART", secao: "perifericos", topicos: ["uart"] },
|
||||
{ campo: "spi", label: "SPI", secao: "perifericos", topicos: ["spi", "flash"] },
|
||||
{ campo: "i2c", label: "I2C", secao: "perifericos", topicos: ["i2c"] },
|
||||
{ campo: "i2s", label: "I2S", secao: "perifericos", topicos: ["i2s"] },
|
||||
{ campo: "pwm", label: "PWM", secao: "perifericos", topicos: ["pwm"] },
|
||||
{ campo: "usb", label: "USB", secao: "perifericos", topicos: ["usb"] },
|
||||
{ campo: "lcd", label: "LCD", secao: "interfaces", topicos: ["lcd"] },
|
||||
{ campo: "camera", label: "Câmera", secao: "interfaces", topicos: ["camera"] },
|
||||
{ campo: "mipi_csi", label: "MIPI CSI", secao: "interfaces", topicos: ["camera"] },
|
||||
{ campo: "mipi_dsi", label: "MIPI DSI", secao: "interfaces", topicos: ["lcd"] },
|
||||
{ campo: "sdio", label: "SDIO", secao: "interfaces", topicos: ["sd"] },
|
||||
{ campo: "sensor_temperatura", label: "Sensor de temperatura", secao: "interfaces", topicos: ["temperatura"] },
|
||||
|
||||
{ campo: "seguranca.aes", label: "AES", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.sha", label: "SHA", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.rsa", label: "RSA", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.ecc", label: "ECC", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.ecdsa", label: "ECDSA", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.hmac", label: "HMAC", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.assinatura_digital", label: "Assinatura digital", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.rng", label: "Gerador aleatório", secao: "seguranca", topicos: ["seguranca"] },
|
||||
{ campo: "seguranca.criptografia_flash", label: "Criptografia de flash", secao: "seguranca", topicos: ["seguranca", "flash"] },
|
||||
{ campo: "seguranca.secure_boot", label: "Secure Boot", secao: "seguranca", topicos: ["seguranca", "strapping"] },
|
||||
|
||||
{ campo: "temperatura_operacao", label: "Temperatura de operação", secao: "temperatura", topicos: ["temperatura"] },
|
||||
{ campo: "temperatura_armazenamento", label: "Temperatura de armazenamento", secao: "temperatura", topicos: ["temperatura"] },
|
||||
|
||||
{ campo: "esp_idf_minimo", label: "ESP-IDF mínimo", secao: "ferramentas", topicos: ["ferramentas"] },
|
||||
{ campo: "arduino_core", label: "Core Arduino", secao: "ferramentas", topicos: ["ferramentas"] },
|
||||
{ campo: "depuracao", label: "Depuração", secao: "ferramentas", topicos: ["jtag", "ferramentas"] },
|
||||
{ campo: "encapsulamento", label: "Encapsulamento", secao: "ferramentas", topicos: ["encapsulamento"] },
|
||||
{ campo: "modulos", label: "Módulos", secao: "ferramentas", topicos: ["encapsulamento"] },
|
||||
];
|
||||
|
||||
const ROTULOS_ENERGIA = {
|
||||
active: "Ativo",
|
||||
modem_sleep: "Modem Sleep",
|
||||
light_sleep: "Light Sleep",
|
||||
deep_sleep: "Deep Sleep",
|
||||
hibernation: "Hibernação",
|
||||
};
|
||||
|
||||
const pegar = (obj, caminho) => caminho.split(".").reduce((o, k) => (o == null ? o : o[k]), obj);
|
||||
|
||||
/**
|
||||
* Monta, para cada série, a lista plana de especificações (com os assuntos a
|
||||
* que respondem) e os pinos do diagrama. É o que o navegador baixa.
|
||||
*
|
||||
* @param {Record<string, object>} series conteúdo de public/series.json
|
||||
* @param {Record<string, object[]>} conexoes pinos por série (public/conexoes)
|
||||
*/
|
||||
export function montarConhecimento(series, conexoes) {
|
||||
const saida = {};
|
||||
for (const [chave, s] of Object.entries(series)) {
|
||||
const specs = [];
|
||||
for (const c of SPEC_CAMPOS) {
|
||||
const valor = pegar(s, c.campo);
|
||||
if (valor == null || valor === "") continue;
|
||||
specs.push({ label: c.label, valor: String(valor), secao: c.secao, topicos: c.topicos });
|
||||
}
|
||||
for (const [modo, valor] of Object.entries(s.consumo_energia ?? {})) {
|
||||
const base = modo.replace(/_cpu.*|_wifi.*/, "");
|
||||
const label = ROTULOS_ENERGIA[modo] ?? ROTULOS_ENERGIA[base] ?? modo.replace(/_/g, " ");
|
||||
specs.push({ label: `Consumo: ${label}`, valor: String(valor), secao: "energia", topicos: ["consumo"] });
|
||||
}
|
||||
saida[chave] = {
|
||||
nome: s.nome_completo ?? chave,
|
||||
specs,
|
||||
pinos: (conexoes[chave] ?? []).map((p) => ({
|
||||
n: String(p.numero),
|
||||
nome: p.nome,
|
||||
f: p.funcoes ?? [],
|
||||
c: p.categorias ?? [],
|
||||
a: p.avisos ?? [],
|
||||
})),
|
||||
};
|
||||
}
|
||||
return saida;
|
||||
}
|
||||
Reference in new issue
Block a user