From d71dc8df3c7eee1d62382c41f19656b81b2d7a35 Mon Sep 17 00:00:00 2001
From: Lucas Rayan <lucas.guerra@pop-pe.rnp.br>
Date: Tue, 25 Aug 2026 16:55:38 -0300
Subject: [PATCH] feat: add ESP-RainMaker and ESP-Matter frameworks and update
 existing framework metadata in frameworks.json

---
 app/componentes/layout.jsx         |  74 ++++
 app/componentes/page.jsx           | 644 +++++++++++++++++++++++++++++
 app/diagnostico/page.jsx           |  17 +-
 app/frameworks/[key]/page.jsx      |  53 ++-
 app/frameworks/page.jsx            | 193 ++++++---
 app/page.jsx                       |  21 +-
 app/sitemap.js                     |   1 +
 components/Footer.jsx              |   8 +
 components/Header.jsx              |  37 +-
 lib/componentRegistryData.js       | 470 +++++++++++++++++++++
 lib/diagnosticoData.js             | 149 ++++++-
 public/exemplos/esp-idf.c          |  59 ++-
 public/exemplos/esp-iot-solution.c |  72 ++++
 public/exemplos/esp-now.c          |  92 +++++
 public/exemplos/esp-rainmaker.c    |  76 ++++
 public/exemplos/esp-sr.c           |  98 +++++
 public/exemplos/esp-zigbee.c       |  97 +++++
 public/exemplos/rust-esp.rs        |  48 +++
 public/frameworks.json             | 531 +++++++++++++++---------
 19 files changed, 2458 insertions(+), 282 deletions(-)
 create mode 100644 app/componentes/layout.jsx
 create mode 100644 app/componentes/page.jsx
 create mode 100644 lib/componentRegistryData.js
 create mode 100644 public/exemplos/esp-iot-solution.c
 create mode 100644 public/exemplos/esp-now.c
 create mode 100644 public/exemplos/esp-rainmaker.c
 create mode 100644 public/exemplos/esp-sr.c
 create mode 100644 public/exemplos/esp-zigbee.c
 create mode 100644 public/exemplos/rust-esp.rs

diff --git a/app/componentes/layout.jsx b/app/componentes/layout.jsx
new file mode 100644
index 0000000..39ba854
--- /dev/null
+++ b/app/componentes/layout.jsx
@@ -0,0 +1,74 @@
+import { paginaMeta, jsonLd } from "@/lib/seo";
+
+export const metadata = paginaMeta({
+	titulo: "ESP Component Registry & IDF Component Manager · ESPDocs",
+	descricao: "Catálogo oficial e interativo do ESP Component Registry: drivers de displays, LVGL, reconhecimento de voz ESP-SR, RainMaker, BSPs e gerador de idf_component.yml.",
+	caminho: "/componentes",
+	keywords: [
+		"ESP Component Registry",
+		"IDF Component Manager",
+		"idf_component.yml",
+		"idf.py add-dependency",
+		"componentes ESP32",
+		"espressif esp_lvgl_port",
+		"espressif esp_rainmaker",
+		"espressif esp-sr",
+		"bibliotecas ESP-IDF",
+	],
+});
+
+const faqs = [
+	{
+		pergunta: "O que é o ESP Component Registry e o IDF Component Manager?",
+		resposta: "O ESP Component Registry (components.espressif.com) é o repositório oficial de pacotes modulares da Espressif. O IDF Component Manager é a ferramenta integrada ao ESP-IDF (a partir do v4.4 e padrão no v5.x+) que baixa, compila e resolve versões de dependências automaticamente a partir do manifesto idf_component.yml.",
+	},
+	{
+		pergunta: "Como adicionar um componente ao meu projeto ESP-IDF?",
+		resposta: "Você pode executar o comando 'idf.py add-dependency \"namespace/componente^versao\"' no terminal do projeto (por exemplo: idf.py add-dependency \"espressif/esp_lvgl_port^2.4.0\") ou editar diretamente o arquivo main/idf_component.yml.",
+	},
+	{
+		pergunta: "Qual a diferença entre usar o Component Registry e git submodules?",
+		resposta: "O Component Registry elimina a complexidade de gerenciar submódulos Git pesados e versões manuais. Ele oferece versionamento semântico (^ e ~), resolução automática de dependências transitivas e compilação modular sob demanda.",
+	},
+	{
+		pergunta: "Posso criar e publicar meus próprios componentes?",
+		resposta: "Sim, qualquer desenvolvedor ou empresa pode publicar componentes públicos ou privados no ESP Component Registry utilizando a ferramenta oficial Compote CLI (pip install idf-component-manager).",
+	},
+];
+
+export default function ComponentesLayout({ children }) {
+	return (
+		<>
+			<script
+				type="application/ld+json"
+				dangerouslySetInnerHTML={{
+					__html: JSON.stringify(
+						jsonLd.trilha([
+							{ nome: "Início", caminho: "/" },
+							{ nome: "ESP Component Registry", caminho: "/componentes" },
+						])
+					),
+				}}
+			/>
+			<script
+				type="application/ld+json"
+				dangerouslySetInnerHTML={{
+					__html: JSON.stringify(jsonLd.perguntas(faqs)),
+				}}
+			/>
+			<script
+				type="application/ld+json"
+				dangerouslySetInnerHTML={{
+					__html: JSON.stringify(
+						jsonLd.aplicacaoWeb({
+							nome: "Hub do ESP Component Registry & Construtor de Manifesto",
+							descricao: "Catálogo curado e gerador de manifesto idf_component.yml para componentes modulares do ESP-IDF.",
+							caminho: "/componentes",
+						})
+					),
+				}}
+			/>
+			{children}
+		</>
+	);
+}
diff --git a/app/componentes/page.jsx b/app/componentes/page.jsx
new file mode 100644
index 0000000..cb5e622
--- /dev/null
+++ b/app/componentes/page.jsx
@@ -0,0 +1,644 @@
+"use client";
+
+import { useState, useMemo } from "react";
+import Header from "@/components/Header";
+import Footer from "@/components/Footer";
+import Link from "next/link";
+import {
+	CATEGORIAS_COMPONENTES,
+	COMPONENTES_REGISTRY,
+	GUIA_COMPONENT_MANAGER
+} from "@/lib/componentRegistryData";
+import {
+	Layers,
+	Search,
+	Copy,
+	Check,
+	ExternalLink,
+	Sparkles,
+	Terminal,
+	Code2,
+	Plus,
+	Trash2,
+	Download,
+	Cpu,
+	Box,
+	CheckCircle2,
+	ChevronRight,
+	HelpCircle,
+	ArrowRight,
+	BookOpen,
+	ShieldCheck,
+	Zap,
+	Monitor,
+	Cloud,
+	Brain,
+	Home,
+	CircuitBoard,
+	Wrench
+} from "lucide-react";
+
+export default function ComponentRegistryPage() {
+	const [busca, setBusca] = useState("");
+	const [categoriaAtiva, setCategoriaAtiva] = useState("todos");
+	const [chipFiltro, setChipFiltro] = useState("todos");
+	const [copiadoId, setCopiadoId] = useState(null);
+	const [manifestoCopiado, setManifestoCopiado] = useState(false);
+
+	// Componentes selecionados no construtor de idf_component.yml
+	const [componentesSelecionados, setComponentesSelecionados] = useState([
+		"espressif-esp_lvgl_port",
+		"espressif-led_indicator"
+	]);
+
+	// Lista de chips únicos para filtro
+	const chipsDisponiveis = ["todos", "ESP32", "ESP32-S3", "ESP32-C6", "ESP32-P4", "ESP32-H2", "ESP32-C3"];
+
+	// Filtragem dos componentes
+	const componentesFiltrados = useMemo(() => {
+		return COMPONENTES_REGISTRY.filter((comp) => {
+			const matchCategoria = categoriaAtiva === "todos" || comp.categoria === categoriaAtiva;
+			const matchChip = chipFiltro === "todos" || (comp.chips && comp.chips.includes(chipFiltro));
+			const matchBusca =
+				busca.trim() === "" ||
+				comp.name.toLowerCase().includes(busca.toLowerCase()) ||
+				comp.namespace.toLowerCase().includes(busca.toLowerCase()) ||
+				comp.titulo.toLowerCase().includes(busca.toLowerCase()) ||
+				comp.descricao.toLowerCase().includes(busca.toLowerCase()) ||
+				comp.tags.some((t) => t.toLowerCase().includes(busca.toLowerCase()));
+
+			return matchCategoria && matchChip && matchBusca;
+		});
+	}, [busca, categoriaAtiva, chipFiltro]);
+
+	// Manipuladores de cópia
+	const copiarComando = (id, comando) => {
+		navigator.clipboard.writeText(comando);
+		setCopiadoId(id);
+		setTimeout(() => setCopiadoId(null), 2000);
+	};
+
+	const toggleSelecaoManifesto = (id) => {
+		setComponentesSelecionados((prev) =>
+			prev.includes(id) ? prev.filter((item) => item !== id) : [...prev, id]
+		);
+	};
+
+	// Geração dinâmica do manifesto YAML
+	const manifestoYaml = useMemo(() => {
+		const selecionados = COMPONENTES_REGISTRY.filter((c) =>
+			componentesSelecionados.includes(c.id)
+		);
+
+		if (selecionados.length === 0) {
+			return `# Nenhum componente selecionado.\n# Clique em "+ Adicionar ao Manifesto" nos cards abaixo.`;
+		}
+
+		let yaml = `# main/idf_component.yml\n# Gerado via ESPDocs Component Hub (https://espdocs.cienciaembarcada.com.br/componentes)\n\ndependencies:\n`;
+		selecionados.forEach((c) => {
+			yaml += `  ${c.namespace}/${c.name}: "${c.versao}"\n`;
+		});
+		return yaml;
+	}, [componentesSelecionados]);
+
+	const copiarManifesto = () => {
+		navigator.clipboard.writeText(manifestoYaml);
+		setManifestoCopiado(true);
+		setTimeout(() => setManifestoCopiado(false), 2000);
+	};
+
+	const baixarManifesto = () => {
+		const blob = new Blob([manifestoYaml], { type: "text/yaml;charset=utf-8" });
+		const url = URL.createObjectURL(blob);
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = "idf_component.yml";
+		document.body.appendChild(link);
+		link.click();
+		document.body.removeChild(link);
+		URL.revokeObjectURL(url);
+	};
+
+	// Mapeamento de ícones de categoria
+	const renderIconeCategoria = (id) => {
+		switch (id) {
+			case "ui_display":
+				return <Monitor className="w-4 h-4" />;
+			case "cloud_conectividade":
+				return <Cloud className="w-4 h-4" />;
+			case "audio_voz_ia":
+				return <Brain className="w-4 h-4" />;
+			case "smart_home_mesh":
+				return <Home className="w-4 h-4" />;
+			case "drivers_perifericos":
+				return <Cpu className="w-4 h-4" />;
+			case "bsp_placas":
+				return <CircuitBoard className="w-4 h-4" />;
+			case "sistema_utilitarios":
+				return <Wrench className="w-4 h-4" />;
+			default:
+				return <Layers className="w-4 h-4" />;
+		}
+	};
+
+	return (
+		<div className="bg-gradient-to-br from-slate-100 via-slate-50 to-purple-100/40 dark:from-slate-950 dark:via-slate-950 dark:to-slate-900 min-h-screen text-slate-900 dark:text-slate-100 transition-colors duration-300">
+			<Header />
+
+			<main id="conteudo" className="px-4 md:px-6 pt-12 md:pt-16 pb-24 max-w-7xl mx-auto space-y-12">
+				{/* Top Hero Section */}
+				<section className="text-center select-none relative">
+					<div className="inline-flex items-center gap-2 bg-white/80 dark:bg-slate-900/60 backdrop-blur-md px-4 py-2 rounded-full mb-6 border border-slate-300 dark:border-slate-800/80 shadow-xs">
+						<Box className="w-4 h-4 text-purple-500" />
+						<span className="text-xs font-bold text-slate-700 dark:text-slate-300 uppercase tracking-wider">
+							ESP-IDF Component Manager
+						</span>
+						<span className="bg-purple-100 dark:bg-purple-950/80 text-purple-700 dark:text-purple-300 text-[10px] font-extrabold px-2 py-0.5 rounded-full">
+							Oficial
+						</span>
+					</div>
+
+					<h1 className="text-4xl md:text-6xl font-display font-extrabold bg-gradient-to-r from-blue-600 via-purple-600 to-pink-600 dark:from-blue-400 dark:via-purple-400 dark:to-pink-400 bg-clip-text text-transparent mb-6 pb-2 pt-1 leading-tight md:leading-[1.18] tracking-tight">
+						ESP Component Registry
+					</h1>
+
+					<p className="text-sm md:text-base text-slate-600 dark:text-slate-350 max-w-3xl mx-auto leading-relaxed font-semibold">
+						O catálogo oficial de pacotes reutilizáveis da Espressif para o ESP-IDF.
+						Adicione drivers de displays, reconhecimento de voz, pilhas industriais e bibliotecas
+						com comandos de um clique e geração de manifesto declarativo.
+					</p>
+
+					<div className="flex flex-wrap items-center justify-center gap-3 mt-6">
+						<a
+							href="https://components.espressif.com"
+							target="_blank"
+							rel="noopener noreferrer"
+							className="inline-flex items-center gap-2 bg-gradient-to-r from-purple-600 to-indigo-600 hover:from-purple-500 hover:to-indigo-500 text-white text-xs font-bold px-4 py-2.5 rounded-xl shadow-md transition-all active:scale-95"
+						>
+							<span>Acessar Registry Oficial</span>
+							<ExternalLink className="w-3.5 h-3.5" />
+						</a>
+						<a
+							href="#manifesto-builder"
+							className="inline-flex items-center gap-2 bg-white dark:bg-slate-900 border border-slate-300 dark:border-slate-800 text-slate-700 dark:text-slate-300 hover:bg-slate-100 dark:hover:bg-slate-800 text-xs font-bold px-4 py-2.5 rounded-xl shadow-xs transition-all active:scale-95"
+						>
+							<Code2 className="w-3.5 h-3.5 text-purple-500" />
+							<span>Gerador de idf_component.yml</span>
+						</a>
+					</div>
+				</section>
+
+				{/* Interactive Search & Filter Bar */}
+				<section className="bg-white dark:bg-slate-900/60 backdrop-blur-xl rounded-3xl p-6 border border-slate-300 dark:border-slate-800/80 shadow-xl space-y-5">
+					<div className="flex flex-col md:flex-row gap-4 items-center justify-between">
+						{/* Search Input */}
+						<div className="relative w-full md:flex-1">
+							<Search className="w-4 h-4 absolute left-3.5 top-1/2 -translate-y-1/2 text-slate-400" />
+							<input
+								type="text"
+								value={busca}
+								onChange={(e) => setBusca(e.target.value)}
+								placeholder="Buscar componentes por nome, namespace, funcionalidade ou tags (ex: lvgl, rainmaker, ws2812)..."
+								className="w-full pl-10 pr-4 py-2.5 bg-slate-50 dark:bg-slate-950/70 border border-slate-250 dark:border-slate-800 rounded-2xl text-xs md:text-sm font-semibold text-slate-800 dark:text-slate-100 placeholder:text-slate-400 focus:outline-hidden focus:ring-2 focus:ring-purple-500 transition-all"
+							/>
+							{busca && (
+								<button
+									onClick={() => setBusca("")}
+									className="absolute right-3 top-1/2 -translate-y-1/2 text-xs font-bold text-slate-400 hover:text-slate-600 dark:hover:text-slate-200"
+								>
+									Limpar
+								</button>
+							)}
+						</div>
+
+						{/* Chip Filter */}
+						<div className="flex items-center gap-1.5 w-full md:w-auto overflow-x-auto pb-1 md:pb-0">
+							<span className="text-[11px] font-bold text-slate-500 uppercase tracking-wider shrink-0 mr-1">
+								SoC:
+							</span>
+							{chipsDisponiveis.map((chip) => (
+								<button
+									key={chip}
+									onClick={() => setChipFiltro(chip)}
+									className={`px-3 py-1.5 rounded-xl text-xs font-bold shrink-0 transition-all cursor-pointer ${
+										chipFiltro === chip
+											? "bg-purple-600 text-white shadow-xs"
+											: "bg-slate-100 dark:bg-slate-800/80 text-slate-650 dark:text-slate-350 hover:bg-slate-200 dark:hover:bg-slate-700"
+									}`}
+								>
+									{chip === "todos" ? "Todos SoCs" : chip}
+								</button>
+							))}
+						</div>
+					</div>
+
+					{/* Category Tabs */}
+					<div className="flex items-center gap-2 overflow-x-auto pb-2 border-t border-slate-200 dark:border-slate-800/60 pt-4">
+						{CATEGORIAS_COMPONENTES.map((cat) => {
+							const ativa = categoriaAtiva === cat.id;
+							const contagem =
+								cat.id === "todos"
+									? COMPONENTES_REGISTRY.length
+									: COMPONENTES_REGISTRY.filter((c) => c.categoria === cat.id).length;
+
+							return (
+								<button
+									key={cat.id}
+									onClick={() => setCategoriaAtiva(cat.id)}
+									className={`inline-flex items-center gap-2 px-3.5 py-2 rounded-xl text-xs font-bold shrink-0 transition-all cursor-pointer ${
+										ativa
+											? "bg-purple-50 dark:bg-purple-950/60 text-purple-600 dark:text-purple-400 border border-purple-200 dark:border-purple-800/60 shadow-xs"
+											: "text-slate-600 dark:text-slate-400 hover:bg-slate-100 dark:hover:bg-slate-800/60"
+									}`}
+								>
+									{renderIconeCategoria(cat.id)}
+									<span>{cat.nome}</span>
+									<span
+										className={`text-[10px] px-1.5 py-0.2 rounded-full ${
+											ativa
+												? "bg-purple-200 dark:bg-purple-900 text-purple-800 dark:text-purple-200"
+												: "bg-slate-200 dark:bg-slate-800 text-slate-600 dark:text-slate-400"
+										}`}
+									>
+										{contagem}
+									</span>
+								</button>
+							);
+						})}
+					</div>
+				</section>
+
+				{/* Components Grid */}
+				<section className="space-y-4">
+					<div className="flex items-center justify-between">
+						<h2 className="text-lg font-display font-extrabold text-slate-850 dark:text-slate-100 flex items-center gap-2">
+							<Sparkles className="w-5 h-5 text-purple-500" />
+							<span>Componentes Disponíveis ({componentesFiltrados.length})</span>
+						</h2>
+						<span className="text-xs text-slate-500 font-semibold">
+							Clique em um comando para copiar para o terminal
+						</span>
+					</div>
+
+					{componentesFiltrados.length === 0 ? (
+						<div className="text-center py-16 bg-white dark:bg-slate-900/40 rounded-3xl border border-slate-300 dark:border-slate-800 p-8">
+							<Box className="w-12 h-12 text-slate-400 mx-auto mb-3 opacity-60" />
+							<p className="text-base font-bold text-slate-750 dark:text-slate-200">
+								Nenhum componente encontrado para esses filtros.
+							</p>
+							<p className="text-xs text-slate-500 mt-1">
+								Tente buscar por termos mais genéricos ou resetar a categoria.
+							</p>
+							<button
+								onClick={() => {
+									setBusca("");
+									setCategoriaAtiva("todos");
+									setChipFiltro("todos");
+								}}
+								className="mt-4 px-4 py-2 bg-purple-600 text-white rounded-xl text-xs font-bold"
+							>
+								Limpar Todos os Filtros
+							</button>
+						</div>
+					) : (
+						<div className="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
+							{componentesFiltrados.map((comp) => {
+								const selecionado = componentesSelecionados.includes(comp.id);
+								const cliCmd = `idf.py add-dependency "${comp.namespace}/${comp.name}${comp.versao}"`;
+								const foiCopiado = copiadoId === comp.id;
+
+								return (
+									<div
+										key={comp.id}
+										className={`bg-white dark:bg-slate-900/45 backdrop-blur-xl border rounded-3xl shadow-lg hover:shadow-2xl transition-all duration-300 flex flex-col justify-between overflow-hidden relative group ${
+											selecionado
+												? "border-purple-500/80 ring-2 ring-purple-500/20"
+												: "border-slate-300 dark:border-slate-800/80 hover:-translate-y-1"
+										}`}
+									>
+										{/* Top Header Card */}
+										<div className="p-6 pb-4 border-b border-slate-150 dark:border-slate-850/40">
+											<div className="flex items-start justify-between gap-3 mb-2">
+												<div>
+													<div className="flex items-center gap-1.5 mb-1">
+														<span className="text-[10px] font-extrabold text-slate-400 uppercase tracking-wider">
+															{comp.namespace}/
+														</span>
+														{comp.oficial && (
+															<span className="inline-flex items-center gap-1 bg-emerald-100 dark:bg-emerald-950/60 text-emerald-700 dark:text-emerald-300 text-[9px] font-extrabold px-2 py-0.2 rounded-full border border-emerald-300 dark:border-emerald-800/60">
+																<ShieldCheck className="w-3 h-3" />
+																Oficial
+															</span>
+														)}
+													</div>
+													<h3 className="text-xl font-display font-extrabold text-slate-850 dark:text-slate-100 group-hover:text-purple-600 dark:group-hover:text-purple-400 transition-colors">
+														{comp.name}
+													</h3>
+													<p className="text-xs font-semibold text-purple-600 dark:text-purple-400">
+														{comp.titulo}
+													</p>
+												</div>
+
+												<span className="px-2.5 py-1 rounded-lg text-[10px] font-mono font-bold bg-slate-100 dark:bg-slate-800 text-slate-700 dark:text-slate-300 border border-slate-200 dark:border-slate-700 shrink-0">
+													{comp.versao}
+												</span>
+											</div>
+
+											<p className="text-xs text-slate-500 dark:text-slate-350 leading-relaxed mt-2.5 line-clamp-3">
+												{comp.descricao}
+											</p>
+
+											{/* Tags */}
+											<div className="flex flex-wrap gap-1.5 mt-3.5">
+												{comp.tags.map((tag) => (
+													<span
+														key={tag}
+														className="text-[9px] font-bold bg-slate-100 dark:bg-slate-950/60 text-slate-600 dark:text-slate-400 px-2 py-0.5 rounded-md border border-slate-250 dark:border-slate-800"
+													>
+														{tag}
+													</span>
+												))}
+											</div>
+										</div>
+
+										{/* Interactive CLI Action Box */}
+										<div className="p-6 py-4 bg-slate-50/50 dark:bg-slate-950/40 space-y-3">
+											<div>
+												<div className="flex items-center justify-between text-[10px] font-bold text-slate-400 uppercase tracking-wider mb-1">
+													<span className="flex items-center gap-1">
+														<Terminal className="w-3 h-3 text-purple-500" />
+														Comando CLI
+													</span>
+													{foiCopiado && (
+														<span className="text-emerald-500 font-bold flex items-center gap-0.5">
+															<Check className="w-3 h-3" /> Copiado!
+														</span>
+													)}
+												</div>
+												<button
+													onClick={() => copiarComando(comp.id, cliCmd)}
+													className="w-full text-left bg-slate-900 text-slate-100 p-2.5 rounded-xl font-mono text-[11px] hover:bg-slate-800 border border-slate-800 flex items-center justify-between group/cmd transition-colors cursor-pointer"
+													title="Clique para copiar comando"
+												>
+													<span className="truncate pr-2">{cliCmd}</span>
+													<Copy className="w-3.5 h-3.5 text-slate-400 group-hover/cmd:text-white shrink-0" />
+												</button>
+											</div>
+
+											{/* Compatible Chips */}
+											<div>
+												<span className="text-[10px] font-bold text-slate-400 uppercase tracking-wider block mb-1">
+													SoCs Compatíveis:
+												</span>
+												<div className="flex flex-wrap gap-1">
+													{comp.chips.map((chip) => (
+														<span
+															key={chip}
+															className="text-[9px] font-semibold text-slate-650 dark:text-slate-350 bg-slate-200/60 dark:bg-slate-800 px-1.5 py-0.2 rounded"
+														>
+															{chip}
+														</span>
+													))}
+												</div>
+											</div>
+										</div>
+
+										{/* Bottom Actions */}
+										<div className="p-4 px-6 border-t border-slate-150 dark:border-slate-850/40 flex items-center justify-between text-xs font-bold">
+											<button
+												onClick={() => toggleSelecaoManifesto(comp.id)}
+												className={`inline-flex items-center gap-1.5 px-3 py-1.5 rounded-xl transition-all cursor-pointer ${
+													selecionado
+														? "bg-purple-600 text-white shadow-xs"
+														: "bg-purple-50 dark:bg-purple-950/40 text-purple-600 dark:text-purple-400 border border-purple-200 dark:border-purple-800/40 hover:bg-purple-100"
+												}`}
+											>
+												{selecionado ? (
+													<>
+														<CheckCircle2 className="w-3.5 h-3.5" />
+														<span>No Manifesto</span>
+													</>
+												) : (
+													<>
+														<Plus className="w-3.5 h-3.5" />
+														<span>Adicionar ao Manifesto</span>
+													</>
+												)}
+											</button>
+
+											<div className="flex items-center gap-2">
+												<a
+													href={comp.urlRegistry}
+													target="_blank"
+													rel="noopener noreferrer"
+													className="text-slate-400 hover:text-purple-600 dark:hover:text-purple-400 transition-colors p-1"
+													title="Ver página oficial no ESP Component Registry"
+												>
+													<ExternalLink className="w-4 h-4" />
+												</a>
+											</div>
+										</div>
+									</div>
+								);
+							})}
+						</div>
+					)}
+				</section>
+
+				{/* Interactive Manifest Builder Section */}
+				<section
+					id="manifesto-builder"
+					className="bg-white dark:bg-slate-900/60 backdrop-blur-xl rounded-3xl p-6 md:p-8 border border-purple-300 dark:border-purple-800/60 shadow-2xl space-y-6"
+				>
+					<div className="flex flex-col md:flex-row items-start md:items-center justify-between gap-4 pb-4 border-b border-slate-250 dark:border-slate-800">
+						<div>
+							<div className="inline-flex items-center gap-2 px-3 py-1 bg-purple-100 dark:bg-purple-950/60 text-purple-700 dark:text-purple-300 text-xs font-bold rounded-full mb-2">
+								<Code2 className="w-3.5 h-3.5" />
+								<span>Gerador de Manifesto Declarativo</span>
+							</div>
+							<h2 className="text-2xl font-display font-extrabold text-slate-850 dark:text-slate-100">
+								Construtor de `idf_component.yml`
+							</h2>
+							<p className="text-xs text-slate-500 dark:text-slate-400 mt-1 font-semibold">
+								Adicione este arquivo na pasta <code>main/</code> do seu projeto ESP-IDF para
+								instalar todas as bibliotecas automaticamente na compilação.
+							</p>
+						</div>
+
+						<div className="flex items-center gap-2.5 w-full md:w-auto">
+							<button
+								onClick={copiarManifesto}
+								className="flex-1 md:flex-none inline-flex items-center justify-center gap-1.5 bg-gradient-to-r from-purple-600 to-indigo-600 text-white px-4 py-2.5 rounded-xl text-xs font-bold hover:opacity-90 shadow-md transition-all active:scale-95 cursor-pointer"
+							>
+								{manifestoCopiado ? (
+									<>
+										<Check className="w-4 h-4" />
+										<span>Manifesto Copiado!</span>
+									</>
+								) : (
+									<>
+										<Copy className="w-4 h-4" />
+										<span>Copiar YAML</span>
+									</>
+								)}
+							</button>
+
+							<button
+								onClick={baixarManifesto}
+								className="inline-flex items-center justify-center gap-1.5 bg-slate-100 dark:bg-slate-800 hover:bg-slate-200 dark:hover:bg-slate-700 text-slate-700 dark:text-slate-200 px-4 py-2.5 rounded-xl text-xs font-bold transition-all active:scale-95 cursor-pointer"
+								title="Baixar arquivo idf_component.yml pronto"
+							>
+								<Download className="w-4 h-4" />
+								<span className="hidden sm:inline">Baixar .yml</span>
+							</button>
+
+							{componentesSelecionados.length > 0 && (
+								<button
+									onClick={() => setComponentesSelecionados([])}
+									className="p-2.5 text-slate-400 hover:text-rose-500 rounded-xl hover:bg-rose-50 dark:hover:bg-rose-950/30 transition-colors"
+									title="Limpar seleção"
+								>
+									<Trash2 className="w-4 h-4" />
+								</button>
+							)}
+						</div>
+					</div>
+
+					{/* YAML Output Terminal */}
+					<div className="relative">
+						<div className="bg-slate-950 text-slate-200 rounded-2xl p-4 md:p-6 font-mono text-xs md:text-sm overflow-x-auto border border-slate-800 shadow-inner">
+							<pre>{manifestoYaml}</pre>
+						</div>
+					</div>
+
+					{/* Selected components badges */}
+					<div className="flex flex-wrap items-center gap-2 pt-2">
+						<span className="text-xs font-bold text-slate-500 uppercase tracking-wider mr-2">
+							Componentes Inclusos ({componentesSelecionados.length}):
+						</span>
+						{componentesSelecionados.map((id) => {
+							const c = COMPONENTES_REGISTRY.find((item) => item.id === id);
+							if (!c) return null;
+							return (
+								<span
+									key={id}
+									className="inline-flex items-center gap-1.5 bg-purple-50 dark:bg-purple-950/60 text-purple-700 dark:text-purple-300 border border-purple-300 dark:border-purple-800 px-3 py-1 rounded-xl text-xs font-bold"
+								>
+									<span>{c.name}</span>
+									<button
+										onClick={() => toggleSelecaoManifesto(id)}
+										className="hover:text-rose-500 ml-1 cursor-pointer"
+										title="Remover"
+									>
+										×
+									</button>
+								</span>
+							);
+						})}
+					</div>
+				</section>
+
+				{/* Educational Guide: O que é o Component Manager */}
+				<section className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl p-6 md:p-8 border border-slate-300 dark:border-slate-800 shadow-xl space-y-8 select-none">
+					<div>
+						<div className="flex items-center gap-3 mb-2">
+							<div className="p-2.5 rounded-xl bg-purple-50 dark:bg-purple-950/50 text-purple-600 dark:text-purple-400">
+								<BookOpen className="w-5 h-5" />
+							</div>
+							<h2 className="text-2xl font-display font-extrabold text-slate-850 dark:text-slate-100">
+								{GUIA_COMPONENT_MANAGER.titulo}
+							</h2>
+						</div>
+						<p className="text-xs md:text-sm text-slate-600 dark:text-slate-350 leading-relaxed font-semibold max-w-4xl">
+							{GUIA_COMPONENT_MANAGER.resumo}
+						</p>
+					</div>
+
+					{/* Vantagens Grid */}
+					<div className="grid md:grid-cols-2 lg:grid-cols-4 gap-4">
+						{GUIA_COMPONENT_MANAGER.vantagens.map((v, i) => (
+							<div
+								key={i}
+								className="bg-slate-50/70 dark:bg-slate-950/40 p-5 rounded-2xl border border-slate-200 dark:border-slate-800/80 space-y-2"
+							>
+								<div className="w-8 h-8 rounded-xl bg-purple-100 dark:bg-purple-900/40 text-purple-600 dark:text-purple-400 flex items-center justify-center text-xs font-extrabold">
+									0{i + 1}
+								</div>
+								<h3 className="text-sm font-bold text-slate-850 dark:text-slate-100">{v.titulo}</h3>
+								<p className="text-xs text-slate-500 dark:text-slate-400 leading-relaxed">
+									{v.descricao}
+								</p>
+							</div>
+						))}
+					</div>
+
+					{/* Comandos Essenciais da CLI */}
+					<div className="space-y-3">
+						<h3 className="text-base font-display font-extrabold text-slate-850 dark:text-slate-100 flex items-center gap-2">
+							<Terminal className="w-4 h-4 text-purple-500" />
+							<span>Comandos Essenciais no Terminal</span>
+						</h3>
+
+						<div className="space-y-3">
+							{GUIA_COMPONENT_MANAGER.comandosCli.map((cmd, i) => (
+								<div
+									key={i}
+									className="bg-slate-900 text-slate-100 p-4 rounded-2xl border border-slate-800 flex flex-col md:flex-row md:items-center justify-between gap-3 font-mono text-xs"
+								>
+									<div>
+										<span className="text-purple-400 font-bold">$ {cmd.exemplo}</span>
+										<p className="text-[11px] text-slate-400 font-sans mt-1">
+											{cmd.explicacao}
+										</p>
+									</div>
+									<button
+										onClick={() => copiarComando(`cmd-${i}`, cmd.exemplo)}
+										className="self-start md:self-auto inline-flex items-center gap-1 bg-slate-800 hover:bg-slate-700 px-3 py-1.5 rounded-lg text-[11px] font-bold text-slate-200 transition-colors shrink-0"
+									>
+										{copiadoId === `cmd-${i}` ? (
+											<>
+												<Check className="w-3.5 h-3.5 text-emerald-400" />
+												<span>Copiado</span>
+											</>
+										) : (
+											<>
+												<Copy className="w-3.5 h-3.5" />
+												<span>Copiar</span>
+											</>
+										)}
+									</button>
+								</div>
+							))}
+						</div>
+					</div>
+
+					{/* Versioning Semantics Callout */}
+					<div className="bg-purple-50 dark:bg-purple-950/30 rounded-2xl p-5 border border-purple-200 dark:border-purple-800/40 text-xs space-y-2">
+						<h4 className="font-bold text-purple-900 dark:text-purple-300 flex items-center gap-1.5">
+							<HelpCircle className="w-4 h-4 text-purple-600 dark:text-purple-400" />
+							<span>Regras de Versionamento Semântico no ESP-IDF</span>
+						</h4>
+						<ul className="list-disc list-inside space-y-1 text-slate-750 dark:text-slate-350">
+							<li>
+								<code>^1.2.0</code>: Permite atualizações menores e correções (ex: 1.2.1, 1.3.0),
+								mas bloqueia grandes mudanças de API (2.0.0). <strong>(Recomendado)</strong>
+							</li>
+							<li>
+								<code>~1.2.0</code>: Permite apenas correções de bugs (ex: 1.2.1, 1.2.5), travando
+								na mesma versão menor.
+							</li>
+							<li>
+								<code>1.2.0</code>: Trava na versão exata indicada, sem receber atualizações.
+							</li>
+							<li>
+								<code>*</code>: Aceita qualquer versão disponível (não recomendado para produção).
+							</li>
+						</ul>
+					</div>
+				</section>
+			</main>
+
+			<Footer />
+		</div>
+	);
+}
diff --git a/app/diagnostico/page.jsx b/app/diagnostico/page.jsx
index 48ff7e7..7400a8d 100644
--- a/app/diagnostico/page.jsx
+++ b/app/diagnostico/page.jsx
@@ -526,7 +526,11 @@ export default function DiagnosticoPage() {
 							const estaAberto = cardAberto === erro.id;
 							const lang = linguagemCodigo[erro.id] || "arduino";
 							const codigoAtual =
-								lang === "arduino" ? erro.codigoArduino : erro.codigoEspIdf;
+								lang === "arduino"
+									? erro.codigoArduino
+									: lang === "espidf"
+									? erro.codigoEspIdf
+									: erro.codigoMicroPython || "# Exemplo não aplicável";
 
 							const catInfo = categoriasDiagnostico.find(
 								(c) => c.id === erro.categoria
@@ -703,6 +707,17 @@ export default function DiagnosticoPage() {
 														>
 															ESP-IDF (C)
 														</button>
+														<button
+															type="button"
+															onClick={() => setLang(erro.id, "micropython")}
+															className={`text-xs px-3 py-1 rounded-lg font-bold transition-all cursor-pointer ${
+																lang === "micropython"
+																	? "bg-white dark:bg-slate-900 text-amber-600 dark:text-amber-400 shadow-xs"
+																	: "text-slate-600 dark:text-slate-400 hover:text-slate-900"
+															}`}
+														>
+															MicroPython
+														</button>
 													</div>
 
 													<button
diff --git a/app/frameworks/[key]/page.jsx b/app/frameworks/[key]/page.jsx
index 0338a62..03c367c 100644
--- a/app/frameworks/[key]/page.jsx
+++ b/app/frameworks/[key]/page.jsx
@@ -17,7 +17,11 @@ import {
 	FileText, 
 	Sliders,
 	Award,
-	Target
+	Target,
+	Box,
+	Sparkles,
+	ExternalLink,
+	ArrowRight
 } from "lucide-react";
 
 export default async function FrameworkDetail({ params }) {
@@ -30,6 +34,7 @@ export default async function FrameworkDetail({ params }) {
 
 	const features = framework.caracteristicas || [];
 	const useCases = framework.casos_uso || [];
+	const isEspIdf = key === "ESP-IDF";
 
 	return (
 		<div className="bg-gradient-to-br from-slate-100 via-slate-50 to-purple-100/40 dark:from-slate-950 dark:via-slate-950 dark:to-slate-900 min-h-screen text-slate-900 dark:text-slate-100 transition-colors duration-300">
@@ -51,7 +56,7 @@ export default async function FrameworkDetail({ params }) {
 
 			<Header />
 
-			<main className="px-6 pt-16 pb-24 max-w-7xl mx-auto">
+			<main className="px-4 md:px-6 pt-12 md:pt-16 pb-24 max-w-7xl mx-auto">
 				{/* Back navigation link */}
 				<div className="mb-8">
 					<Link 
@@ -112,7 +117,7 @@ export default async function FrameworkDetail({ params }) {
 							</div>
 						</div>
 
-						<p className="text-sm text-slate-500 dark:text-slate-200 mt-6 leading-relaxed max-w-4xl font-semibold">
+						<p className="text-sm text-slate-600 dark:text-slate-200 mt-6 leading-relaxed max-w-4xl font-semibold">
 							{framework.descricao}
 						</p>
 					</div>
@@ -129,7 +134,7 @@ export default async function FrameworkDetail({ params }) {
 							<span>LINGUAGEM DE DESENVOLVIMENTO</span>
 						</h3>
 						<p className="text-2xl font-extrabold text-slate-800 dark:text-slate-100">{framework.linguagem}</p>
-						<p className="text-xs text-slate-400 mt-1">Sintaxe principal do ecossistema</p>
+						<p className="text-xs text-slate-400 mt-1">Sintaxe e ecossistema</p>
 					</div>
 
 					<div 
@@ -233,9 +238,39 @@ export default async function FrameworkDetail({ params }) {
 					</div>
 				</div>
 
-				{/* Coding examples container (renders only if framework has examples defined) */}
-				{framework.exemplos && (
-					<div className="mt-12">
+				{/* Special Section: ESP Component Registry Callout for ESP-IDF */}
+				{isEspIdf && (
+					<div className="bg-gradient-to-r from-purple-900/90 to-indigo-900/90 rounded-3xl p-6 md:p-8 text-white shadow-2xl border border-purple-500/40 mb-12 relative overflow-hidden">
+						<div className="flex flex-col lg:flex-row items-start lg:items-center justify-between gap-6 relative z-10">
+							<div className="space-y-2 max-w-2xl">
+								<div className="inline-flex items-center gap-1.5 px-3 py-1 rounded-full bg-purple-500/20 border border-purple-400/30 text-purple-300 text-xs font-bold">
+									<Box className="w-3.5 h-3.5" />
+									<span>Arquitetura Moderna ESP-IDF</span>
+								</div>
+								<h3 className="text-2xl font-display font-extrabold text-white">
+									Gerenciamento Modular com ESP Component Registry
+								</h3>
+								<p className="text-xs md:text-sm text-slate-200 leading-relaxed font-medium">
+									Nos projetos ESP-IDF v4.4+ e v5.x+, as bibliotecas não precisam mais ser adicionadas como submódulos Git.
+									Utilize o <code>idf_component.yml</code> e o comando <code>idf.py add-dependency</code> para baixar automaticamente drivers de displays (LVGL), pilhas industriais (Modbus), RainMaker e mais.
+								</p>
+							</div>
+
+							<Link
+								href="/componentes"
+								className="inline-flex items-center gap-2 bg-white text-purple-900 hover:bg-slate-100 font-extrabold text-xs uppercase tracking-wider px-6 py-3.5 rounded-xl shadow-lg transition-all active:scale-95 shrink-0"
+							>
+								<Sparkles className="w-4 h-4 text-purple-600" />
+								<span>Explorar Componentes ESP-IDF</span>
+								<ArrowRight className="w-4 h-4 text-purple-600" />
+							</Link>
+						</div>
+					</div>
+				)}
+
+				{/* Coding examples container */}
+				{framework.exemplo && (
+					<div className="mt-8">
 						<CodeExample framework={framework} />
 					</div>
 				)}
@@ -283,8 +318,8 @@ export async function generateMetadata({ params }) {
 
 	return {
 		...paginaMeta({
-			titulo: `${framework.nome} para ESP32`,
-			descricao: `${framework.nome_completo}: ${framework.descricao} Guia em português com exemplo de código e quando usar.`,
+			titulo: `${framework.nome} para ESP32 · Guia Técnico`,
+			descricao: `${framework.nome_completo}: ${framework.descricao} Guia com exemplos práticos de código e casos de uso.`,
 			caminho: `/frameworks/${encodeURIComponent(key)}`,
 			tipo: "article",
 			keywords: [
diff --git a/app/frameworks/page.jsx b/app/frameworks/page.jsx
index 10aef79..366c87a 100644
--- a/app/frameworks/page.jsx
+++ b/app/frameworks/page.jsx
@@ -17,15 +17,31 @@ import {
 	Music,
 	Camera,
 	Brain,
-	Home
+	Home,
+	Box,
+	Cloud,
+	Radio,
+	ShieldCheck,
+	Mic
 } from "lucide-react";
 
-
 export const metadata = paginaMeta({
-	titulo: "Frameworks para ESP32",
-	descricao: "ESP-IDF, Arduino, MicroPython, ESP-ADF, ESP-DSP, ESP-WHO, ESP-NN e ESP-Matter: para que serve cada framework do ESP32, com exemplo de código e quando usar.",
+	titulo: "Frameworks & SDKs para ESP32: Guia Completo e Comparativo",
+	descricao: "Guia completo de desenvolvimento: ESP-IDF, ESP-RainMaker, ESP-Matter, Rust, ESP-ADF, ESP-SR, ESP-WHO, Arduino e MicroPython com exemplos de código.",
 	caminho: "/frameworks",
-	keywords: ["ESP-IDF", "Arduino ESP32", "MicroPython ESP32", "frameworks ESP32", "programar ESP32"],
+	keywords: [
+		"ESP-IDF",
+		"ESP-RainMaker",
+		"ESP-Matter",
+		"Rust ESP32",
+		"ESP-SR",
+		"ESP-ADF",
+		"ESP-IoT-Solution",
+		"Arduino ESP32",
+		"MicroPython ESP32",
+		"frameworks ESP32",
+		"programar ESP32"
+	],
 });
 
 export default function Frameworks() {
@@ -35,34 +51,70 @@ export default function Frameworks() {
 		<div className="bg-gradient-to-br from-slate-100 via-slate-50 to-purple-100/40 dark:from-slate-950 dark:via-slate-950 dark:to-slate-900 min-h-screen text-slate-900 dark:text-slate-100 transition-colors duration-300">
 			<Header />
 
-			<main id="conteudo" className="px-6 pt-16 pb-24 max-w-7xl mx-auto">
+			<main id="conteudo" className="px-4 md:px-6 pt-12 md:pt-16 pb-24 max-w-7xl mx-auto space-y-12">
 				{/* Top Hero Section */}
-				<section className="text-center mb-16 select-none">
-					<div className="inline-flex items-center gap-2 bg-white dark:bg-slate-900/50 backdrop-blur-md px-4 py-2 rounded-full mb-6 border border-slate-300 dark:border-slate-800/60 shadow-xs">
+				<section className="text-center select-none">
+					<div className="inline-flex items-center gap-2 bg-white/80 dark:bg-slate-900/60 backdrop-blur-md px-4 py-2 rounded-full mb-6 border border-slate-300 dark:border-slate-800/80 shadow-xs">
 						<Layers className="w-4 h-4 text-purple-500" />
-						<span className="text-xs font-bold text-slate-700 dark:text-slate-350 uppercase tracking-wider">Ferramentas de Desenvolvimento</span>
+						<span className="text-xs font-bold text-slate-700 dark:text-slate-350 uppercase tracking-wider">
+							Ecossistema de Desenvolvimento
+						</span>
+						<span className="bg-purple-100 dark:bg-purple-950/80 text-purple-700 dark:text-purple-300 text-[10px] font-extrabold px-2 py-0.5 rounded-full">
+							14 SDKs
+						</span>
 					</div>
 					
-					<h1 className="text-4xl md:text-6xl font-display font-extrabold bg-gradient-to-r from-blue-600 via-purple-600 to-pink-600 dark:from-blue-400 dark:via-purple-400 dark:to-pink-400 bg-clip-text text-transparent mb-6 leading-none tracking-tight">
-						Frameworks ESP32
+					<h1 className="text-4xl md:text-6xl font-display font-extrabold bg-gradient-to-r from-blue-600 via-purple-600 to-pink-600 dark:from-blue-400 dark:via-purple-400 dark:to-pink-400 bg-clip-text text-transparent mb-6 pb-2 pt-1 leading-tight md:leading-[1.18] tracking-tight">
+						Frameworks & SDKs ESP32
 					</h1>
 					
-					<p className="text-sm md:text-base text-slate-500 dark:text-slate-400 max-w-2xl mx-auto leading-relaxed font-semibold">
-						Descubra o ecossistema de software do ESP32. De desenvolvimento geral C/C++ a 
-						soluções dedicadas a áudio de alto desempenho, visão computacional na borda e IoT inteligente.
+					<p className="text-sm md:text-base text-slate-600 dark:text-slate-400 max-w-3xl mx-auto leading-relaxed font-semibold">
+						Descubra o ecossistema completo de software do ESP32. Do desenvolvimento nativo C/C++ 
+						com FreeRTOS ao ecossistema moderno em Rust, passando por nuvem IoT, reconhecimento de voz local,
+						áudio de alta fidelidade e o padrão universal Matter.
 					</p>
 				</section>
 
+				{/* Highlight Callout: ESP Component Registry */}
+				<section className="bg-gradient-to-r from-purple-900/90 via-indigo-900/90 to-slate-900/90 text-white rounded-3xl p-6 md:p-8 shadow-2xl border border-purple-500/30 relative overflow-hidden flex flex-col lg:flex-row items-start lg:items-center justify-between gap-6">
+					<div className="absolute -right-12 -top-12 w-64 h-64 bg-purple-500/10 rounded-full blur-3xl pointer-events-none" />
+					
+					<div className="space-y-2 max-w-3xl relative z-10">
+						<div className="inline-flex items-center gap-2 px-3 py-1 bg-purple-500/20 text-purple-300 text-xs font-bold rounded-full border border-purple-400/30">
+							<Box className="w-3.5 h-3.5 text-purple-300" />
+							<span>Arquitetura Modular</span>
+						</div>
+						<h2 className="text-2xl md:text-3xl font-display font-extrabold text-white">
+							ESP Component Registry & IDF Component Manager
+						</h2>
+						<p className="text-xs md:text-sm text-slate-300 leading-relaxed font-medium">
+							Desenvolva de forma modular: instale drivers de displays (LVGL), pilhas industriais (Modbus),
+							recursos de nuvem (RainMaker) e pacotes de suporte a placas (BSPs) com uma única linha no seu manifesto <code>idf_component.yml</code>.
+						</p>
+					</div>
+
+					<div className="relative z-10 shrink-0 w-full lg:w-auto">
+						<Link
+							href="/componentes"
+							className="inline-flex items-center justify-center gap-2 w-full lg:w-auto bg-gradient-to-r from-purple-500 to-pink-500 hover:from-purple-400 hover:to-pink-400 text-white font-bold text-xs uppercase tracking-wider px-6 py-3.5 rounded-2xl shadow-lg transition-all active:scale-95"
+						>
+							<Sparkles className="w-4 h-4" />
+							<span>Explorar Component Registry</span>
+							<ArrowRight className="w-4 h-4" />
+						</Link>
+					</div>
+				</section>
+
 				{/* Cards Grid */}
 				<div className="grid md:grid-cols-2 lg:grid-cols-3 gap-6">
 					{frameworks.map(([key, framework]) => (
 						<Link
 							key={key}
-							href={`/frameworks/${key}`}
+							href={`/frameworks/${encodeURIComponent(key)}`}
 							className="group flex"
 						>
 							<div 
-								className="bg-white dark:bg-slate-900/40 backdrop-blur-xl border border-slate-300 dark:border-slate-800/80 rounded-3xl shadow-lg hover:shadow-2xl transition-all duration-500 hover:-translate-y-1.5 flex flex-col justify-between overflow-hidden w-full"
+								className="bg-white dark:bg-slate-900/40 backdrop-blur-xl border border-slate-300 dark:border-slate-800/80 rounded-3xl shadow-lg hover:shadow-2xl transition-all duration-300 hover:-translate-y-1.5 flex flex-col justify-between overflow-hidden w-full"
 								style={{ borderTop: `4px solid ${framework.cor}` }}
 							>
 								
@@ -80,6 +132,9 @@ export default function Frameworks() {
 											>
 												{framework.linguagem}
 											</span>
+											<span className="text-[9px] font-bold text-slate-400 dark:text-slate-500">
+												{framework.tipo}
+											</span>
 										</div>
 									</div>
 									
@@ -104,7 +159,7 @@ export default function Frameworks() {
 												<Target className="w-3.5 h-3.5 text-blue-500" />
 												<span>Objetivo Principal</span>
 											</h4>
-											<p className="text-xs text-slate-650 dark:text-slate-200 font-medium leading-relaxed">
+											<p className="text-xs text-slate-650 dark:text-slate-200 font-medium leading-relaxed line-clamp-2">
 												{framework.funcao_principal}
 											</p>
 										</div>
@@ -153,9 +208,9 @@ export default function Frameworks() {
 				</div>
 
 				{/* Bottom Informative Cards Section */}
-				<div className="mt-16 grid md:grid-cols-2 gap-8 select-none">
+				<div className="grid md:grid-cols-3 gap-6 select-none">
 					{/* Card 1: Beginner Guide */}
-					<div className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl shadow-xl p-8 border border-slate-300 dark:border-slate-800/80 flex flex-col justify-between relative overflow-hidden">
+					<div className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl shadow-xl p-6 md:p-8 border border-slate-300 dark:border-slate-800/80 flex flex-col justify-between relative overflow-hidden">
 						<div>
 							<div className="flex items-center gap-3.5 mb-5">
 								<div className="w-12 h-12 bg-blue-500/10 border border-blue-500/20 rounded-2xl flex items-center justify-center text-blue-500">
@@ -170,32 +225,67 @@ export default function Frameworks() {
 							</div>
 							
 							<p className="text-xs text-slate-500 dark:text-slate-400 leading-relaxed mb-6 font-semibold">
-								Se você está iniciando a sua jornada de hardware, recomendamos adotar o ecossistema&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">Arduino</strong> ou&nbsp;
+								Se você está iniciando a sua jornada, o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">Arduino Core</strong> ou&nbsp;
 								<strong className="text-slate-750 dark:text-slate-300">MicroPython</strong>&nbsp;
-								para testar sensores e APIs. Para projetos profissionais industriais de alta performance e eficiência energética, o framework nativo&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">ESP-IDF</strong> é o padrão exigido no mercado.
+								são ideais para testar sensores e APIs. Para produtos comerciais, adote o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-IDF</strong> ou&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">Rust on ESP32</strong>.
 							</p>
 						</div>
 
-						<div className="flex flex-wrap gap-2.5 pt-4 border-t border-slate-200 dark:border-slate-850/40 mt-auto">
-							<Link href="/frameworks/Arduino" className="inline-flex items-center gap-1.5 px-4 py-2.5 bg-blue-500/10 text-blue-600 dark:text-blue-400 border border-blue-500/20 rounded-xl text-xs font-bold hover:bg-blue-500/20 transition-all">
+						<div className="flex flex-wrap gap-2 pt-4 border-t border-slate-200 dark:border-slate-850/40 mt-auto">
+							<Link href="/frameworks/Arduino" className="inline-flex items-center gap-1 px-3 py-2 bg-blue-500/10 text-blue-600 dark:text-blue-400 border border-blue-500/20 rounded-xl text-xs font-bold hover:bg-blue-500/20 transition-all">
 								<span>Arduino</span>
-								<ArrowRight className="w-3.5 h-3.5" />
 							</Link>
-							<Link href="/frameworks/MicroPython" className="inline-flex items-center gap-1.5 px-4 py-2.5 bg-purple-500/10 text-purple-600 dark:text-purple-400 border border-purple-500/20 rounded-xl text-xs font-bold hover:bg-purple-500/20 transition-all">
+							<Link href="/frameworks/MicroPython" className="inline-flex items-center gap-1 px-3 py-2 bg-purple-500/10 text-purple-600 dark:text-purple-400 border border-purple-500/20 rounded-xl text-xs font-bold hover:bg-purple-500/20 transition-all">
 								<span>MicroPython</span>
-								<ArrowRight className="w-3.5 h-3.5" />
 							</Link>
-							<Link href="/frameworks/ESP-IDF" className="inline-flex items-center gap-1.5 px-4 py-2.5 bg-red-500/10 text-red-600 dark:text-red-450 border border-red-500/20 rounded-xl text-xs font-bold hover:bg-red-500/20 transition-all">
-								<span>ESP-IDF</span>
-								<ArrowRight className="w-3.5 h-3.5" />
+							<Link href="/frameworks/Rust-ESP" className="inline-flex items-center gap-1 px-3 py-2 bg-amber-500/10 text-amber-600 dark:text-amber-400 border border-amber-500/20 rounded-xl text-xs font-bold hover:bg-amber-500/20 transition-all">
+								<span>Rust</span>
 							</Link>
 						</div>
 					</div>
 
-					{/* Card 2: Specialized Solutions */}
-					<div className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl shadow-xl p-8 border border-slate-300 dark:border-slate-800/80 flex flex-col justify-between relative overflow-hidden">
+					{/* Card 2: Cloud & Smart Home */}
+					<div className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl shadow-xl p-6 md:p-8 border border-slate-300 dark:border-slate-800/80 flex flex-col justify-between relative overflow-hidden">
+						<div>
+							<div className="flex items-center gap-3.5 mb-5">
+								<div className="w-12 h-12 bg-indigo-500/10 border border-indigo-500/20 rounded-2xl flex items-center justify-center text-indigo-500">
+									<Cloud className="w-6 h-6" />
+								</div>
+								<div>
+									<h3 className="text-xl font-display font-extrabold text-slate-850 dark:text-slate-100">
+										Cloud & Smart Home
+									</h3>
+									<p className="text-[10px] font-bold text-indigo-500 uppercase tracking-wider leading-none">Conectividade Avançada</p>
+								</div>
+							</div>
+							
+							<p className="text-xs text-slate-500 dark:text-slate-400 leading-relaxed mb-6 font-semibold">
+								Crie dispositivos interoperáveis com&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-Matter</strong>, implemente produtos de nuvem rápida com&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-RainMaker</strong> ou redes locais com&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-NOW</strong> e&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">Zigbee 3.0</strong>.
+							</p>
+						</div>
+
+						<div className="flex flex-wrap gap-2 pt-4 border-t border-slate-200 dark:border-slate-850/40 mt-auto">
+							<Link href="/frameworks/ESP-RainMaker" className="inline-flex items-center gap-1 px-3 py-2 bg-blue-500/10 text-blue-600 dark:text-blue-400 border border-blue-500/20 rounded-xl text-xs font-bold hover:bg-blue-500/20 transition-all">
+								<span>RainMaker</span>
+							</Link>
+							<Link href="/frameworks/ESP-Matter" className="inline-flex items-center gap-1 px-3 py-2 bg-amber-500/10 text-amber-600 dark:text-amber-400 border border-amber-500/20 rounded-xl text-xs font-bold hover:bg-amber-500/20 transition-all">
+								<span>Matter</span>
+							</Link>
+							<Link href="/frameworks/ESP-Zigbee-SDK" className="inline-flex items-center gap-1 px-3 py-2 bg-pink-500/10 text-pink-600 dark:text-pink-400 border border-pink-500/20 rounded-xl text-xs font-bold hover:bg-pink-500/20 transition-all">
+								<span>Zigbee</span>
+							</Link>
+						</div>
+					</div>
+
+					{/* Card 3: Specialized Edge AI */}
+					<div className="bg-white dark:bg-slate-900/40 backdrop-blur-xl rounded-3xl shadow-xl p-6 md:p-8 border border-slate-300 dark:border-slate-800/80 flex flex-col justify-between relative overflow-hidden">
 						<div>
 							<div className="flex items-center gap-3.5 mb-5">
 								<div className="w-12 h-12 bg-purple-500/10 border border-purple-500/20 rounded-2xl flex items-center justify-center text-purple-500">
@@ -203,38 +293,33 @@ export default function Frameworks() {
 								</div>
 								<div>
 									<h3 className="text-xl font-display font-extrabold text-slate-850 dark:text-slate-100">
-										Soluções Especializadas
+										Áudio, Voz & IA
 									</h3>
-									<p className="text-[10px] font-bold text-purple-500 uppercase tracking-wider leading-none">Domínios Avançados</p>
+									<p className="text-[10px] font-bold text-purple-500 uppercase tracking-wider leading-none">Domínios Especializados</p>
 								</div>
 							</div>
 							
 							<p className="text-xs text-slate-500 dark:text-slate-400 leading-relaxed mb-6 font-semibold">
-								Projetos complexos de IoT demandam bibliotecas altamente otimizadas na arquitetura. 
-								A Espressif fornece extensões prontas como o&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">ESP-ADF</strong> para processamento de áudio digital,&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">ESP-WHO</strong> para processamento de imagem por câmera,&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">ESP-NN</strong> para redes neurais locais e&nbsp;
-								<strong className="text-slate-750 dark:text-slate-300">ESP-Matter</strong> para automação residencial.
+								Processe áudio com o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-ADF</strong>, reconheça fala offline com o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-SR</strong>, processe vídeo com o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-WHO</strong> e acelere TinyML com o&nbsp;
+								<strong className="text-slate-750 dark:text-slate-300">ESP-NN</strong>.
 							</p>
 						</div>
 
-						<div className="flex flex-wrap gap-2.5 pt-4 border-t border-slate-200 dark:border-slate-850/40 mt-auto">
-							<Link href="/frameworks/ESP-ADF" className="inline-flex items-center gap-1.5 px-3.5 py-2 bg-slate-150/45 dark:bg-slate-850 text-slate-700 dark:text-slate-300 border border-slate-300 dark:border-slate-850/60 rounded-xl text-xs font-bold hover:bg-slate-200 dark:hover:bg-slate-800 transition-all">
-								<Music className="w-3.5 h-3.5 text-blue-500" />
+						<div className="flex flex-wrap gap-2 pt-4 border-t border-slate-200 dark:border-slate-850/40 mt-auto">
+							<Link href="/frameworks/ESP-ADF" className="inline-flex items-center gap-1 px-3 py-2 bg-blue-500/10 text-blue-600 dark:text-blue-400 border border-blue-500/20 rounded-xl text-xs font-bold hover:bg-blue-500/20 transition-all">
+								<Music className="w-3.5 h-3.5" />
 								<span>Áudio</span>
 							</Link>
-							<Link href="/frameworks/ESP-WHO" className="inline-flex items-center gap-1.5 px-3.5 py-2 bg-slate-150/45 dark:bg-slate-850 text-slate-700 dark:text-slate-300 border border-slate-300 dark:border-slate-850/60 rounded-xl text-xs font-bold hover:bg-slate-200 dark:hover:bg-slate-800 transition-all">
-								<Camera className="w-3.5 h-3.5 text-orange-500" />
-								<span>Visão</span>
+							<Link href="/frameworks/ESP-SR" className="inline-flex items-center gap-1 px-3 py-2 bg-indigo-500/10 text-indigo-600 dark:text-indigo-400 border border-indigo-500/20 rounded-xl text-xs font-bold hover:bg-indigo-500/20 transition-all">
+								<Mic className="w-3.5 h-3.5" />
+								<span>Voz</span>
 							</Link>
-							<Link href="/frameworks/ESP-NN" className="inline-flex items-center gap-1.5 px-3.5 py-2 bg-slate-150/45 dark:bg-slate-850 text-slate-700 dark:text-slate-300 border border-slate-300 dark:border-slate-850/60 rounded-xl text-xs font-bold hover:bg-slate-200 dark:hover:bg-slate-800 transition-all">
-								<Brain className="w-3.5 h-3.5 text-teal-500" />
-								<span>Inteligência Artificial</span>
-							</Link>
-							<Link href="/frameworks/ESP-Matter" className="inline-flex items-center gap-1.5 px-3.5 py-2 bg-slate-150/45 dark:bg-slate-850 text-slate-700 dark:text-slate-300 border border-slate-300 dark:border-slate-850/60 rounded-xl text-xs font-bold hover:bg-slate-200 dark:hover:bg-slate-800 transition-all">
-								<Home className="w-3.5 h-3.5 text-yellow-500" />
-								<span>Matter</span>
+							<Link href="/frameworks/ESP-NN" className="inline-flex items-center gap-1 px-3 py-2 bg-teal-500/10 text-teal-600 dark:text-teal-400 border border-teal-500/20 rounded-xl text-xs font-bold hover:bg-teal-500/20 transition-all">
+								<Brain className="w-3.5 h-3.5" />
+								<span>IA</span>
 							</Link>
 						</div>
 					</div>
diff --git a/app/page.jsx b/app/page.jsx
index 3a89c08..df1547e 100644
--- a/app/page.jsx
+++ b/app/page.jsx
@@ -21,16 +21,17 @@ import {
 	Radio,
 	ShieldCheck,
 	Code,
-	HelpCircle
+	HelpCircle,
+	Box
 } from "lucide-react";
 
 export default function Home() {
 	// Estatísticas da Plataforma
 	const stats = [
 		{ value: "12", label: "Séries Documentadas", desc: "Do ESP32 clássico ao P4 e C61" },
-		{ value: "8", label: "Frameworks & SDKs", desc: "ESP-IDF, Arduino, MicroPython, etc." },
+		{ value: "14", label: "Frameworks & SDKs", desc: "ESP-IDF, RainMaker, Rust, Matter, etc." },
+		{ value: "20+", label: "Componentes Curados", desc: "ESP Component Registry & idf_component.yml" },
 		{ value: "30+", label: "Guias de Diagnóstico", desc: "Soluções para bootloops, brownouts e WDT" },
-		{ value: "60+", label: "Termos Técnicos", desc: "Glossário completo de arquitetura e IoT" },
 	];
 
 	// Ferramentas da Plataforma (100% Clicáveis)
@@ -45,6 +46,16 @@ export default function Home() {
 			iconBg: "text-purple-600 bg-purple-50 dark:bg-purple-950/40 dark:text-purple-400",
 			ctaText: "Iniciar Quiz de Seleção",
 		},
+		{
+			title: "ESP Component Registry",
+			badge: "Oficial & Modular",
+			badgeColor: "bg-purple-100 text-purple-700 dark:bg-purple-950/60 dark:text-purple-300",
+			description: "Explore o catálogo oficial de pacotes modulares da Espressif (LVGL, RainMaker, ESP-SR, BSPs) e gere manifestos idf_component.yml.",
+			href: "/componentes",
+			icon: <Box className="w-6 h-6" />,
+			iconBg: "text-purple-600 bg-purple-50 dark:bg-purple-950/40 dark:text-purple-400",
+			ctaText: "Explorar Componentes",
+		},
 		{
 			title: "Diagnóstico de Falhas",
 			badge: "30+ Soluções",
@@ -87,9 +98,9 @@ export default function Home() {
 		},
 		{
 			title: "Frameworks & SDKs",
-			badge: "C++, Python & Rust",
+			badge: "14 Frameworks",
 			badgeColor: "bg-teal-100 text-teal-700 dark:bg-teal-950/60 dark:text-teal-300",
-			description: "Documentação de frameworks oficiais e comunitários: ESP-IDF, Arduino Core, MicroPython, ESP-Matter, ESP-WHO e mais.",
+			description: "Documentação completa de frameworks oficiais: ESP-IDF, RainMaker, Rust, Matter, ESP-SR, Arduino, MicroPython e mais.",
 			href: "/frameworks",
 			icon: <Terminal className="w-6 h-6" />,
 			iconBg: "text-teal-600 bg-teal-50 dark:bg-teal-950/40 dark:text-teal-400",
diff --git a/app/sitemap.js b/app/sitemap.js
index 34f1be1..71c90d0 100644
--- a/app/sitemap.js
+++ b/app/sitemap.js
@@ -21,6 +21,7 @@ export default function sitemap() {
 		{ caminho: "/diagnostico", prioridade: 0.9, frequencia: "weekly", lastModified: dataRevisao },
 		{ caminho: "/seletor", prioridade: 0.8, frequencia: "monthly", lastModified: dataRevisao },
 		{ caminho: "/frameworks", prioridade: 0.8, frequencia: "monthly", lastModified: dataRevisao },
+		{ caminho: "/componentes", prioridade: 0.8, frequencia: "weekly", lastModified: dataRevisao },
 		{ caminho: "/glossario", prioridade: 0.7, frequencia: "monthly", lastModified: dataRevisao },
 		{ caminho: "/catalogo", prioridade: 0.6, frequencia: "weekly", lastModified: dataRevisao },
 		{ caminho: "/sobre", prioridade: 0.4, frequencia: "yearly", lastModified: dataRevisao },
diff --git a/components/Footer.jsx b/components/Footer.jsx
index 8452537..dff5ffd 100644
--- a/components/Footer.jsx
+++ b/components/Footer.jsx
@@ -47,6 +47,14 @@ export default function Footer() {
 							Recursos
 						</h4>
 						<ul className="space-y-3 text-sm">
+							<li>
+								<Link
+									href="/componentes"
+									className="hover:text-purple-600 dark:hover:text-purple-400 transition-colors flex items-center gap-1.5 font-medium"
+								>
+									<span>ESP Component Registry</span>
+								</Link>
+							</li>
 							<li>
 								<Link
 									href="/diagnostico"
diff --git a/components/Header.jsx b/components/Header.jsx
index 383c065..90904f5 100644
--- a/components/Header.jsx
+++ b/components/Header.jsx
@@ -24,7 +24,8 @@ import {
 	ArrowRight,
 	ExternalLink,
 	Compass,
-	Layers
+	Layers,
+	Box
 } from "lucide-react";
 
 export default function Header() {
@@ -291,7 +292,7 @@ export default function Header() {
 								setToolsDropdown(false);
 							}}
 							className={`flex items-center gap-1.5 px-3 py-2 rounded-xl font-semibold text-sm transition-all duration-200 cursor-pointer ${
-								isActive("/frameworks") || isActive("/glossario") || isActive("/sobre")
+								isActive("/frameworks") || isActive("/componentes") || isActive("/glossario") || isActive("/sobre")
 									? "bg-purple-50 dark:bg-purple-950/40 text-purple-600 dark:text-purple-400"
 									: "text-slate-650 dark:text-slate-350 hover:bg-slate-100/70 dark:hover:bg-slate-800/60 hover:text-slate-850 dark:hover:text-slate-100"
 							}`}
@@ -303,7 +304,7 @@ export default function Header() {
 						</button>
 
 						{docsDropdown && (
-							<div className="absolute left-0 mt-2 w-72 bg-white dark:bg-slate-900 rounded-2xl shadow-2xl border border-slate-200 dark:border-slate-800 p-3 z-50 animate-fadeIn">
+							<div className="absolute left-0 mt-2 w-80 bg-white dark:bg-slate-900 rounded-2xl shadow-2xl border border-slate-200 dark:border-slate-800 p-3 z-50 animate-fadeIn">
 								<div className="space-y-1">
 									<Link
 										href="/frameworks"
@@ -316,7 +317,22 @@ export default function Header() {
 											<div className="font-bold text-sm text-slate-850 dark:text-slate-100 group-hover:text-purple-600 dark:group-hover:text-purple-400">
 												Frameworks & SDKs
 											</div>
-											<div className="text-xs text-slate-500 dark:text-slate-400 mt-0.5">ESP-IDF, Arduino, MicroPython e mais</div>
+											<div className="text-xs text-slate-500 dark:text-slate-400 mt-0.5">ESP-IDF, Arduino, Rust, RainMaker e mais</div>
+										</div>
+									</Link>
+
+									<Link
+										href="/componentes"
+										className="flex items-start gap-3 p-2.5 rounded-xl hover:bg-slate-100 dark:hover:bg-slate-800/70 transition-colors group"
+									>
+										<div className="p-2 rounded-lg bg-purple-50 dark:bg-purple-950/40 text-purple-600 dark:text-purple-400 shrink-0">
+											<Box className="w-4 h-4" />
+										</div>
+										<div>
+											<div className="font-bold text-sm text-slate-850 dark:text-slate-100 group-hover:text-purple-600 dark:group-hover:text-purple-400">
+												Component Registry
+											</div>
+											<div className="text-xs text-slate-500 dark:text-slate-400 mt-0.5">Catálogo de drivers e gerador idf_component.yml</div>
 										</div>
 									</Link>
 
@@ -584,6 +600,19 @@ export default function Header() {
 										<span>Frameworks & SDKs</span>
 									</Link>
 
+									<Link
+										href="/componentes"
+										onClick={() => setDrawerOpen(false)}
+										className={`flex items-center gap-2.5 p-2.5 rounded-xl font-medium text-sm transition-colors ${
+											isActive("/componentes")
+												? "bg-purple-50 dark:bg-purple-950/40 text-purple-600 dark:text-purple-400 font-bold"
+												: "text-slate-700 dark:text-slate-300 hover:bg-slate-100 dark:hover:bg-slate-800/60"
+										}`}
+									>
+										<Box className="w-4 h-4 text-purple-600 dark:text-purple-400" />
+										<span>Component Registry</span>
+									</Link>
+
 									<Link
 										href="/glossario"
 										onClick={() => setDrawerOpen(false)}
diff --git a/lib/componentRegistryData.js b/lib/componentRegistryData.js
new file mode 100644
index 0000000..6392739
--- /dev/null
+++ b/lib/componentRegistryData.js
@@ -0,0 +1,470 @@
+/**
+ * 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 e decodificadores de imagem"
+	},
+	{
+		id: "cloud_conectividade",
+		nome: "Cloud & Conectividade",
+		icone: "Cloud",
+		descricao: "ESP RainMaker, AWS IoT, MQTT, HTTP, WebSockets e coprocessamento ESP-Hosted"
+	},
+	{
+		id: "audio_voz_ia",
+		nome: "Áudio, Voz & IA",
+		icone: "Brain",
+		descricao: "Reconhecimento de fala ESP-SR, processamento DSP, codecs de áudio e aceleração 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 endereçáveis, Ethernet PHYs, USB Host e sensores I2C/SPI"
+	},
+	{
+		id: "bsp_placas",
+		nome: "BSPs (Board Support Packages)",
+		icone: "CircuitBoard",
+		descricao: "Pacotes de suporte direto para placas oficiais como ESP32-S3-BOX, Korvo, Eye e LilyGO"
+	},
+	{
+		id: "sistema_utilitarios",
+		nome: "Sistema & Utilitários",
+		icone: "Wrench",
+		descricao: "Sistemas de arquivos LittleFS/FATFS, gerenciadores de tarefas, logs e testes unitários"
+	}
+];
+
+export const COMPONENTES_REGISTRY = [
+	// 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.0.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: "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_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 câmeras em displays.",
+		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"`
+	},
+
+	// 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-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-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"`
+	},
+
+	// Á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-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"`
+	},
+
+	// 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"`
+	},
+
+	// 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-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"`
+	},
+
+	// 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"`
+	},
+
+	// 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-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"`
+	}
+];
+
+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"`
+};
diff --git a/lib/diagnosticoData.js b/lib/diagnosticoData.js
index 90f3278..6fceb01 100644
--- a/lib/diagnosticoData.js
+++ b/lib/diagnosticoData.js
@@ -1,6 +1,7 @@
 /**
  * Base de dados estruturada para o Guia de Diagnóstico, Erros Comuns e Resolução de Problemas no ESP32.
- * Abrange 6 categorias técnicas com causas raízes, comparativos de boas práticas vs gambiarras e exemplos de código.
+ * Abrange 6 categorias técnicas com causas raízes, comparativos de boas práticas vs gambiarras e exemplos de código
+ * em Arduino C++, ESP-IDF (C) e MicroPython.
  */
 
 export const categoriasDiagnostico = [
@@ -102,6 +103,26 @@ void app_main(void) {
     // Para mitigar picos em ambientes com limite de potência:
     esp_wifi_set_max_tx_power(68); // 68 = 17dBm (unidades de 0.25dBm)
 }`,
+		codigoMicroPython: `# Conexão Wi-Fi segura no MicroPython com estabilização:
+import network
+import time
+
+wlan = network.WLAN(network.STA_IF)
+wlan.active(True)
+
+# Aguarda estabilização da alimentação antes de iniciar transmissão
+time.sleep_ms(200)
+wlan.connect("SSID", "SENHA")
+
+tentativas = 0
+while not wlan.isconnected() and tentativas < 30:
+    time.sleep_ms(200)
+    tentativas += 1
+
+if wlan.isconnected():
+    print("Wi-Fi Conectado! IP:", wlan.ifconfig()[0])
+else:
+    print("[ERRO] Falha ao conectar Wi-Fi")`,
 		dicaPro: "Se estiver projetando sua própria PCB, coloque um plano de terra sólido sob o módulo e trilhas de alimentação com largura mínima de 0.5mm a 1mm para suportar os surtos de corrente sem queda resistiva (IR drop).",
 	},
 	{
@@ -139,6 +160,15 @@ void app_main(void) {
 // Se você usa ESP32 clássico e precisa liberar GPIO12, pode queimar o eFuse de 3.3V:
 // espefuse.py --port /dev/ttyUSB0 set_flash_voltage 3.3V
 // Isso desativa a amostragem de hardware no GPIO12 para sempre.`,
+		codigoMicroPython: `# Configuração correta de pinos no MicroPython:
+from machine import Pin
+
+# ✅ Pinos seguros para saídas e botões com pull-up interno:
+led = Pin(2, Pin.OUT)       # GPIO 2
+botao = Pin(4, Pin.IN, Pin.PULL_UP) # GPIO 4 (seguro)
+
+# ⚠️ Pinos 34, 35, 36, 39 são APENAS ENTRADA e não têm pull-up interno:
+sensor_analogico = Pin(36, Pin.IN) # Correto (requer resistor externo se for botão)`,
 		dicaPro: "Lembre-se sempre: pinos 'Input-Only' (GPI 34 a 39 no ESP32 clássico) não possuem circuitos de pull-up/pull-down de silício nem transistores de saída. Sensores analógicos ou botões neles exigem resistores de pull-up externos.",
 	},
 	{
@@ -190,6 +220,23 @@ esp_err_t ler_dado(char* buffer, size_t max_len) {
     // Operação segura...
     return ESP_OK;
 }`,
+		codigoMicroPython: `# Prevenção contra NoneType e exceções de objeto no MicroPython:
+import json
+
+def processar_sensor(dados_raw):
+    # Proteção defensiva contra payload nulo:
+    if dados_raw is None:
+        print("[ERRO] Dados nulos recebidos!")
+        return None
+    
+    try:
+        obj = json.loads(dados_raw)
+        # Uso seguro de .get() com valor padrão para evitar KeyError
+        temperatura = obj.get("temp", 0.0)
+        return temperatura
+    except (ValueError, AttributeError) as e:
+        print("Erro ao processar objeto:", e)
+        return None`,
 		dicaPro: "Se EXCVADDR for algo como 0x3fxxxxxx ou 0x40xxxxxx mas seu código falha, você pode estar acessando um array fora do limite (buffer overflow) que sobrescreveu ponteiros na memória.",
 	},
 	{
@@ -241,6 +288,22 @@ void app_main(void) {
     gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
     gpio_isr_handler_add(GPIO_NUM_4, gpio_isr_handler, NULL);
 }`,
+		codigoMicroPython: `# Tratamento seguro de interrupções (ISR) no MicroPython:
+import micropython
+from machine import Pin
+
+# Aloca buffer de emergência para depurar exceções dentro de ISRs:
+micropython.alloc_emergency_exception_buf(100)
+
+contador_pulsos = 0
+
+# Callback de interrupção: NÃO aloque memória (sem strings, sem floats novos)
+def tratar_pulso(pin):
+    global contador_pulsos
+    contador_pulsos += 1
+
+sensor = Pin(4, Pin.IN, Pin.PULL_UP)
+sensor.irq(trigger=Pin.IRQ_FALLING, handler=tratar_pulso)`,
 		dicaPro: "Se você passar ESP_INTR_FLAG_IRAM ao registrar a interrupção no ESP-IDF, qualquer função chamada por essa interrupção (inclusive funções do FreeRTOS) DEVE suportar IRAM (ex: xQueueSendFromISR).",
 	},
 	{
@@ -293,6 +356,27 @@ void tarefa_processamento(void *pvParameters) {
         vTaskDelay(pdMS_TO_TICKS(50));
     }
 }`,
+		codigoMicroPython: `# Watchdog e laços não-bloqueantes com uasyncio no MicroPython:
+from machine import WDT
+import uasyncio as asyncio
+
+# Inicializa o Watchdog de hardware com timeout de 5 segundos
+wdt = WDT(timeout=5000)
+
+async def tarefa_sensor():
+    while True:
+        # Alimenta o cão de guarda a cada ciclo saudável:
+        wdt.feed()
+        
+        # Cede controle para o escalonador cooperativo:
+        await asyncio.sleep_ms(100)
+
+async def main():
+    asyncio.create_task(tarefa_sensor())
+    while True:
+        await asyncio.sleep(1)
+
+asyncio.run(main())`,
 		dicaPro: "No Arduino, a função delay(ms) na verdade chama internamente o vTaskDelay do FreeRTOS. Porém, loops que usam delayMicroseconds() ou operações puras de CPU não cedem tempo e podem disparar o TWDT se durarem mais de alguns segundos.",
 	},
 	{
@@ -339,6 +423,17 @@ void setup() {
 		codigoEspIdf: `// Habilite a checagem dupla de Stack no menuconfig:
 // Component config -> FreeRTOS -> Set a end of stack check -> Option 2 (Check by Stack Canary)
 // Isso detecta o estouro ANTES que dados sejam corrompidos em tempo de execução.`,
+		codigoMicroPython: `# Monitoramento de memória e pilha no MicroPython:
+import gc
+import micropython
+
+# Exibe estatísticas de memória RAM e pilha da VM do Python:
+micropython.mem_info()
+
+# Executa garbage collector para liberar blocos órfãos:
+gc.collect()
+print("Memória Heap Livre:", gc.mem_free(), "bytes")
+print("Memória Heap Alocada:", gc.mem_alloc(), "bytes")`,
 		dicaPro: "Se a sua função precisa processar um JSON ou pacote HTTP esporadicamente, aloque o buffer no Heap apenas durante o processamento e libere-o logo em seguida, em vez de inflar o Stack permanente da tarefa.",
 	},
 	{
@@ -387,6 +482,23 @@ void inspecionar_memoria(void) {
     
     ESP_LOGI("HEAP", "Total livre: %d bytes | Maior bloco continuo: %d bytes", livre_total, maior_bloco);
 }`,
+		codigoMicroPython: `# Prevenção de fragmentação de Heap no MicroPython:
+import gc
+
+# 1. Habilita coleta automática
+gc.enable()
+
+# 2. Pré-aloque bytearrays para reaproveitamento em vez de criar novas strings:
+buffer_leitura = bytearray(256)
+
+def ler_sensor_sem_alocacao(stream):
+    # Lê reutilizando o mesmo espaço em memória (Zero-Allocation):
+    bytes_lidos = stream.readinto(buffer_leitura)
+    return buffer_leitura[:bytes_lidos]
+
+# 3. Dispare o GC antes de abrir conexões pesadas (como HTTPS / TLS):
+gc.collect()
+print(f"Heap Livre: {gc.mem_free()} B | Alocado: {gc.mem_alloc()} B")`,
 		dicaPro: "Se o maior bloco contíguo livre for menor que 35KB ~ 40KB, conexões HTTPS/TLS modernas falharão durante o handshake de certificados.",
 	},
 	{
@@ -431,6 +543,15 @@ void setup() {
 uint8_t* alocar_buffer_spi(size_t len) {
     return (uint8_t*) heap_caps_aligned_alloc(4, len, MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
 }`,
+		codigoMicroPython: `# No MicroPython, verifique a memória PSRAM disponível:
+import gc
+import esp32
+
+# Se o firmware foi compilado com suporte a SPIRAM (ex: firmwares com 'SPIRAM'):
+print("Memória total acessível no MicroPython:", gc.mem_free() + gc.mem_alloc(), "bytes")
+
+# Para operações rápidas com periféricos, use bytearrays contíguos:
+buffer_spi = bytearray(1024)`,
 		dicaPro: "No ESP32-P4, a arquitetura avançada de barramento AXI permite DMA em certas regiões externas, mas para toda a linha ESP32/S2/S3/C3 a regra da SRAM interna é estrita.",
 	},
 	{
@@ -463,6 +584,12 @@ uint8_t* alocar_buffer_spi(size_t len) {
 // idf.py -p /dev/ttyUSB0 -b 460800 flash
 // Se o upload falhar em altas velocidades, reduza a taxa de baud rate para 115200:
 // idf.py -p /dev/ttyUSB0 -b 115200 flash`,
+		codigoMicroPython: `# Gravação do firmware MicroPython oficial no ESP32 via terminal:
+# 1. Apague a memória Flash:
+# esptool.py --port /dev/ttyUSB0 erase_flash
+
+# 2. Grave o binário com taxa de baud segura:
+# esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-*.bin`,
 		dicaPro: "Se estiver usando módulos ESP32-S3 ou C3 com USB nativo (Direct USB-JTAG), certifique-se de que a porta correta selecionada é a porta CDC/JTAG e não a UART legada.",
 	},
 	{
@@ -518,6 +645,24 @@ void inicializar_sntp(void) {
     
     // Aguarda sincronização do relógio...
 }`,
+		codigoMicroPython: `# Sincronização SNTP e requisições HTTPS no MicroPython:
+import ntptime
+import time
+import urequests
+
+def sincronizar_e_requisitar():
+    try:
+        print("Sincronizando relógio via NTP...")
+        ntptime.host = "pool.ntp.br"
+        ntptime.settime() # Atualiza o RTC interno do ESP32 via NTP
+        print("Hora sincronizada UTC:", time.localtime())
+        
+        # Agora o handshake TLS validará o certificado sem o erro -0x2700:
+        resposta = urequests.get("https://api.github.com")
+        print("Resposta HTTPS:", resposta.status_code)
+        resposta.close()
+    except Exception as e:
+        print("[ERRO TLS/NTP]:", e)`,
 		dicaPro: "Se seu projeto opera em ambientes sem acesso à internet externa (rede local isolada), configure um servidor NTP local no roteador ou adicione um módulo RTC físico como o DS3231 via I2C.",
 	},
 ];
@@ -584,7 +729,7 @@ export const regrasDecodificadorLog = [
 		explicacao:
 			"O ESP32 tentou autenticar um certificado HTTPS/TLS com a data zerada na época Unix (01/01/1970).",
 		acaoRecomendada:
-			"Sincronize o horário via SNTP (`configTime`) antes de iniciar requisições HTTPS seguras.",
+			"Sincronize o horário via SNTP (`configTime` no Arduino ou `ntptime.settime()` no MicroPython) antes de iniciar requisições HTTPS seguras.",
 	},
 	{
 		padrao: /rst:0x1 \(POWERON_RESET\),boot:0x[0-9a-fA-F]+/i,
diff --git a/public/exemplos/esp-idf.c b/public/exemplos/esp-idf.c
index fdccda2..c58de73 100644
--- a/public/exemplos/esp-idf.c
+++ b/public/exemplos/esp-idf.c
@@ -1,25 +1,56 @@
+/*
+ * Exemplo ESP-IDF v5.x+ para ESP32
+ * Demonstração de inicialização do sistema, gerenciamento de tarefas FreeRTOS e log unificado
+ * 
+ * Gerenciamento de componentes (main/idf_component.yml):
+ *   dependencies:
+ *     espressif/led_strip: "^2.5.0"
+ */
+
 #include <stdio.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "driver/gpio.h"
+#include "esp_log.h"
+#include "esp_system.h"
+#include "esp_chip_info.h"
 
-#define LED_PIN GPIO_NUM_2  // LED onboard (ajuste conforme sua placa)
+static const char *TAG = "main_app";
+
+#define BLINK_GPIO  GPIO_NUM_2  // Ajuste conforme o pino do LED da sua placa
+
+static void blink_task(void *pvParameters)
+{
+    // Configura o pino GPIO com a nova API do ESP-IDF
+    gpio_reset_pin(BLINK_GPIO);
+    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
+
+    bool led_state = false;
+
+    while (1) {
+        led_state = !led_state;
+        gpio_set_level(BLINK_GPIO, led_state);
+        
+        ESP_LOGI(TAG, "LED %s | Heap livre: %lu bytes", 
+                 led_state ? "LIGADO" : "DESLIGADO", 
+                 (unsigned long)esp_get_free_heap_size());
+                 
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
 
 void app_main(void)
 {
-    // Configura o pino do LED como saída
-    gpio_reset_pin(LED_PIN);
-    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
+    // Informações do chip SoC
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
 
-    while (1) {
-        // Liga o LED
-        gpio_set_level(LED_PIN, 1);
-        printf("LED ON\n");
-        vTaskDelay(pdMS_TO_TICKS(1000));  // Espera 1 segundo
+    ESP_LOGI(TAG, "===========================================");
+    ESP_LOGI(TAG, "  Iniciando ESP-IDF v5.x Modern Application ");
+    ESP_LOGI(TAG, "  Modelo do Chip: %d | Núcleos: %d | Rev: %d", 
+             chip_info.model, chip_info.cores, chip_info.revision);
+    ESP_LOGI(TAG, "===========================================");
 
-        // Desliga o LED
-        gpio_set_level(LED_PIN, 0);
-        printf("LED OFF\n");
-        vTaskDelay(pdMS_TO_TICKS(1000));  // Espera 1 segundo
-    }
+    // Cria uma tarefa FreeRTOS dedicada
+    xTaskCreate(blink_task, "blink_task", 3072, NULL, 5, NULL);
 }
diff --git a/public/exemplos/esp-iot-solution.c b/public/exemplos/esp-iot-solution.c
new file mode 100644
index 0000000..2285010
--- /dev/null
+++ b/public/exemplos/esp-iot-solution.c
@@ -0,0 +1,72 @@
+/*
+ * Exemplo ESP-IoT-Solution para ESP32
+ * Inicialização de Botão Inteligente com Callbacks e Driver de Display/Sensores
+ * 
+ * Dependência (idf_component.yml):
+ *   espressif/button: "^3.3.0"
+ *   espressif/led_indicator: "^1.2.0"
+ */
+
+#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "iot_button.h"
+#include "led_indicator.h"
+
+static const char *TAG = "iot_solution_app";
+
+#define BUTTON_GPIO_NUM       0   // Botão BOOT nativo
+#define LED_INDICATOR_GPIO    2   // LED indicador
+
+static led_indicator_handle_t led_handle = NULL;
+
+/* Callback para clique único do botão */
+static void button_single_click_cb(void *arg, void *data)
+{
+    ESP_LOGI(TAG, "Evento: Clique Único detectado!");
+    led_indicator_start(led_handle, BLINK_DOUBLE_FAST);
+}
+
+/* Callback para clique longo (> 3 segundos) */
+static void button_long_press_cb(void *arg, void *data)
+{
+    ESP_LOGW(TAG, "Evento: Pressionamento Longo! Acionando modo de reset de fábrica.");
+    led_indicator_start(led_handle, BLINK_BREATHE_FAST);
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "Iniciando ESP-IoT-Solution Component Suite");
+
+    // 1. Configuração do LED Indicator
+    led_indicator_gpio_config_t led_cfg = {
+        .is_active_level_high = true,
+        .gpio_num = LED_INDICATOR_GPIO,
+    };
+    led_handle = led_indicator_create(&led_cfg);
+
+    // 2. Configuração do Botão com debounce de hardware/software automático
+    button_config_t btn_cfg = {
+        .type = BUTTON_TYPE_GPIO,
+        .long_press_time = 3000,
+        .short_press_time = 180,
+        .gpio_button_config = {
+            .gpio_num = BUTTON_GPIO_NUM,
+            .active_level = 0,
+        },
+    };
+
+    button_handle_t btn_handle = iot_button_create(&btn_cfg);
+    assert(btn_handle != NULL);
+
+    // Registra callbacks para diferentes gestos
+    iot_button_register_cb(btn_handle, BUTTON_SINGLE_CLICK, button_single_click_cb, NULL);
+    iot_button_register_cb(btn_handle, BUTTON_LONG_PRESS_START, button_long_press_cb, NULL);
+
+    ESP_LOGI(TAG, "Drivers inicializados com sucesso! Pressione o botão GPIO 0.");
+
+    while (1) {
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
diff --git a/public/exemplos/esp-now.c b/public/exemplos/esp-now.c
new file mode 100644
index 0000000..ddfab5b
--- /dev/null
+++ b/public/exemplos/esp-now.c
@@ -0,0 +1,92 @@
+/*
+ * Exemplo ESP-NOW para ESP32
+ * Comunicação Sem Fio Ponto-a-Ponto e Broadcast sem roteador Wi-Fi
+ * 
+ * Protocolo nativo integrado no ESP-IDF
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_wifi.h"
+#include "esp_now.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+
+static const char *TAG = "esp_now_demo";
+
+// Estrutura de dados enviada no pacote
+typedef struct {
+    uint32_t sensor_id;
+    float temperatura;
+    float umidade;
+    uint32_t tempo_ms;
+} __attribute__((packed)) dados_pacote_t;
+
+// Endereço MAC de Broadcast (envia para todos os nós ESP-NOW por perto)
+static const uint8_t broadcast_mac[ESP_NOW_ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+/* Callback executado ao enviar um pacote */
+static void on_data_sent(const uint8_t *mac_addr, esp_now_send_status_t status)
+{
+    ESP_LOGI(TAG, "Envio concluído: %s", status == ESP_NOW_SEND_SUCCESS ? "SUCESSO (ACK)" : "FALHA");
+}
+
+/* Callback executado ao receber um pacote de outro ESP32 */
+static void on_data_recv(const esp_now_recv_info_t *recv_info, const uint8_t *data, int len)
+{
+    if (len == sizeof(dados_pacote_t)) {
+        dados_pacote_t *pct = (dados_pacote_t *)data;
+        ESP_LOGI(TAG, "Pacote recebido de [%02X:%02X:%02X:%02X:%02X:%02X]: Sensor #%ld | Temp: %.1f C | Umid: %.1f %%",
+                 recv_info->src_addr[0], recv_info->src_addr[1], recv_info->src_addr[2],
+                 recv_info->src_addr[3], recv_info->src_addr[4], recv_info->src_addr[5],
+                 pct->sensor_id, pct->temperatura, pct->umidade);
+    }
+}
+
+void app_main(void)
+{
+    // Inicializa NVS e Wi-Fi em modo Station
+    nvs_flash_init();
+    esp_netif_init();
+    esp_event_loop_create_default();
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    esp_wifi_init(&cfg);
+    esp_wifi_set_mode(WIFI_MODE_STA);
+    esp_wifi_start();
+
+    // Inicializa o protocolo ESP-NOW
+    ESP_ERROR_CHECK(esp_now_init());
+    esp_now_register_send_cb(on_data_sent);
+    esp_now_register_recv_cb(on_data_recv);
+
+    // Registra o peer de Broadcast
+    esp_now_peer_info_t peer_info = {
+        .channel = 1,
+        .ifidx = WIFI_IF_STA,
+        .encrypt = false,
+    };
+    memcpy(peer_info.peer_addr, broadcast_mac, ESP_NOW_ETH_ALEN);
+    ESP_ERROR_CHECK(esp_now_add_peer(&peer_info));
+
+    ESP_LOGI(TAG, "ESP-NOW pronto! Enviando telemetria a cada 3 segundos...");
+
+    dados_pacote_t telemetria = {
+        .sensor_id = 101,
+        .temperatura = 24.8f,
+        .umidade = 58.2f,
+    };
+
+    while (1) {
+        telemetria.tempo_ms = esp_log_timestamp();
+        telemetria.temperatura += ((float)(rand() % 10) - 5.0f) / 10.0f;
+
+        esp_err_t res = esp_now_send(broadcast_mac, (uint8_t *)&telemetria, sizeof(telemetria));
+        if (res != ESP_OK) {
+            ESP_LOGE(TAG, "Erro ao disparar envio ESP-NOW: %d", res);
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(3000));
+    }
+}
diff --git a/public/exemplos/esp-rainmaker.c b/public/exemplos/esp-rainmaker.c
new file mode 100644
index 0000000..19bdf01
--- /dev/null
+++ b/public/exemplos/esp-rainmaker.c
@@ -0,0 +1,76 @@
+/*
+ * Exemplo ESP-RainMaker para ESP32
+ * Dispositivo: Interruptor Inteligente com controle via App e Nuvem
+ * 
+ * Dependência (idf_component.yml):
+ *   espressif/esp_rainmaker: "^1.4.0"
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+
+#include <esp_rmaker_core.h>
+#include <esp_rmaker_standard_params.h>
+#include <esp_rmaker_standard_devices.h>
+#include <app_wifi.h>
+
+static const char *TAG = "app_rainmaker";
+static esp_rmaker_device_t *switch_device;
+
+/* Callback acionado quando o usuário altera o estado no App móvel */
+static esp_err_t write_cb(const esp_rmaker_device_t *dev, const esp_rmaker_param_val_t val, void *priv_data, esp_rmaker_write_ctx_t *ctx)
+{
+    if (ctx) {
+        ESP_LOGI(TAG, "Comando recebido via %s", esp_rmaker_device_cb_src_to_str(ctx->src));
+    }
+    
+    bool state = val.val.b;
+    ESP_LOGI(TAG, "Estado do interruptor alterado para: %s", state ? "LIGADO" : "DESLIGADO");
+    
+    // Atualiza o parâmetro na nuvem e no aplicativo
+    esp_rmaker_param_update_and_report(priv_data, val);
+    return ESP_OK;
+}
+
+void app_main(void)
+{
+    // Inicialização da memória não-volátil (NVS)
+    esp_err_t err = nvs_flash_init();
+    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
+        ESP_ERROR_CHECK(nvs_flash_erase());
+        err = nvs_flash_init();
+    }
+    ESP_ERROR_CHECK(err);
+
+    // Inicializa o provisionamento Wi-Fi
+    app_wifi_init();
+
+    // Configura o nó RainMaker
+    esp_rmaker_config_t rainmaker_cfg = {
+        .enable_time_sync = true,
+    };
+    esp_rmaker_node_t *node = esp_rmaker_node_init(&rainmaker_cfg, "ESP32_SmartSwitch", "Switch");
+    
+    // Cria o dispositivo padrão 'Switch'
+    switch_device = esp_rmaker_switch_device_create("Luz Sala", NULL, true);
+    
+    // Registra callback de escrita
+    esp_rmaker_device_add_cb(switch_device, write_cb, NULL);
+    esp_rmaker_node_add_device(node, switch_device);
+
+    // Habilita serviços adicionais (OTA e Timezone)
+    esp_rmaker_ota_enable_default();
+    esp_rmaker_timezone_service_enable();
+
+    // Inicia o agente RainMaker
+    esp_rmaker_start();
+
+    // Inicia o provisionamento Wi-Fi via BLE (abre no app oficial RainMaker)
+    app_wifi_start(POP_TYPE_RANDOM);
+
+    ESP_LOGI(TAG, "Nó RainMaker pronto! Escaneie o QR Code no app ESP RainMaker.");
+}
diff --git a/public/exemplos/esp-sr.c b/public/exemplos/esp-sr.c
new file mode 100644
index 0000000..a4cd9a1
--- /dev/null
+++ b/public/exemplos/esp-sr.c
@@ -0,0 +1,98 @@
+/*
+ * Exemplo ESP-SR para ESP32-S3 / ESP32-P4
+ * Reconhecimento de Fala Local Offline (WakeNet + MultiNet)
+ * 
+ * Dependência (idf_component.yml):
+ *   espressif/esp-sr: "^1.5.0"
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_wn_iface.h"
+#include "esp_wn_models.h"
+#include "esp_mn_iface.h"
+#include "esp_mn_models.h"
+#include "esp_afe_sr_iface.h"
+#include "esp_afe_sr_models.h"
+
+static const char *TAG = "app_voice_sr";
+
+void feed_audio_task(void *arg)
+{
+    esp_afe_sr_data_t *afe_data = (esp_afe_sr_data_t *)arg;
+    int audio_chunksize = afe_handle->get_feed_chunksize(afe_data);
+    int16_t *feed_buff = (int16_t *)malloc(audio_chunksize * sizeof(int16_t) * 2);
+
+    while (1) {
+        // Leitura de áudio I2S dos microfones da placa
+        // i2s_read(I2S_NUM_0, feed_buff, ...);
+        
+        afe_handle->feed(afe_data, feed_buff);
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    free(feed_buff);
+    vTaskDelete(NULL);
+}
+
+void speech_recognition_task(void *arg)
+{
+    esp_afe_sr_data_t *afe_data = (esp_afe_sr_data_t *)arg;
+    const esp_afe_sr_iface_t *afe_handle = &ESP_AFE_SR_HANDLE;
+
+    // Inicializa o modelo de comandos de fala (MultiNet)
+    const esp_mn_iface_t *multinet = &ESP_MN_HANDLE;
+    model_iface_data_t *model_data = multinet->create(&MULTINET_MODEL, 6000);
+
+    ESP_LOGI(TAG, "Aguardando palavra-chave de ativação (ex: 'Hi, ESP')...");
+
+    while (1) {
+        afe_fetch_result_t *res = afe_handle->fetch(afe_data);
+        if (!res || res->ret_value == ESP_FAIL) {
+            continue;
+        }
+
+        // 1. Verificação de Wake Word (Palavra de ativação)
+        if (res->wake_word_detected == WAKENET_DETECTED) {
+            ESP_LOGW(TAG, ">>> PALAVRA-CHAVE DETECTADA! Canal de escuta aberto.");
+        }
+
+        // 2. Reconhecimento de comando local
+        if (res->raw_data_size > 0) {
+            esp_mn_state_t mn_state = multinet->detect(model_data, res->data);
+            
+            if (mn_state == ESP_MN_STATE_DETECTED) {
+                esp_mn_results_t *mn_res = multinet->get_results(model_data);
+                ESP_LOGI(TAG, ">>> COMANDO RECONHECIDO: ID #%d (Frase correspondente)", mn_res->command_id[0]);
+                
+                // Exemplo de ação
+                if (mn_res->command_id[0] == 1) {
+                    ESP_LOGI(TAG, "Ação: Ligar Luz da Sala");
+                } else if (mn_res->command_id[0] == 2) {
+                    ESP_LOGI(TAG, "Ação: Desligar Luz da Sala");
+                }
+            } else if (mn_state == ESP_MN_STATE_TIMEOUT) {
+                ESP_LOGI(TAG, "Tempo esgotado. Retornando ao modo de escuta de Wake Word.");
+            }
+        }
+    }
+    vTaskDelete(NULL);
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "Iniciando ESP-SR Speech Recognition Engine");
+
+    // Configura o pipeline de Audio Front-End (AEC, BSS, VAD, WakeNet)
+    afe_config_t afe_config = AFE_CONFIG_DEFAULT();
+    afe_config.wakenet_init = true;
+    afe_config.voice_communication_init = false;
+
+    esp_afe_sr_data_t *afe_data = ESP_AFE_SR_HANDLE.create_from_config(&afe_config);
+
+    // Cria as tarefas de alimentação de áudio e reconhecimento
+    xTaskCreatePinnedToCore(feed_audio_task, "feed_task", 4096, afe_data, 5, NULL, 0);
+    xTaskCreatePinnedToCore(speech_recognition_task, "sr_task", 8192, afe_data, 5, NULL, 1);
+}
diff --git a/public/exemplos/esp-zigbee.c b/public/exemplos/esp-zigbee.c
new file mode 100644
index 0000000..a3e5bb6
--- /dev/null
+++ b/public/exemplos/esp-zigbee.c
@@ -0,0 +1,97 @@
+/*
+ * Exemplo ESP-Zigbee-SDK para ESP32-H2 e ESP32-C6 (IEEE 802.15.4)
+ * Dispositivo: Lâmpada Inteligente Zigbee 3.0 (Home Automation End Device)
+ * 
+ * Dependência (idf_component.yml):
+ *   espressif/esp-zigbee-lib: "^1.6.0"
+ */
+
+#include <stdio.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "esp_zigbee_core.h"
+
+static const char *TAG = "zigbee_light_device";
+
+#define HA_ESP_LIGHT_ENDPOINT  1
+#define ESP_ZB_PRIMARY_CHANNEL_MASK (1l << 15) // Canal 15 padrão Zigbee
+
+/* Callback de escrita em atributos Zigbee (ex: Liga/Desliga via Home Assistant) */
+static esp_err_t zb_attribute_handler(const esp_zb_zcl_set_attr_value_message_t *message)
+{
+    if (message->info.cluster == ESP_ZB_ZCL_CLUSTER_ID_ON_OFF) {
+        if (message->attribute.id == ESP_ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID &&
+            message->attribute.data.type == ESP_ZB_ZCL_ATTR_TYPE_BOOL) {
+            bool on_off_state = message->attribute.data.value ? *(bool *)message->attribute.data.value : false;
+            ESP_LOGW(TAG, ">>> COMANDO ZIGBEE RECEBIDO: Lâmpada %s", on_off_state ? "LIGADA" : "DESLIGADA");
+        }
+    }
+    return ESP_OK;
+}
+
+/* Callback de eventos da pilha Zigbee */
+void esp_zb_app_signal_handler(esp_zb_app_signal_msg_t *signal_msg)
+{
+    uint32_t *p_sg_p = signal_msg->p_app_signal;
+    esp_err_t err_status = signal_msg->esp_err_status;
+    esp_zb_app_signal_type_t sig_type = *p_sg_p;
+
+    switch (sig_type) {
+    case ESP_ZB_ZDO_SIGNAL_SKIP_STARTUP:
+        ESP_LOGI(TAG, "Iniciando comissionamento na rede Zigbee...");
+        esp_zb_bdb_start_top_level_commissioning(ESP_ZB_BDB_MODE_NETWORK_STEERING);
+        break;
+    case ESP_ZB_BDB_SIGNAL_STEERING:
+        if (err_status == ESP_OK) {
+            ESP_LOGI(TAG, "Conectado com sucesso à rede Zigbee 3.0!");
+        } else {
+            ESP_LOGW(TAG, "Buscando coordenador Zigbee novamente...");
+            esp_zb_scheduler_alarm((esp_zb_callback_t)esp_zb_bdb_start_top_level_commissioning, ESP_ZB_BDB_MODE_NETWORK_STEERING, 1000);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+static void esp_zb_task(void *pvParameters)
+{
+    // Configura nó Zigbee como End Device
+    esp_zb_cfg_t zb_nwk_cfg = {
+        .esp_zb_role = ESP_ZB_DEVICE_TYPE_ED,
+        .install_code_policy = false,
+        .nwk_cfg.zed_cfg = {
+            .ed_timeout = ESP_ZB_ED_0_5_MIN,
+            .keep_alive = 3000,
+        },
+    };
+    esp_zb_init(&zb_nwk_cfg);
+
+    // Cria o cluster de On/Off de iluminação residencial
+    esp_zb_on_off_light_cfg_t light_cfg = ESP_ZB_DEFAULT_ON_OFF_LIGHT_CONFIG();
+    esp_zb_ep_list_t *ep_list = esp_zb_on_off_light_ep_create(HA_ESP_LIGHT_ENDPOINT, &light_cfg);
+
+    // Registra endpoint e manipulador de atributos
+    esp_zb_device_register(ep_list);
+    esp_zb_core_action_handler_register(zb_attribute_handler);
+
+    esp_zb_set_primary_network_channel_set(ESP_ZB_PRIMARY_CHANNEL_MASK);
+    ESP_ERROR_CHECK(esp_zb_start(false));
+    esp_zb_main_loop_iteration();
+}
+
+void app_main(void)
+{
+    ESP_ERROR_CHECK(nvs_flash_init());
+    
+    // Inicializa a pilha de rádio IEEE 802.15.4
+    esp_zb_platform_config_t config = {
+        .radio_config = { .radio_mode = ZB_RADIO_MODE_NATIVE },
+        .host_config = { .host_connection_mode = ZB_HOST_CONNECTION_MODE_NONE },
+    };
+    ESP_ERROR_CHECK(esp_zb_platform_config(&config));
+
+    xTaskCreate(esp_zb_task, "Zigbee_main", 4096, NULL, 5, NULL);
+}
diff --git a/public/exemplos/rust-esp.rs b/public/exemplos/rust-esp.rs
new file mode 100644
index 0000000..17288c3
--- /dev/null
+++ b/public/exemplos/rust-esp.rs
@@ -0,0 +1,48 @@
+//! Exemplo Rust no ESP32 usando `esp-hal` (Modo Bare-Metal / no_std)
+//! Pisca um LED e envia mensagens via UART Serial com segurança de memória garantida.
+//!
+//! Cargo.toml:
+//!   esp-hal = { version = "0.22", features = ["esp32s3"] }
+//!   esp-println = { version = "0.12", features = ["esp32s3", "log"] }
+
+#![no_std]
+#![no_main]
+
+use esp_backtrace as _;
+use esp_hal::{
+    clock::ClockControl,
+    gpio::{Io, Level, Output},
+    peripherals::Peripherals,
+    system::SystemControl,
+    timer::timg::TimerGroup,
+    delay::Delay,
+    prelude::*,
+};
+use esp_println::println;
+
+#[entry]
+fn main() -> ! {
+    // Inicializa periféricos do SoC com verificação em tempo de compilação
+    let peripherals = Peripherals::take();
+    let system = SystemControl::new(peripherals.SYSTEM);
+    let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
+
+    // Configura os pinos de E/S
+    let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
+    let mut led = Output::new(io.pins.gpio2, Level::Low);
+
+    let delay = Delay::new(&clocks);
+
+    println!("🦀 Firmware Rust Bare-Metal inicializado no ESP32!");
+
+    let mut counter: u32 = 0;
+
+    loop {
+        // Inverte estado do LED com garantia de exclusão mútua
+        led.toggle();
+        counter += 1;
+
+        println!("Ciclo Rust #{}: LED está {:?}", counter, led.is_set_high());
+        delay.delay_millis(500);
+    }
+}
diff --git a/public/frameworks.json b/public/frameworks.json
index afcd498..d97f6a1 100644
--- a/public/frameworks.json
+++ b/public/frameworks.json
@@ -3,214 +3,364 @@
         "nome": "ESP-IDF",
         "icone": "⚙️",
         "nome_completo": "Espressif IoT Development Framework",
-        "descricao": "Framework oficial de desenvolvimento da Espressif para ESP32, baseado em FreeRTOS",
-        "linguagem": "C/C++",
-        "tipo": "Framework Base",
-        "funcao_principal": "Desenvolvimento de aplicações IoT de propósito geral com acesso completo ao hardware",
+        "descricao": "Framework oficial nativo da Espressif para todos os SoCs ESP32. Baseado em FreeRTOS multicore e CMake, oferece controle total do silício, periféricos, rádio e arquitetura de componentes modulares.",
+        "linguagem": "C / C++",
+        "tipo": "Framework Base Oficial",
+        "funcao_principal": "Desenvolvimento industrial e de alta performance com acesso direto aos registradores, RTOS em tempo real e pilha completa de protocolos",
         "caracteristicas": [
-            "Sistema operacional em tempo real (FreeRTOS)",
-            "Pilha completa de Wi-Fi e Bluetooth",
-            "Suporte a todos os periféricos do ESP32",
-            "Ferramentas de build e debug integradas",
-            "Gerenciamento de energia avançado",
-            "Suporte OTA (Over-The-Air updates)",
-            "Biblioteca de componentes extensível"
+            "Sistema operacional de tempo real (FreeRTOS SMP multicore)",
+            "Suporte nativo ao ESP Component Registry via idf_component.yml",
+            "Pilha completa de conectividade Wi-Fi 4/6, BLE 5.x, Zigbee e Thread",
+            "Suporte a todos os SoCs (ESP32, S2, S3, C2, C3, C6, H2, P4)",
+            "Gerenciamento avançado de energia e modos Deep Sleep",
+            "Segurança robusta: Secure Boot v2, Flash Encryption e Crypto HW",
+            "Atualizações OTA criptografadas com rollback automático",
+            "Toolchain moderna Clang/GCC, suporte a C++23 e debug via JTAG OpenOCD"
         ],
         "casos_uso": [
-            "Dispositivos IoT conectados",
-            "Automação residencial e industrial",
-            "Wearables e dispositivos vestíveis",
-            "Gateways e hubs de comunicação",
-            "Sistemas embarcados em tempo real"
+            "Produtos comerciais e industriais de IoT",
+            "Dispositivos com requisitos rigorosos de bateria e consumo",
+            "Aplicações em tempo real com controle de interrupções",
+            "Sistemas de segurança com criptografia de hardware",
+            "Gateways multiprotocolo de alto desempenho"
         ],
         "exemplo": "/exemplos/esp-idf.c",
         "exemplos": "https://github.com/espressif/esp-idf/tree/master/examples",
-        "documentacao": "https://docs.espressif.com/projects/esp-idf/",
+        "documentacao": "https://docs.espressif.com/projects/esp-idf/en/latest/",
         "repositorio": "https://github.com/espressif/esp-idf",
         "cor": "#E74C3C"
     },
-    "ESP-ADF": {
-        "nome": "ESP-ADF",
-        "icone": "🎵",
-        "nome_completo": "ESP Audio Development Framework",
-        "descricao": "Framework especializado para aplicações de áudio no ESP32",
-        "linguagem": "C/C++",
-        "tipo": "Framework Especializado",
-        "funcao_principal": "Desenvolvimento de aplicações de áudio com suporte a codecs, streaming e processamento",
+    "ESP-RainMaker": {
+        "nome": "ESP-RainMaker",
+        "icone": "☁️",
+        "nome_completo": "ESP RainMaker AIoT Cloud Platform",
+        "descricao": "Plataforma completa de nuvem e firmware da Espressif para produtos conectados. Permite criar dispositivos IoT sem precisar desenvolver backend ou aplicativos móveis do zero.",
+        "linguagem": "C / C++",
+        "tipo": "Cloud & AIoT Framework",
+        "funcao_principal": "Construção acelerada de produtos inteligentes com aplicativo móvel (iOS/Android), nuvem AWS Serverless e controle por voz (Alexa/Google Home)",
         "caracteristicas": [
-            "Suporte a múltiplos codecs de áudio (MP3, AAC, FLAC, WAV, etc.)",
-            "Pipeline de áudio configurável",
-            "Streaming de áudio via HTTP, HTTPS, HLS",
-            "Integração com serviços de nuvem (AWS, Google, Baidu)",
-            "Reconhecimento de voz e wake word",
-            "Equalização e efeitos de áudio",
-            "Suporte a Bluetooth A2DP e HFP"
+            "Provisionamento Wi-Fi e BLE assistido via aplicativo oficial",
+            "Geração dinâmica de interface no app com base nos parâmetros do firmware",
+            "Integração nativa com Amazon Alexa e Google Assistant",
+            "Suporte a controle local (Local Control via mDNS/HTTP) e nuvem simultâneos",
+            "Painel administrativo (RainMaker Dashboard) para gerenciamento de frotas e OTA",
+            "Compatibilidade nativa com nós Matter e Bridge de dispositivos",
+            "Biblioteca integrada via ESP Component Registry (espressif/esp_rainmaker)"
         ],
         "casos_uso": [
-            "Alto-falantes inteligentes",
-            "Assistentes de voz",
-            "Rádios de internet",
-            "Players de música",
-            "Interfones e intercomunicadores",
-            "Sistemas de PA (Public Address)"
+            "Eletrodomésticos e iluminação inteligente para consumidor final",
+            "Produtos IoT com prazo reduzido de lançamento no mercado (Time-to-Market)",
+            "Dispositivos que exigem controle por app móvel sem custo de infraestrutura própria",
+            "Sistemas de monitoramento remoto com atualização OTA centralizada"
         ],
-        "exemplo": "/exemplos/esp-adf.c",
-        "exemplos": "https://github.com/espressif/esp-adf/tree/master/examples",
-        "documentacao": "https://docs.espressif.com/projects/esp-adf/",
-        "repositorio": "https://github.com/espressif/esp-adf",
-        "cor": "#3498DB"
-    },
-    "ESP-DSP": {
-        "nome": "ESP-DSP",
-        "icone": "📊",
-        "nome_completo": "ESP Digital Signal Processing Library",
-        "descricao": "Biblioteca otimizada para processamento digital de sinais no ESP32",
-        "linguagem": "C/C++",
-        "tipo": "Biblioteca Especializada",
-        "funcao_principal": "Processamento de sinais digitais com algoritmos otimizados para arquitetura ESP32",
-        "caracteristicas": [
-            "Operações matemáticas otimizadas (FFT, convolução, correlação)",
-            "Filtros digitais (FIR, IIR, Kalman)",
-            "Transformadas (FFT, DCT, DWT)",
-            "Operações de matriz e vetores",
-            "Suporte a ponto fixo e ponto flutuante",
-            "Otimizações específicas para Xtensa e RISC-V"
-        ],
-        "casos_uso": [
-            "Análise de sinais de áudio",
-            "Processamento de sinais de sensores",
-            "Filtros adaptativos",
-            "Análise espectral",
-            "Compressão de dados",
-            "Reconhecimento de padrões"
-        ],
-        "exemplo": "/exemplos/esp-dsp.c",
-        "exemplos": "https://github.com/espressif/esp-dsp/tree/master/examples",
-        "documentacao": "https://docs.espressif.com/projects/esp-dsp/",
-        "repositorio": "https://github.com/espressif/esp-dsp",
-        "cor": "#9B59B6"
-    },
-    "ESP-WHO": {
-        "nome": "ESP-WHO",
-        "icone": "📷",
-        "nome_completo": "ESP Image Processing Framework",
-        "descricao": "Framework para processamento de imagens e visão computacional no ESP32",
-        "linguagem": "C/C++",
-        "tipo": "Framework Especializado",
-        "funcao_principal": "Detecção facial, reconhecimento facial e processamento de imagens",
-        "caracteristicas": [
-            "Detecção de faces em tempo real",
-            "Reconhecimento facial",
-            "Detecção de pontos faciais (landmarks)",
-            "Rastreamento de objetos",
-            "Otimizado para ESP32-S3 com aceleradores de IA",
-            "Suporte a câmeras via interface DVP",
-            "Modelos de rede neural otimizados"
-        ],
-        "casos_uso": [
-            "Sistemas de reconhecimento facial",
-            "Controle de acesso inteligente",
-            "Câmeras de segurança com IA",
-            "Detecção de presença",
-            "Análise de expressões faciais",
-            "Contagem de pessoas"
-        ],
-        "exemplo": "/exemplos/esp-who.c",
-        "exemplos": "https://github.com/espressif/esp-who/tree/master/examples",
-        "documentacao": "https://github.com/espressif/esp-who",
-        "repositorio": "https://github.com/espressif/esp-who",
-        "cor": "#E67E22"
-    },
-    "ESP-NN": {
-        "nome": "ESP-NN",
-        "icone": "🧠",
-        "nome_completo": "ESP Neural Network Library",
-        "descricao": "Biblioteca de redes neurais otimizada para ESP32",
-        "linguagem": "C/C++",
-        "tipo": "Biblioteca Especializada",
-        "funcao_principal": "Inferência de redes neurais com otimizações específicas para ESP32",
-        "caracteristicas": [
-            "Operações de rede neural otimizadas",
-            "Suporte a convolução, pooling, fully connected",
-            "Quantização de 8 e 16 bits",
-            "Otimizações SIMD para Xtensa e RISC-V",
-            "Compatível com TensorFlow Lite",
-            "Baixo consumo de memória",
-            "Aceleração via instruções vetoriais"
-        ],
-        "casos_uso": [
-            "Classificação de imagens",
-            "Detecção de objetos",
-            "Reconhecimento de voz",
-            "Predição de séries temporais",
-            "Detecção de anomalias",
-            "IA na borda (Edge AI)"
-        ],
-        "exemplo": "/exemplos/esp-nn.c",
-        "exemplos": "https://github.com/espressif/esp-nn/tree/master/test_app",
-        "documentacao": "https://github.com/espressif/esp-nn",
-        "repositorio": "https://github.com/espressif/esp-nn",
-        "cor": "#1ABC9C"
+        "exemplo": "/exemplos/esp-rainmaker.c",
+        "exemplos": "https://github.com/espressif/esp-rainmaker/tree/master/examples",
+        "documentacao": "https://rainmaker.espressif.com/docs/",
+        "repositorio": "https://github.com/espressif/esp-rainmaker",
+        "cor": "#3B82F6"
     },
     "ESP-Matter": {
         "nome": "ESP-Matter",
         "icone": "🏠",
         "nome_completo": "ESP Matter SDK",
-        "descricao": "SDK para desenvolvimento de dispositivos compatíveis com o padrão Matter",
-        "linguagem": "C/C++",
-        "tipo": "Framework Especializado",
-        "funcao_principal": "Criar dispositivos smart home interoperáveis usando o padrão Matter",
+        "descricao": "SDK oficial da Espressif para o padrão universal de casa inteligente Matter (antigo Project CHIP). Permite que seus dispositivos operem de forma interoperável com Apple HomeKit, Google Home, Amazon Alexa e Home Assistant.",
+        "linguagem": "C++",
+        "tipo": "Smart Home Framework",
+        "funcao_principal": "Desenvolvimento de dispositivos e pontes inteligentes compatíveis com o padrão unificado Matter sobre Wi-Fi e Thread",
         "caracteristicas": [
-            "Compatibilidade com padrão Matter (ex-Project CHIP)",
-            "Interoperabilidade entre ecossistemas (Apple, Google, Amazon)",
-            "Suporte a Thread e Wi-Fi",
-            "Comissionamento simplificado",
-            "Segurança robusta (PKI, criptografia)",
-            "Modelos de dispositivos pré-definidos",
-            "Integração com ESP-IDF"
+            "Implementação completa dos clusters da especificação Matter",
+            "Suporte a transporte sobre Wi-Fi e Thread (802.15.4 em ESP32-H2 e ESP32-C6)",
+            "Comissionamento simplificado via BLE ou On-Network",
+            "Compatibilidade simultânea com Apple Home, Google Home, Alexa e SmartThings",
+            "Segurança baseada em certificados de autenticação de dispositivo (DAC)",
+            "Suporte a Matter Bridge (conectando dispositivos legados Zigbee/BLE ao Matter)",
+            "Integração direta ao ESP-IDF e ESP Component Registry"
         ],
         "casos_uso": [
-            "Lâmpadas inteligentes",
-            "Tomadas e interruptores smart",
-            "Sensores de temperatura e umidade",
-            "Fechaduras inteligentes",
-            "Termostatos",
-            "Dispositivos de controle de cortinas"
+            "Lâmpadas, tomadas, interruptores e dimmers interoperáveis",
+            "Sensores de presença, temperatura, umidade e contato",
+            "Fechaduras eletrônicas e atuadores de cortinas",
+            "Matter Border Routers e Bridges residenciais"
         ],
         "exemplo": "/exemplos/esp-matter.c",
         "exemplos": "https://github.com/espressif/esp-matter/tree/main/examples",
-        "documentacao": "https://docs.espressif.com/projects/esp-matter/",
+        "documentacao": "https://docs.espressif.com/projects/esp-matter/en/latest/",
         "repositorio": "https://github.com/espressif/esp-matter",
-        "cor": "#F39C12"
+        "cor": "#F59E0B"
     },
-    "Arduino": {
-        "nome": "Arduino",
-        "icone": "🛠️",
-        "nome_completo": "Arduino Core for ESP32",
-        "descricao": "Implementação do framework Arduino para ESP32, facilitando o desenvolvimento",
-        "linguagem": "C++",
-        "tipo": "Framework Alternativo",
-        "funcao_principal": "Desenvolvimento rápido e simplificado usando a API familiar do Arduino",
+    "ESP-ADF": {
+        "nome": "ESP-ADF",
+        "icone": "🎵",
+        "nome_completo": "ESP Audio Development Framework",
+        "descricao": "Framework especializado para processamento, streaming e reprodução de áudio digital de alta qualidade em SoCs ESP32.",
+        "linguagem": "C / C++",
+        "tipo": "Framework de Áudio & Voz",
+        "funcao_principal": "Criação de pipelines de áudio flexíveis com decodificadores, streaming de rede, equalização e efeitos acústicos",
         "caracteristicas": [
-            "API simples e intuitiva",
-            "Grande comunidade e bibliotecas",
-            "IDE Arduino integrada",
-            "Suporte a Wi-Fi e Bluetooth",
-            "Compatibilidade com bibliotecas Arduino",
-            "Ideal para prototipagem rápida",
-            "Curva de aprendizado suave"
+            "Arquitetura de pipeline de áudio modular (Audio Elements & Audio Stream)",
+            "Suporte a múltiplos codecs: MP3, AAC, FLAC, WAV, OGG, Opus e AMR",
+            "Streaming de áudio via HTTP, HTTPS, HLS, RTSP e WebSockets",
+            "Suporte a Bluetooth A2DP (Sink/Source) e Bluetooth Handsfree (HFP)",
+            "Algoritmos de processamento acústico (AEC, AGC, NS, equalizadores paramétricos)",
+            "Suporte a placas dedicadas como ESP32-LyraT e ESP32-S3-Korvo"
         ],
         "casos_uso": [
-            "Prototipagem rápida",
-            "Projetos educacionais",
-            "Makers e hobistas",
-            "IoT simples",
-            "Sensores e atuadores básicos",
-            "Projetos DIY"
+            "Caixas de som inteligentes e internet radios",
+            "Intercomunicadores, walkie-talkies e sistemas de interfonia VoIP",
+            "Aparelhos de reprodução musical com PSRAM",
+            "Sistemas de som ambiente para automação predial"
+        ],
+        "exemplo": "/exemplos/esp-adf.c",
+        "exemplos": "https://github.com/espressif/esp-adf/tree/master/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-adf/en/latest/",
+        "repositorio": "https://github.com/espressif/esp-adf",
+        "cor": "#0284C7"
+    },
+    "ESP-SR": {
+        "nome": "ESP-SR",
+        "icone": "🎙️",
+        "nome_completo": "ESP Speech Recognition Framework",
+        "descricao": "Framework de reconhecimento de fala local e processamento de áudio com IA na borda (Edge AI), permitindo comandos de voz sem depender de conexão à internet.",
+        "linguagem": "C / C++",
+        "tipo": "Framework de Voz & IA",
+        "funcao_principal": "Processamento de voz local, detecção de palavra de ativação (Wake Word) e reconhecimento de comandos de fala em tempo real",
+        "caracteristicas": [
+            "WakeNet: Detecção precisa de Wake Words locais (como 'Hi, ESP' e palavras personalizadas)",
+            "MultiNet: Reconhecimento de até centenas de comandos de voz locais offline em português, inglês e mandarim",
+            "AFE (Audio Front-End): Cancelamento acústico de eco (AEC), supressão de ruído (BSS/NS) e controle automático de ganho (AGC)",
+            "Suporte a múltiplos microfones com formação de feixe direcional (Beamforming)",
+            "Otimizado com aceleração vetorial SIMD para ESP32-S3 e ESP32-P4",
+            "Componente disponível no ESP Component Registry (espressif/esp-sr)"
+        ],
+        "casos_uso": [
+            "Eletrodomésticos com controle por voz 100% offline e privativo",
+            "Painéis de automação residencial acionados por fala",
+            "Brinquedos interativos e robótica educacional",
+            "Equipamentos hospitalares e industriais com comando sem as mãos"
+        ],
+        "exemplo": "/exemplos/esp-sr.c",
+        "exemplos": "https://github.com/espressif/esp-sr/tree/master/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-sr/en/latest/",
+        "repositorio": "https://github.com/espressif/esp-sr",
+        "cor": "#6366F1"
+    },
+    "ESP-IoT-Solution": {
+        "nome": "ESP-IoT-Solution",
+        "icone": "🧩",
+        "nome_completo": "ESP-IoT-Solution Driver & Peripheral Suite",
+        "descricao": "Coleção oficial da Espressif com dezenas de drivers, componentes de periféricos, telas touch, sensores e protocolos de barramento prontos para produção.",
+        "linguagem": "C / C++",
+        "tipo": "Biblioteca de Periféricos & Drivers",
+        "funcao_principal": "Acelerar a integração de componentes de hardware (telas LCD/OLED, sensores ambientais/IMU, botões inteligentes, barramentos I2C/SPI/Modbus)",
+        "caracteristicas": [
+            "Drivers completos de sensores (temperatura, umidade, pressão, acelerômetros, luz)",
+            "Gerenciamento avançado de botões físicos, matrizes touch e encoders rotativos",
+            "Drivers para displays LCD e OLED (ST7789, ILI9341, SSD1306) e controladores touch (FT6X36, GT911)",
+            "Pilha industrial Modbus (Master e Slave sobre RS-485 ou TCP)",
+            "Controle de motores de passo e drivers de LED endereçável (WS2812/SK6812)",
+            "Totalmente modularizado no ESP Component Registry"
+        ],
+        "casos_uso": [
+            "Interfaces homem-máquina (IHM / HMI) com telas e botões capacitivos",
+            "Estações meteorológicas e monitoramento de sensores industriais",
+            "Equipamentos de automação industrial integrados via RS-485 Modbus",
+            "Projetos com fitas e matrizes de LED RGB complexas"
+        ],
+        "exemplo": "/exemplos/esp-iot-solution.c",
+        "exemplos": "https://github.com/espressif/esp-iot-solution/tree/master/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-iot-solution/en/latest/",
+        "repositorio": "https://github.com/espressif/esp-iot-solution",
+        "cor": "#10B981"
+    },
+    "ESP-NOW": {
+        "nome": "ESP-NOW & Mesh",
+        "icone": "📡",
+        "nome_completo": "ESP-NOW Protocol & Mesh-Lite",
+        "descricao": "Protocolo de comunicação sem fio de ultra-baixa latência desenvolvido pela Espressif, operando na faixa de 2.4 GHz sem a necessidade de um roteador Wi-Fi tradicional.",
+        "linguagem": "C / C++",
+        "tipo": "Protocolo de Rede & Mesh",
+        "funcao_principal": "Troca de mensagens ponto-a-ponto, broadcast e formação de redes em malha leves entre dezenas de placas ESP32",
+        "caracteristicas": [
+            "Comunicação direta sem roteador ou ponto de acesso (AP)",
+            "Latência de transmissão de milissegundos e conexão instantânea",
+            "Criptografia nativa com chaves de chaveamento AES-128",
+            "Extremamente econômico em energia, ideal para nós alimentados por bateria",
+            "Capacidade de emparelhamento por controle remoto e broadcast para múltiplos nós",
+            "Suporte ao Mesh-Lite para roteamento em malha com salto IP"
+        ],
+        "casos_uso": [
+            "Controles remotos sem fio e interruptores de parede a bateria",
+            "Redes de sensores agrícolas distribuídas no campo",
+            "Sincronização em tempo real de iluminação cênica e drones",
+            "Alarmes e botões de pânico residenciais"
+        ],
+        "exemplo": "/exemplos/esp-now.c",
+        "exemplos": "https://github.com/espressif/esp-now/tree/master/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html",
+        "repositorio": "https://github.com/espressif/esp-now",
+        "cor": "#8B5CF6"
+    },
+    "ESP-Zigbee-SDK": {
+        "nome": "ESP-Zigbee-SDK",
+        "icone": "🐝",
+        "nome_completo": "ESP Zigbee SDK (ZCL & ZBOSS)",
+        "descricao": "SDK oficial para desenvolvimento de nós, roteadores e coordenadores Zigbee 3.0 nos SoCs ESP32 com suporte ao rádio 802.15.4 (como ESP32-H2 e ESP32-C6).",
+        "linguagem": "C / C++",
+        "tipo": "Smart Home & Mesh",
+        "funcao_principal": "Construção de redes de automação predial ultraleves e de baixíssimo consumo energético baseadas no padrão Zigbee 3.0",
+        "caracteristicas": [
+            "Implementação certificada Zigbee 3.0 baseada na stack ZBOSS",
+            "Suporte a papéis de Coordenador (ZC), Roteador (ZR) e Dispositivo Final (ZED / Sleepy End Device)",
+            "Biblioteca rica de clusters ZCL (On/Off, Nível, Cor, Temperatura, Medição de Energia)",
+            "Consumo em microampères durante sono profundo para sensores operando por anos a bateria",
+            "Compatibilidade nativa com pontes Zigbee (Home Assistant ZHA/Zigbee2MQTT, Philips Hue)"
+        ],
+        "casos_uso": [
+            "Sensores de presença, porta/janela e vazamento operando a pilha botão",
+            "Lâmpadas e tomadas inteligentes na rede Zigbee 3.0",
+            "Gateways e pontes Zigbee-para-Wi-Fi ou Zigbee-para-Ethernet",
+            "Automação predial comercial com alta densidade de nós"
+        ],
+        "exemplo": "/exemplos/esp-zigbee.c",
+        "exemplos": "https://github.com/espressif/esp-zigbee-sdk/tree/main/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-zigbee-sdk/en/latest/",
+        "repositorio": "https://github.com/espressif/esp-zigbee-sdk",
+        "cor": "#EC4899"
+    },
+    "ESP-WHO": {
+        "nome": "ESP-WHO",
+        "icone": "📷",
+        "nome_completo": "ESP Image Processing & Vision Framework",
+        "descricao": "Framework da Espressif para processamento de imagens e visão computacional na borda (Edge Vision) com câmeras conectadas ao ESP32.",
+        "linguagem": "C / C++",
+        "tipo": "Visão Computacional & IA",
+        "funcao_principal": "Detecção de rostos, identificação biométrica, detecção de pessoas e processamento de stream de vídeo",
+        "caracteristicas": [
+            "Detecção de faces em tempo real e extração de marcos faciais (Landmarks)",
+            "Reconhecimento facial local com banco de dados de usuários cadastrados",
+            "Detecção de presença humana e contagem de pessoas (Human Detection)",
+            "Otimizado para ESP32-S3 e ESP32-P4 com instruções vetoriais de IA",
+            "Suporte a sensores de câmera DVP e MIPI-CSI (OV2640, OV3660, OV5640, SC030IOT)"
+        ],
+        "casos_uso": [
+            "Controle de acesso por biometria facial",
+            "Campainhas e câmeras de segurança inteligentes (Smart Doorbells)",
+            "Sensores inteligentes de ocupação de salas e escritórios",
+            "Robôs seguidores de pessoas e brinquedos interativos"
+        ],
+        "exemplo": "/exemplos/esp-who.c",
+        "exemplos": "https://github.com/espressif/esp-who/tree/master/examples",
+        "documentacao": "https://github.com/espressif/esp-who",
+        "repositorio": "https://github.com/espressif/esp-who",
+        "cor": "#F97316"
+    },
+    "ESP-NN": {
+        "nome": "ESP-NN",
+        "icone": "🧠",
+        "nome_completo": "ESP Neural Network Acceleration Library",
+        "descricao": "Biblioteca de kernels e operações de redes neurais altamente otimizada para as arquiteturas Xtensa e RISC-V dos chips ESP32.",
+        "linguagem": "C / C++",
+        "tipo": "Biblioteca Especializada de IA",
+        "funcao_principal": "Aceleração de inferência de redes neurais profundas com quantização INT8 e INT16 aproveitando as instruções SIMD vetoriais",
+        "caracteristicas": [
+            "Operações otimizadas: Convolução 2D, Depthwise Conv, Fully Connected e Pooling",
+            "Backend acelerador oficial integrado ao TensorFlow Lite for Microcontrollers (TFLM)",
+            "Quantização eficiente de 8 e 16 bits para redução drástica de uso de RAM e Flash",
+            "Aceleração extrema no ESP32-S3 e ESP32-P4 usando instruções vetoriais dedicadas",
+            "Execução sem overhead de sistema operacional em tempo real"
+        ],
+        "casos_uso": [
+            "Classificação de áudio e sinais de vibração industrial (manutenção preditiva)",
+            "Detecção de anomalias em sensores por modelos TinyML",
+            "Reconhecimento de gestos por IMU",
+            "Visão computacional ultraleve em microcontroladores"
+        ],
+        "exemplo": "/exemplos/esp-nn.c",
+        "exemplos": "https://github.com/espressif/esp-nn/tree/master/test_app",
+        "documentacao": "https://github.com/espressif/esp-nn",
+        "repositorio": "https://github.com/espressif/esp-nn",
+        "cor": "#14B8A6"
+    },
+    "ESP-DSP": {
+        "nome": "ESP-DSP",
+        "icone": "📊",
+        "nome_completo": "ESP Digital Signal Processing Library",
+        "descricao": "Biblioteca oficial de processamento digital de sinais para a família ESP32, fornecendo algoritmos matemáticos acelerados em hardware.",
+        "linguagem": "C / C++",
+        "tipo": "Biblioteca Especializada de Sinais",
+        "funcao_principal": "Execução de cálculos matemáticos pesados como FFT, transformadas, filtragem digital e operações matriciais com máxima velocidade",
+        "caracteristicas": [
+            "Transformadas Rápidas de Fourier (FFT real e complexa) otimizadas em Assembly",
+            "Filtros digitais IIR, FIR e estimadores de Kalman",
+            "Operações com matrizes, vetores e produtos escalares",
+            "Suporte a números de ponto flutuante e ponto fixo (Radix-2 e Radix-4)",
+            "Otimizações personalizadas para arquiteturas Xtensa Dual-Core e RISC-V"
+        ],
+        "casos_uso": [
+            "Análise espectral de áudio e vibrações em tempo real",
+            "Filtros anti-ruído para sensores biomédicos (ECG/EMG) e industriais",
+            "Controle de motores de alta precisão e algoritmos FOC",
+            "Compressão e codificação de dados na borda"
+        ],
+        "exemplo": "/exemplos/esp-dsp.c",
+        "exemplos": "https://github.com/espressif/esp-dsp/tree/master/examples",
+        "documentacao": "https://docs.espressif.com/projects/esp-dsp/en/latest/",
+        "repositorio": "https://github.com/espressif/esp-dsp",
+        "cor": "#A855F7"
+    },
+    "Rust-ESP": {
+        "nome": "Rust on ESP32",
+        "icone": "🦀",
+        "nome_completo": "ESP-RS Rust Ecosystem for ESP32",
+        "descricao": "Ecossistema moderno de desenvolvimento em linguagem Rust para a família ESP32, combinando segurança de memória (Memory Safety), concorrência robusta e alto desempenho.",
+        "linguagem": "Rust",
+        "tipo": "Linguagem & Framework Moderno",
+        "funcao_principal": "Desenvolvimento de firmware seguro e de alta performance tanto em modo bare-metal (no_std via esp-hal) quanto com a pilha completa (std via esp-idf-svc)",
+        "caracteristicas": [
+            "Modo Bare-Metal `no_std` com a biblioteca `esp-hal`: controle total sem RTOS e boot ultrarrápido",
+            "Modo `std` com `esp-idf-svc`: acesso à biblioteca padrão do Rust, Wi-Fi, BLE, HTTP, MQTT e threads",
+            "Prevenção garantida em tempo de compilação contra corrupção de memória e Data Races",
+            "Suporte a targets Xtensa (ESP32, S2, S3) e RISC-V nativo (C2, C3, C6, H2, P4)",
+            "Integração com ecossistema de crates `embedded-hal` e async/await com `embassy`",
+            "Ferramentas oficiais: `espflash` para gravação e monitor serial e `esp-generate` para templates"
+        ],
+        "casos_uso": [
+            "Sistemas críticos onde falhas de memória (Null Pointer, Buffer Overflow) são inaceitáveis",
+            "Aplicações IoT modernas com concorrência assíncrona limpa",
+            "Dispositivos industriais que exigem segurança de alto nível",
+            "Projetos modernos de robótica e instrumentação"
+        ],
+        "exemplo": "/exemplos/rust-esp.rs",
+        "exemplos": "https://github.com/esp-rs/esp-hal/tree/main/examples",
+        "documentacao": "https://esp-rs.github.io/book/",
+        "repositorio": "https://github.com/esp-rs",
+        "cor": "#E44D26"
+    },
+    "Arduino": {
+        "nome": "Arduino Core",
+        "icone": "🛠️",
+        "nome_completo": "Arduino Core for ESP32",
+        "descricao": "Implementação oficial do framework Arduino sobre o ESP-IDF (versões 3.x+ baseadas em ESP-IDF v5.1+), combinando extrema facilidade com os recursos avançados do ESP32.",
+        "linguagem": "C++",
+        "tipo": "Framework Alternativo Popular",
+        "funcao_principal": "Prototipagem rápida, projetos educacionais e desenvolvimento acelerado aproveitando o vasto ecossistema de bibliotecas Arduino",
+        "caracteristicas": [
+            "Sintaxe clássica `setup()` e `loop()` com centenas de milhares de bibliotecas compatíveis",
+            "Execução como uma tarefa FreeRTOS sobre o ESP-IDF oficial",
+            "Suporte completo a Wi-Fi, Bluetooth Classic/BLE, WebServer e WebSockets",
+            "Compatibilidade com Arduino IDE 2.x, PlatformIO e VS Code",
+            "Suporte atualizado a todos os SoCs populares (ESP32, S2, S3, C3, C6)",
+            "Acesso a funções nativas do ESP-IDF quando necessário"
+        ],
+        "casos_uso": [
+            "Prototipagem rápida e validação de conceitos (PoC)",
+            "Projetos educacionais, makers e acadêmicos",
+            "Sistemas IoT simples com dashboards (Blynk, Adafruit IO, ThingSpeak)",
+            "Robótica amadora e automação residencial faça-você-mesmo (DIY)"
         ],
         "exemplo": "/exemplos/arduino.ino",
         "exemplos": "https://github.com/espressif/arduino-esp32/tree/master/docs/en/tutorials",
-        "documentacao": "https://docs.espressif.com/projects/arduino-esp32/",
+        "documentacao": "https://docs.espressif.com/projects/arduino-esp32/en/latest/",
         "repositorio": "https://github.com/espressif/arduino-esp32",
         "cor": "#00979D"
     },
@@ -218,26 +368,22 @@
         "nome": "MicroPython",
         "icone": "🐍",
         "nome_completo": "MicroPython for ESP32",
-        "descricao": "Implementação do Python 3 otimizada para microcontroladores ESP32",
+        "descricao": "Implementação enxuta e eficiente da linguagem Python 3 otimizada para rodar diretamente na CPU do ESP32 com interpretador em tempo real.",
         "linguagem": "Python",
-        "tipo": "Framework Alternativo",
-        "funcao_principal": "Desenvolvimento em Python para prototipagem rápida e scripting",
+        "tipo": "Linguagem & Interpretador Dinâmico",
+        "funcao_principal": "Desenvolvimento interativo e prototipagem ágil em Python com console REPL interativo e manipulação instantânea de hardware",
         "caracteristicas": [
-            "Sintaxe Python 3",
-            "REPL interativo",
-            "Desenvolvimento iterativo",
-            "Bibliotecas padrão Python",
-            "Suporte a Wi-Fi e Bluetooth",
-            "Sistema de arquivos integrado",
-            "Ideal para educação e prototipagem"
+            "Interpretador Python 3 completo com compilação para bytecode em RAM",
+            "Console interativo REPL via porta serial e WebREPL via Wi-Fi",
+            "Sistema de arquivos integrado (LittleFS / FAT) com upload de scripts `.py` sem recompilar",
+            "Módulos nativos `machine`, `network`, `bluetooth`, `espnow` e `asyncio`",
+            "Excelente para ensinar programação e algoritmos com hardware real"
         ],
         "casos_uso": [
-            "Prototipagem rápida",
-            "Educação e ensino",
-            "Scripts de automação",
-            "IoT experimental",
-            "Projetos de ciência de dados embarcados",
-            "Testes e validação"
+            "Ensino de computação física e laboratórios universitários",
+            "Prototipagem ágil e testes rápidos de sensores em bancada",
+            "Scripts de automação de testes de bancada",
+            "Aplicações experimentais de coleta de dados IoT"
         ],
         "exemplo": "/exemplos/micropython.py",
         "exemplos": "https://github.com/micropython/micropython/tree/master/examples",
@@ -246,4 +392,3 @@
         "cor": "#2B2B2B"
     }
 }
-