Tag: Inobot

  • LLMs Locais: Sua IA, Seu Hardware, Suas Regras

    LLMs Locais: Sua IA, Seu Hardware, Suas Regras

    Toda vez que você pergunta algo ao ChatGPT, Gemini ou Claude, seu texto viaja até um datacenter, atravessa camadas de roteamento, é processado por clusters de GPUs que consomem megawatts e volta com uma resposta. É mágica — mas também significa que um terceiro leu, processou e potencialmente armazenou sua pergunta. Para um maker, isso levanta uma questão inevitável: e se eu pudesse rodar isso aqui, no meu hardware, com zero dependência externa?

    A resposta em 2026 é: pode. E é mais fácil do que parece.

    O Que Mudou: De Gigantes a Anões Poderosos

    Em 2022, rodar um LLM decente localmente exigia uma GPU de US$ 3000. Em 2023, a Meta lançou o Llama 2, o primeiro modelo de código aberto competitivo. Em 2024, o Llama 3 chegou com variantes de 8B a 70B de parâmetros — a versão de 8 bilhões roda confortavelmente em 8 GB de RAM. A Mistral AI, startup francesa fundada por ex-engenheiros da Meta e DeepMind, lançou o Mistral 7B e o Mixtral 8x7B com arquitetura MoE (Mixture of Experts), eficientes e com desempenho próximo a modelos muito maiores.

    Mas o catalisador foi o Ollama: um projeto de código aberto que empacota modelos de linguagem em containers prontos para executar. Instalou, rodou. Sem configurar Python, sem compilar CUDA, sem dependências exóticas. O Ollama fez para LLMs o que o Docker fez para serviços web e o que o Arduino fez para microcontroladores: eliminou a fricção.

    Instalando e Rodando em 5 Minutos

    O Ollama roda em Linux, macOS e Windows. A instalação é um comando:

    # Linux
    curl -fsSL https://ollama.com/install.sh | sh
    
    # Windows
    # Baixe o instalador em https://ollama.com/download/windows
    

    Para baixar e rodar um modelo:

    # Llama 3 8B — ~4.7 GB de download
    ollama pull llama3
    ollama run llama3
    

    Pronto. Você está conversando com uma IA que roda integralmente na sua máquina. O prompt aparece no terminal. Sem navegador. Sem internet. Sem latência de rede. O zumbido dos coolers da sua GPU lembrando que você é o dono do datacenter agora.

    Outros modelos que recomendo testar:

    • Mistral 7B: ollama pull mistral — mais leve, excelente para código, roda em máquinas com 8 GB de RAM.
    • Phi-3 Mini (Microsoft): ollama pull phi3 — 3.8B parâmetros, surpreendentemente bom, cabe em 4 GB.
    • CodeGemma (Google): ollama pull codegemma — especializado em código, autocompleta Python como ninguém.
    • DeepSeek Coder V2: ollama pull deepseek-coder-v2 — open-source da DeepSeek, rival de peso para GPT-4 em código.

    Integrando com Python: Sua API Pessoal

    O Ollama expõe uma API REST na porta 11434. Com Python, é trivial:

    import requests
    import json
    
    def ask_llama(prompt):
        """Pergunta ao Llama 3 rodando localmente"""
        url = "http://localhost:11434/api/generate"
        payload = {
            "model": "llama3",
            "prompt": prompt,
            "stream": False
        }
        response = requests.post(url, json=payload)
        return response.json()["response"]
    
    # Exemplo: pergunte o que quiser
    resposta = ask_llama("Explique o que é um transistor MOSFET em duas frases.")
    print(resposta)
    

    Agora imagine um sistema maker que lê sensores (temperatura, umidade, presença) e consulta o LLM local para gerar um resumo do ambiente em linguagem natural: “Está quente e úmido no quarto, típico de tarde de verão. Recomendo ligar o ventilador e fechar a cortina.” Isso é IA no mundo físico — e é possível hoje.

    Casos de Uso Reais para o Maker

    • Assistente de código offline: o Ollama + Continue.dev (plugin VS Code) substitui o GitHub Copilot com zero custo e zero telemetria.
    • Interface em linguagem natural para projetos: em vez de um dashboard com 20 botões, uma caixa de texto: “acenda a luz da sala e regule para 50%” → o LLM interpreta → chama a API do Home Assistant.
    • Documentação automática: um script Python que lê os comentários do seu código e gera README.md com explicações em português.
    • Classificador de imagens local: com o LLaVA (modelo multimodal), você pergunta “tem alguém na porta?” e ele analisa o frame da ESP32-CAM sem enviar nada pra nuvem.
    • Tradutor embarcado: um display ePaper que traduz placas e menus em tempo real, offline.

    Hardware: Quanto Você Precisa Investir

    Uso Modelo RAM Mínima GPU Recomendada Investimento (~BR)
    Básico (chat, código simples) Phi-3 Mini / Mistral 7B (Q4) 8 GB Integrada serve R$ 0 (seu PC atual)
    Intermediário (projetos makers) Llama 3 8B / DeepSeek Coder 16 GB RTX 3060 12GB ~R$ 2000-3000 (GPU)
    Avançado (multimodal, código complexo) Llama 3 70B (Q4) / Mixtral 8x7B 32 GB+ RTX 3090/4090 24GB ~R$ 6000-10000

    A boa notícia: para a maioria dos casos de uso maker, um notebook com 16 GB de RAM já roda Llama 3 8B quantizado a 4 bits com velocidade aceitável (~10 tokens/s em CPU, ~50 tokens/s com GPU). Você não precisa montar um cluster.

    A Questão da Privacidade (E Por Que Ela Importa)

    Quando você usa um LLM na nuvem, está compartilhando seu contexto — seus projetos, suas ideias, seu código proprietário — com uma corporação. Para um hobby, talvez não importe. Para uma startup desenvolvendo um produto, importa muito. Para um jornalista ou ativista trabalhando com dados sensíveis, é existencial.

    LLMs locais resolvem isso por definição: os dados nunca saem da sua máquina. Você pode desconectar o cabo de rede e continuar usando. Pode auditar o modelo. Pode fazer fine-tuning com seus próprios dados. É a diferença entre alugar um quarto e ser dono da casa.

    Fontes e Referências

  • Robótica com ROS 2: O Sistema Operacional Que os Robôs Merecem

    Robótica com ROS 2: O Sistema Operacional Que os Robôs Merecem

    Se você já programou um Arduino para seguir linha com sensor infravermelho, sabe que robótica “bare metal” é deliciosa — e rapidamente insustentável. Adicione uma câmera. Depois um LIDAR. Depois um IMU. Depois planejamento de trajetória. De repente você está gerenciando dezenas de threads, timestamps, transformadas de coordenadas e fusão de sensores — e seu código virou um spaghetti que só você entende (e olhe lá). Foi exatamente para resolver isso que nasceu o ROS.

    O Que É ROS (E Por Que a Versão 2)

    ROS (Robot Operating System) não é um sistema operacional no sentido tradicional — não substitui Linux, não faz boot. É um middleware: uma camada de comunicação que organiza os componentes de software de um robô como uma rede de nós (nodes) que trocam mensagens por tópicos (topics). Criado em 2007 no laboratório de Inteligência Artificial de Stanford e mantido pela Open Robotics, o ROS tornou-se o padrão de fato para robótica acadêmica e industrial.

    O ROS 1, porém, tinha falhas fundamentais: dependia de um nó central (roscore) — se ele caísse, o robô inteiro parava. Não havia segurança de rede. A comunicação era frágil em WiFi. Não havia suporte a sistemas em tempo real. Não rodava nativamente no Windows. E era monolítico: você não conseguia atualizar um componente sem recompilar o sistema inteiro.

    O ROS 2, lançado oficialmente em 2020 com a distribuição Foxy Fitzroy, reescreveu a arquitetura do zero sobre o DDS (Data Distribution Service), um padrão industrial de comunicação publish-subscribe descentralizado. Resultado: sem nó central, TLS nativo, QoS configurável, suporte a múltiplos sistemas operacionais (Ubuntu, Windows, macOS) e, crucialmente, arquitetura de microsserviços.

    Três Conceitos Que Você Precisa Entender

    A metáfora que eu uso nas aulas é uma redação de jornal:

    • Node (nó): é um repórter. Cada nó faz uma coisa específica: um lê o LIDAR, outro processa odometria, outro controla os motores. Cada nó é um processo independente — pode ser em Python, C++, até Rust.
    • Topic (tópico): é o quadro de avisos onde os repórteres publicam. Um nó publica mensagens num tópico (publisher); outros nós assinam esse tópico (subscriber). O sensor de temperatura publica em /temp; o nó do painel assina e mostra no display.
    • Service (serviço): é quando você precisa de uma resposta pontual. Enquanto tópicos são streams contínuas, serviços são request-reply. “Tira uma foto agora” → serviço. “Mande todos os frames de vídeo” → tópico.

    Mão na Massa: Instalando o ROS 2 Humble

    Vamos usar o ROS 2 Humble Hawksbill, a distribuição LTS atual, rodando no Ubuntu 22.04. Se você usa Windows, recomendo instalar via WSL2 — funciona perfeitamente com acesso a GPU e USB.

    # Adiciona o repositório da Open Robotics
    sudo apt update && sudo apt install curl gnupg lsb-release
    sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/ros2.list
    
    # Instala o ROS 2 Humble (versão desktop completa)
    sudo apt update
    sudo apt install ros-humble-desktop python3-colcon-common-extensions
    

    Após a instalação, configure o ambiente:

    # Adicione isso ao seu ~/.bashrc
    echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc
    source ~/.bashrc
    

    Primeiro Robô: TurtleSim

    O Turtlesim é o “Hello World” do ROS — e, como toda boa ferramenta de aprendizado, é simples por fora e profundo por dentro. É uma simulação 2D de uma tartaruga que você controla por mensagens ROS.

    Abra três terminais. Em cada um, rode source /opt/ros/humble/setup.bash (se não estiver no bashrc).

    Terminal 1 — Rode o simulador:

    ros2 run turtlesim turtlesim_node
    

    Uma janela azul se abre com uma tartaruga no centro. Viva — seu primeiro robô virtual está rodando.

    Terminal 2 — Controle a tartaruga via teclado:

    ros2 run turtlesim turtle_teleop_key
    

    Use as setas para mover a tartaruga. A cada tecla pressionada, o nó teleop publica mensagens no tópico /turtle1/cmd_vel (velocidade linear e angular). O nó turtlesim assina esse tópico e atualiza a posição.

    Terminal 3 — Inspecione o sistema:

    # Lista todos os nós rodando
    ros2 node list
    
    # Lista todos os tópicos
    ros2 topic list
    
    # Mostra o conteúdo de um tópico em tempo real
    ros2 topic echo /turtle1/cmd_vel
    
    # Mostra o grafo de nós e tópicos
    rqt_graph
    

    O rqt_graph é mágico: você vê visualmente que o nó teleop publica em /turtle1/cmd_vel e o nó turtlesim assina. É a arquitetura do seu robô desenhada automaticamente.

    Programando Seu Próprio Nó em Python

    Crie um workspace ROS 2 e um package Python:

    mkdir -p ~/robot_ws/src && cd ~/robot_ws
    colcon build
    source install/setup.bash
    
    cd ~/robot_ws/src
    ros2 pkg create --build-type ament_python meu_robo --dependencies rclpy geometry_msgs
    

    Crie o arquivo ~/robot_ws/src/meu_robo/meu_robo/quadrado.py:

    import rclpy
    from rclpy.node import Node
    from geometry_msgs.msg import Twist
    import time
    
    class SquareMover(Node):
        def __init__(self):
            super().__init__('square_mover')
            # Publisher para o tópico de velocidade da tartaruga
            self.publisher = self.create_publisher(Twist, '/turtle1/cmd_vel', 10)
            self.timer = self.create_timer(0.5, self.move_square)
            self.step = 0
    
        def move_square(self):
            msg = Twist()
            if self.step % 2 == 0:
                # Anda reto
                msg.linear.x = 2.0
                msg.angular.z = 0.0
            else:
                # Gira 90°
                msg.linear.x = 0.0
                msg.angular.z = 1.57  # ~π/2 radianos
            self.publisher.publish(msg)
            self.step += 1
            self.get_logger().info(f'Step {self.step}: linear={msg.linear.x}, angular={msg.angular.z}')
    
    def main():
        rclpy.init()
        node = SquareMover()
        rclpy.spin(node)
        node.destroy_node()
        rclpy.shutdown()
    
    if __name__ == '__main__':
        main()
    

    Adicione o entry point no setup.py do package e compile:

    cd ~/robot_ws && colcon build && source install/setup.bash
    ros2 run meu_robo quadrado
    

    Sua tartaruga começa a desenhar quadrados na tela. O que está acontecendo: seu nó Python publica mensagens Twist (velocidade linear + angular) no tópico /turtle1/cmd_vel. O nó turtlesim assina esse tópico e move a tartaruga. Você não mexeu no código do simulador — só publicou na interface certa.

    Isso é a essência do ROS: componentes desacoplados que conversam por mensagens padronizadas. Você pode trocar o simulador por um robô real, mantendo o mesmo código de controle — é só o tópico que muda de nome.

    Por Que Isso Importa Para o Maker

    ROS 2 não é só para Boston Dynamics e NASA. Com a popularização de plataformas como TurtleBot 4, Leo Rover e até kits baseados em ESP32 + micro-ROS, a robótica com ROS está chegando ao orçamento maker. Um robô diferencial com LIDAR, IMU e câmera, rodando ROS 2 e fazendo SLAM (mapeamento simultâneo) pode ser montado por menos de R$ 2000 em 2026.

    O aprendizado de ROS 2 é um investimento de carreira: vagas de engenharia robótica que pedem ROS pagam consistentemente acima da média, e a demanda só cresce com logística autônoma, agricultura de precisão e inspeção industrial. E tudo começa com uma tartaruga desenhando quadrados no Ubuntu.

    Fontes e Referências

  • O Laboratório em Casa: Monte Seu Espaço Maker

    O Laboratório em Casa: Monte Seu Espaço Maker

    Existe um mito persistente no mundo maker: o de que você precisa de uma garagem de 30 metros quadrados, com bancada de aço inox, osciloscópio de 4 canais e uma impressora 3D de R$ 10 mil para começar. Não precisa. Meu primeiro “laboratório” foi uma tábua de MDF em cima de duas gavetas no canto do quarto, com um ferro de solda de R$ 15 e um multímetro emprestado. E adivinhe? Funcionava. O que faz um espaço maker não é o tamanho — à a intenção. Uma mesa de 1,20m com as ferramentas certas, organizada com propósito, vale mais que um galpão bagunçado.

    O Laboratório em Casa: Monte Seu Espaço Maker
    Foto: Andrew Magill — CC BY 2.0 (via Wikimedia Commons, arquivo File:Home lab.jpg)

    Ferramentas Essenciais: O Kit de Sobrevivência

    Se você está começando do zero absoluto, esta à a lista mínima — o que eu compraria hoje se perdesse tudo num incêndio (depois de chorar):

    • Multímetro digital: a ferramenta mais importante da eletrônica. Meça tensão, corrente, resistência, continuidade. O Uni-T UT33C+ (~R$ 50-70) é o padrão-ouro para iniciantes. O Minipa ET-1000 (~R$ 40) também é bom. Não compre o de R$ 15 — ele mente, e mentiras com 220V são perigosas.
    • Ferro de solda: como detalhei no Post 6, mínimo 60W com temperatura ajustável. TS101 ou estação Yihua.
    • Alicate de corte diagonal: para cortar terminais de componentes, fios, jumpers. O de 4 polegadas (~R$ 15-20) é perfeito. Pegue um com mola de retorno — seus dedos agradecem.
    • Alicate de bico: para segurar componentes pequenos, dobrar terminais, alcançar lugares apertados. Bico fino e serrilhado (~R$ 15-25).
    • Chave de fenda e philips pequenas: kit de precisão com bits intercambiáveis (~R$ 30-50). Parafusos M2 e M3 são onipresentes em projetos maker.
    • Estilete: para cortar fios, descascar cabos finos, abrir caixas. Com lâmina retrátil e trava (~R$ 10-15).
    • Fita isolante 3M: a original, não a genérica que descola em 3 dias. Preço: ~R$ 10-15. Dura meses.
    • Abraçadeiras (zip ties): 100 peças de 100—2.5mm por ~R$ 10. Organizam cabos, prendem sensores, seguram placas. Subestimadas.
    • Breadboard + jumpers: 3 breadboards de 400 pontos + kit de jumpers macho-macho e macho-fêmea (~R$ 40).

    Total desse kit de sobrevivência: ~R$ 250-350. Com ele, você faz 80% dos projetos maker que existem.

    Próximo Nível: O Que Comprar Depois

    Quando os projetos começarem a ficar mais complexos — e sua confiança crescer — estas ferramentas compensam cada centavo:

    • Osciloscópio DSO138: kit DIY de osciloscópio digital (~R$ 70-100). 200 kHz de largura de banda, tela colorida. Não é um Rigol, mas já mostra formas de onda, PWM, ruído, sinal serial. Você monta e solda — dois aprendizado em um.
    • Fonte de bancada: converter fonte ATX de PC velho é o projeto maker clássico: 3.3V, 5V, 12V, proteção contra curto. Tutorial aos montes no YouTube. Custo: R$ 30-50 em conectores e bornes + a fonte velha. Alternativa: fonte de bancada pronta de 30V 5A (~R$ 200-300).
    • Estação de retrabalho: pistola de ar quente para soldar/dessoldar SMD. A Yihua 858D (~R$ 150-200) à a porta de entrada. SMD não é bicho de sete cabeças — com ar quente e fluxo, é mais fácil que through-hole.
    • Lupa de bancada com iluminação LED: sua visão agradece. Componentes SMD 0603 são menores que um grão de arroz. Com lupa e boa iluminação, você solda sem drama. Preço: ~R$ 80-150.

    Organização: O Sistema Que Salva Sua Sanidade

    Organizar componentes eletrônicos é um problema NP-difícil — a quantidade de resistores, capacitores, LEDs, sensores e módulos cresce exponencialmente com o número de projetos. Meu sistema, refinado ao longo de anos:

    • Gaveteiro de componentes: aqueles de plástico com 30-60 gavetinhas transparentes (~R$ 40-60). Cada gaveta etiquetada: “Resistores 220Ω”, “Capacitores 100nF”, “LEDs vermelhos 5mm”, “Transistores 2N2222”. Saber que você tem o componente não adianta se você não consegue encontrá-lo em menos de 2 minutos.
    • Caixas plásticas transparentes: para módulos maiores (ESP32, sensores, displays, shields). Empilháveis e com tampa (~R$ 25 por kit de 5).
    • Etiquetadora: sério. Uma Brother P-Touch ou similar (~R$ 180-250) é o investimento com maior retorno emocional do maker. Componentes não etiquetados desaparecem — é lei da termodinâmica maker.
    • Painel perfurado (pegboard): na parede atrás da bancada. Ganchos para pendurar alicates, tesouras, fitas, cabos USB. Custa R$ 30-50 e multiplica o espaço útil.

    Iluminação: O Segredo Que Ninguém Conta

    A iluminação da sua bancada é tão importante quanto as ferramentas. Trabalhar com componentes pequenos sob luz amarela fraca é receita para erro, fadiga ocular e solda fria. Minha recomendação:

    • Temperatura de cor: 4000K (branco neutro). Não é o 6500K frio de escritório, nem o 2700K quente de sala. O 4000K é o ponto ideal — fiel às cores (importante para ler código de cores de resistor), não cansa os olhos.
    • Luminária articulada de bancada: braços longos reguláveis + LED 4000K. Posicione a 40-60 cm da área de trabalho. Preço: ~R$ 60-120 no Mercado Livre.
    • Fita LED na prateleira inferior: se sua bancada tem prateleira em cima, coloque fita LED 4000K embaixo dela para iluminar uniformemente a área de trabalho.

    A Filosofia da Bancada

    Existe uma correlação direta entre a organização da sua bancada e a clareza dos seus projetos. Não é misticismo — é psicologia cognitiva. Quando sua área de trabalho está caótica, parte do seu cérebro fica processando a desordem visual. Você perde componentes, repete medições, esquece onde deixou o ferro ligado.

    Uma bancada organizada não é sobre ser “arrumadinho” — é sobre reduzir o atrito entre ideia e execução. Cada segundo que você gasta procurando o resistor de 10kΩ é um segundo que sua empolgação esfria. E empolgação é o combustível mais precioso do maker.

    Minha rotina: 10 minutos no final de cada sessão guardando ferramentas, varrendo a bancada e guardando componentes nos lugares certos. Não leva 10 minutos se você fizer todo dia. No sábado de manhã, você chega na bancada e ela está pronta para receber sua ideia — sem obstáculos, sem distrações, só possibilidade.

    Seu espaço maker não é só um lugar físico. é um reflexo do seu respeito pelo próprio processo criativo. Trate-o bem.

    Fontes e Referências

  • Linux É Sua Oficina

    Linux É Sua Oficina

    Se você está entrando agora no mundo maker, há uma decisão que vai definir sua relação com as ferramentas pelos próximos anos — e não é qual placa comprar. É o sistema operacional do seu computador principal. Não vou fazer proselitismo: o Windows funciona, o macOS funciona. Mas o Linux funciona melhor para o que fazemos. E a diferença não é cosmética — é arquitetural.

    Linux É Sua Oficina
    Wikimedia Commons — CC BY-SA 4.0, autor Keanu Dölle

    Quando conecto um Arduino no Windows, torço para o driver CH340 instalar sozinho (às vezes instala, às vezes preciso baixar de um site chinês). No Linux, eu conecto e digito ls /dev/ttyUSB*. Se o dispositivo existe, ele aparece. Se não aparece, eu olho o dmesg e vejo exatamente o que o kernel detectou. Não tem caixa preta. Não tem balãozinho na barra de tarefas dizendo “dispositivo instalado com sucesso” enquanto ele falhou silenciosamente. O terminal não mente.

    Por Que Linux Para Maker?

    Não é sobre odiar a Microsoft. É sobre usar a ferramenta certa para o trabalho certo. E o trabalho do maker é fundamentalmente compatível com o que o Linux oferece:

    • Arduino IDE e PlatformIO: ambos rodam nativamente no Linux. O PlatformIO, em particular, como extensão do VS Code, integra compilação, upload, monitor serial e gerenciamento de bibliotecas com uma fluidez que no Windows depende de variáveis de ambiente PATH quebrando misteriosamente a cada atualização.
    • KiCad: o KiCad é desenvolvido primariamente para Linux. A instalação no Ubuntu é sudo apt install kicad — sem installers, sem wizards, sem “concordo com os termos”.
    • Slicers (Cura/PrusaSlicer): ambos têm versões nativas para Linux. A renderização da pré-visualização de camadas é mais rápida e estável.
    • Drivers USB-Serial: CH340, CP2102, FTDI — todos têm drivers no kernel Linux. Você conecta o dispositivo e ele aparece como /dev/ttyUSB0 ou /dev/ttyACM0. Sem baixar nada.
    • Python e pip: no Linux, Python vem instalado. Você roda pip install e as bibliotecas vão para o lugar certo. No Windows, precisa configurar PATH, escolher entre Python do site ou da Microsoft Store, rezar para o pip estar no PATH também. Cada minuto gasto configurando ambiente no Windows é um minuto que você não está fazendo seu projeto.
    • OpenSCAD: modelagem 3D programática — você “escreve” objetos 3D em código. Extremamente útil para peças paramétricas. No Linux: sudo apt install openscad. Pronto.
    • Git: controle de versão para código, esquemáticos, modelos 3D. O Git é nativo do Linux — foi criado pelo Linus Torvalds para o kernel Linux.
    • SSH e SCP: conectar remotamente a Raspberry Pis, ESP32 com MicroPython, servidores — no Linux é transparente porque SSH é parte da alma do sistema.

    Qual Distro Para Começar?

    A pergunta que mais assusta iniciantes. Resposta direta:

    • Ubuntu 24.04 LTS: a distro mais popular do mundo, com a maior comunidade. Qualquer tutorial que você encontrar vai ter instruções para Ubuntu. Suporte de 5 anos garantido. Ideal para quem quer instalar e usar — sem aventuras.
    • Linux Mint 22: interface mais familiar para quem vem do Windows (Cinnamon), base Ubuntu, estável. Minha recomendação pessoal para iniciantes em 2026. A transição do Windows é menos traumática.
    • Pop!_OS 24.04: da System76, foco em produtividade. Tem uma versão com drivers NVIDIA pré-instalados — útil se você usa GPU para IA/visão computacional.
    • Não comece com Arch, Gentoo, Void: são distros excelentes, mas para usuários avançados. Você quer fazer projetos de eletrônica, não compilar o kernel. Deixe o “I use Arch btw” para depois do seu quinto PCB fabricado.

    Comandos Que Todo Maker Deve Saber

    Você não precisa ser sysadmin para usar Linux como maker. Mas estes 10 comandos vão resolver 90% dos seus problemas:

    • ls /dev/tty* — lista dispositivos seriais conectados. Seu Arduino/ESP32 vai aparecer aqui. Sem esse comando, você está programando no escuro.
    • lsusb — lista dispositivos USB. O VID:PID (ex: 1a86:7523 para CH340) confirma se o driver carregou.
    • dmesg | tail -20 — últimas 20 linhas do log do kernel. Conectou algo USB e quer ver se foi detectado? Esse comando mostra.
    • cd ~/projetos — navega entre diretórios. O til (~) é atalho para sua home.
    • chmod +x script.sh — torna um arquivo executável. Necessário para scripts Python que você quer rodar direto.
    • ssh usuario@192.168.1.100 — conecta remotamente a outro computador (ex: seu Raspberry Pi).
    • git clone https://github.com/usuario/projeto — baixa repositórios de código. Essencial para compartilhar e colaborar.
    • pip install biblioteca — instala pacotes Python (mas prefira pip install --user ou ambientes virtuais).
    • sudo apt update && sudo apt upgrade — atualiza o sistema. Faça uma vez por semana.
    • htop — monitor de sistema interativo. Mais bonito e informativo que o Task Manager do Windows.

    Open-Source É Mentalidade, Não Só Software

    A decisão de usar Linux vai além da eficiência técnica. Existe uma filosofia aqui: as ferramentas que você usa influenciam o que você constrói. Quando você usa software proprietário, está aceitando caixas-pretas no seu fluxo de trabalho — pedaços que você não pode inspecionar, modificar ou entender completamente. No mundo maker, onde o objetivo é justamente abrir caixas-pretas, isso é contraditório.

    Usar Linux não significa que você precisa odiar Windows ou abandonar jogos. Dual boot existe. Máquina virtual existe. O ponto é: para o computador que você usa para projetar, programar e criar, o Linux é a escolha que maximiza controle, minimiza fricção e te coloca no mesmo ecossistema onde Arduino, KiCad, OpenSCAD e PlatformIO foram concebidos. Eles foram feitos para rodar aqui.

    Fontes e Referências

  • Do Breadboard ao PCB: A Jornada do Protótipo ao Produto

    Do Breadboard ao PCB: A Jornada do Protótipo ao Produto

    O protótipo na breadboard funciona. O LED pisca, o sensor lê, o motor gira. Você mostra para alguém e a reação é “legal!” — seguida de “mas esses fiozinhos não vão cair?” E caem. Todo mundo que já levou um protótipo numa viagem de carro sabe: breadboard é para validar ideias, não para transportar realidades. A jornada do protótipo frágil ao produto sólido passa por uma palavra de três letras que assusta iniciantes: PCB.

    Do Breadboard ao PCB: A Jornada do Protótipo ao Produto
    Wikimedia Commons — CC BY-SA 4.0, autor Pradana Aumars (talk · contribs)

    Não precisa assustar. Em 2026, projetar e fabricar sua própria placa de circuito impresso é mais fácil — e mais barato — do que nunca.

    Os Quatro Estágios da Materialização

    Entenda o fluxo como uma escada de permanência: cada degrau é mais sólido e mais difícil de voltar atrás — mas também mais profissional:

    • Breadboard: prototipagem instantânea, zero solda, fácil de modificar. Duração esperada: horas a dias. Inimiga número 1: vibração e mal contato.
    • Protoboard / Perfboard: placa fenólica com furos padronizados. Você solda os componentes e faz as trilhas com fio esmaltado ou jumpers. Já é permanente, mas trabalhoso e feio. Custo: R$ 5-10. Bom para protótipos que vão ficar montados por semanas.
    • PCB caseiro (toner transfer): você imprime o layout em papel glossy com impressora laser, transfere o toner para a placa de cobre com calor (ferro de passar), corrói o cobre exposto com percloreto de ferro e perfura os furos. Resultado profissional, mas o processo é artesanal e a precisão depende da sua habilidade. Satisfatório? Muito. Repetível? Nem tanto.
    • PCB fabricado (JLCPCB / PCBWay): você envia arquivos Gerber para uma fábrica na China e recebe placas profissionais em casa, com máscara de solda colorida, serigrafia, furos metalizados, tudo. Custo: US$ 2 por 5 placas de 50×50mm + frete (~US$ 7-15). Tempo: 7-15 dias. Esse é o degrau onde seu projeto deixa de ser “coisa de hobby” e vira produto.

    KiCad: Sua Primeira PCB em 30 Minutos

    O KiCad é um software open-source de design de PCBs, mantido pelo CERN, que compete de igual para igual com ferramentas que custam milhares de dólares. É o padrão da comunidade maker. Baixe em kicad.org — versão estável mais recente.

    O fluxo do KiCad tem quatro etapas principais. Vamos criar uma placa simples: um LED com resistor controlado por um ESP32, com conector de bateria e regulador de tensão.

    1. Esquemático (Eeschema)

    No esquemático, você desenha o circuito — não a placa física. É um diagrama lógico: quais componentes existem e como estão conectados. Aqui você:

    • Adiciona símbolos: resistor (R), LED, capacitor, regulador AMS1117-3.3V, conector de bateria
    • Atribui footprints (o formato físico de cada componente — ex: resistor 0805, LED 5mm through-hole, conector JST PH 2.0mm)
    • Conecta os pinos com wires — o clique é satisfatório
    • Roda a verificação elétrica (ERC) para garantir que não há pino de saída conectado a outro pino de saída, sem GND flutuando

    2. Layout da Placa (Pcbnew)

    Aqui a mágica (e o quebra-cabeça) acontece. Você arrasta os footprints para a posição desejada na placa e traça as trilhas de cobre que conectam os pinos conforme o esquemático. Dicas de ouro:

    • Componentes na frente, trilhas atrás: para sua primeira placa de duas camadas, coloque todos os componentes na camada superior (F.Cu) e faça as trilhas na inferior (B.Cu). Facilita a solda manual.
    • Trilhas de 0.5 mm para sinais, 1 mm para alimentação: as trilhas de VCC e GND carregam mais corrente — faça-as mais largas.
    • Plano de terra (ground pour): preencha as áreas vazias com cobre conectado ao GND. Reduz ruído, facilita o roteamento (menos trilhas de GND para traçar) e dá um visual profissional.
    • Rode o DRC (Design Rule Check): verifica se trilhas se tocam onde não deveriam, se os furos estão muito próximos, se o silk screen invade pads. Sempre faça o DRC antes de gerar os Gerbers.

    3. Gerar Gerbers

    No KiCad, Arquivo > Fabricar > Gerbers. Selecione as camadas F.Cu, B.Cu, F.Silkscreen, B.Silkscreen, F.Mask, B.Mask, Edge.Cuts. Gere também o ficheiro de furação (Excellon). Comprima tudo num .zip.

    4. Encomendar

    Vá para JLCPCB.com ou PCBWay.com, faça upload do .zip, escolha a cor da máscara de solda (verde é clássico, mas azul e preto são lindos), e confirme. A JLCPCB tem preços imbatíveis para protótipos — literalmente US$ 2 + frete para 5 placas. A PCBWay tem melhor acabamento e opções flexíveis, mas é um pouco mais cara.

    O Momento do Envelope

    Abrir o pacote que chegou da China e ver sua placa — com seu nome no silkscreen, com suas trilhas, seu layout — é uma das experiências mais gratificantes que existem na eletrônica.

    Você olha para aquele retângulo verde com detalhes brancos e percebe que todos os componentes que antes estavam soltos na breadboard agora têm um lugar definitivo. O que era temporário virou permanente. O que era frágil virou sólido. Não é só uma placa — é a materialização de uma ideia que passou pelo seu cérebro, pelas suas mãos, pelos servidores do KiCad e por uma fábrica do outro lado do mundo.

    Na primeira vez que você solda os componentes na sua PCB e ela funciona de primeira, a sensação é de que você venceu a entropia. E venceu mesmo.

    Fontes e Referências

  • Raspberry Pi: O Computador Que Cabe na Palma

    Raspberry Pi: O Computador Que Cabe na Palma

    Em 2006, Eben Upton trabalhava como diretor de estudos no St. John’s College, Cambridge. O problema que ele via ano após ano era desanimador: os candidatos ao curso de Ciência da Computação chegavam sabendo fazer websites e planilhas, mas nunca tinham mexido com hardware, nunca tinham programado em baixo nível, nunca tinham ligado um LED com código. Eles sabiam usar computadores, mas não sabiam o que eles eram.

    Raspberry Pi: O Computador Que Cabe na Palma
    Foto: rail fox ( flufftech.net ) — CC0 (via Wikimedia Commons, arquivo File:Raspberry Pi 4 on a network switch.jpg)

    Upton reuniu um time no Laboratório de Computação de Cambridge e passou seis anos projetando um computador que fosse barato o suficiente para qualquer adolescente comprar com a mesada, poderoso o suficiente para programar de verdade, e aberto o suficiente para hackear sem medo. Em 29 de fevereiro de 2012, o Raspberry Pi Modelo B foi lançado. O site da fundação caiu em minutos. Em 2026, mais de 60 milhões de unidades depois, o “pequeno computador que podia” virou um ecossistema.

    Do Pi 1 ao Pi 5: Uma Evolução Impressionante

    A primeira versão do Pi tinha um processador ARM de 700 MHz, 256 MB de RAM e uma porta HDMI. Parece piada hoje, mas em 2012 era revolucionário por US$ 35. A evolução foi consistente:

    • Raspberry Pi 1 (2012): 700 MHz, 256 MB RAM, 2 USB, Ethernet 100Mbps, HDMI
    • Raspberry Pi 2 (2015): 900 MHz quad-core, 1 GB RAM — finalmente utilizável como desktop leve
    • Raspberry Pi 3 (2016): 1.2 GHz, WiFi e Bluetooth integrados — IoT sem dongles USB
    • Raspberry Pi 4 (2019): 1.5 GHz, até 8 GB RAM, USB 3.0, dual HDMI 4K — um computador de verdade
    • Raspberry Pi 5 (2023): 2.4 GHz, até 16 GB RAM, PCIe 2.0, RTC integrado, GPU VideoCore VII — performance comparável a um laptop de entrada

    Hoje, para o maker, recomendo o Raspberry Pi 4 com 4 GB como ponto ideal custo-benefício. O Pi 5 é mais rápido, mas para servidores, automação e projetos maker, o Pi 4 já é overkill. Se você quer desktop replacement, vá de Pi 5 com 8 GB.

    O Que Um Raspberry Pi Pode Ser

    Diferente do Arduino (que é um microcontrolador — roda um programa de cada vez, sem sistema operacional), o Raspberry Pi é um computador completo rodando Linux. Isso expande radicalmente os casos de uso:

    • Servidor web: com Nginx ou Apache2, você hospeda sites, APIs, dashboards. Um Pi 4 aguenta tráfego moderado sem suar.
    • Home Assistant: a central de automação residencial mais popular do mundo roda que à uma beleza num Pi 4. Controle luzes, sensores, câmeras, tudo local, sem nuvem.
    • Pi-hole: bloqueador de anúncios e rastreadores para toda a rede doméstica. Instala em 10 minutos e transforma sua navegação.
    • Media center: com LibreELEC/Kodi, o Pi vira uma central multimédia que toca qualquer codec, de H.264 a HEVC (Pi 5 suporta 4K60 HEVC por hardware).
    • Console retrô: RetroPie ou Batocera emulam de Atari 2600 a PlayStation 1. O Pi 5 emula até Dreamcast e PSP com folga.
    • Estação meteorológica: sensores de temperatura, umidade, pressão barométrica e qualidade do ar conectados via GPIO, com dados armazenados em InfluxDB, visualizados no Grafana.
    • Cluster de Kubernetes: junte 3 ou 4 Raspberry Pis em um cluster com K3s para aprender orquestração de containers como se fosse um datacenter em miniatura.
    • Cérebro de robô: com ROS (Robot Operating System), o Pi processa visão computacional e tomada de decisão enquanto delega controle de motores para Arduinos conectados via serial.

    Primeiro Projeto em 15 Minutos

    Vamos instalar o Raspberry Pi OS, conectar via SSH e acender um LED com Python. Você vai precisar de: Raspberry Pi (qualquer modelo), cartão microSD de 16 GB+, fonte USB-C 5V 3A, um LED 5mm, resistor 220é, jumpers fêmea-macho e breadboard.

    1. Gravar o Sistema

    Baixe o Raspberry Pi Imager no seu computador principal. Insira o microSD, abra o Imager e escolha: Raspberry Pi Device > seu modelo, Operating System > Raspberry Pi OS (64-bit), Storage > seu cartão SD. Antes de gravar, clique na engrenagem para configurar: hostname (ex: piprojeto.local), usuário/senha, WiFi e — essencial — habilite SSH. Grave.

    2. Conectar via SSH

    Insira o microSD no Pi, conecte a fonte e espere 1-2 minutos. No seu computador, abra o terminal e conecte:

    ssh usuario@piprojeto.local

    Se não encontrar o hostname, descubra o IP do Pi no roteador ou use um scanner como nmap. Quando o prompt aparecer, você está dentro de um servidor Linux que cabe na palma da mão.

    3. Acender LED com Python

    Monte o circuito no GPIO: ânodo do LED (perna longa) no pino GPIO 17 (pino físico 11), cátodo via resistor de 220é no GND (pino físico 9). Agora instale a biblioteca GPIO e crie o script:

    sudo apt update
    sudo apt install python3-gpiozero -y
    nano led.py
    

    Dentro do nano, escreva:

    from gpiozero import LED
    from time import sleep
    
    led = LED(17)
    
    while True:
        led.on()
        sleep(1)
        led.off()
        sleep(1)
    

    Salve (Ctrl+O, Enter, Ctrl+X) e execute: python3 led.py. O LED pisca. Você acabou de conectar o mundo da computação Linux ao mundo físico dos componentes eletrônicos. Isso é extraordinário.

    Fontes e Referências

  • Solda, Ferro e Paciência

    Solda, Ferro e Paciência

    Existe um ponto cego na formação de todo maker que começa pela via digital: o Arduino, o ESP32, as placas prontas — tudo se conecta com jumpers e breadboard. Até o dia em que você precisa de um sensor que só vem SMD, ou quer passar seu protótipo de uma protoboard instável para algo permanente. Aí você encara o ferro de solda. E descobre que soldar não é sobre derreter metal — é sobre controle, paciência e a dura verdade de que no mundo físico não tem Ctrl+Z.

    Solda, Ferro e Paciência
    Wikimedia Commons — CC BY-SA 3.0, autor Tlapicka / CC BY-SA (https://creativecommons.org/licenses/by-sa/3.0)

    O Que Comprar (E O Que Não Comprar)

    Meu primeiro ferro de solda custou R$ 15 num camelô — era basicamente um pedaço de metal que esquentava sem controle nenhum. Durou duas semanas, queimou uma placa e me ensinou a lição mais cara do maker: ferramenta ruim custa mais caro que ferramenta boa, porque você paga duas vezes — na compra e no prejuízo.

    Para começar de verdade, você precisa de:

    • Ferro de solda com temperatura ajustável: mínimo 60W, display digital se possível. O modelo TS100 (ou seu sucessor TS101) é o padrão-ouro do maker portátil — alimentado por USB-C PD ou bateria, firmware open-source (IronOS), aquece em 8 segundos. Custa ~R$ 200-300. Alternativa mais em conta: estação Yihua 936 ou similares (~R$ 120-180 no Mercado Livre).
    • Ponta fina tipo B ou C: a ponta cônica (tipo I) que vem de fábrica é horrível para a maioria dos trabalhos. Ponta B (cônica arredondada) ou C (biselada) são muito melhores. O calor flui pela área de contato — quanto maior a área, mais rápida a solda.
    • Sugador de solda: aquele tubo azul com mola. Essencial para corrigir erros e dessoldar componentes. Prefira os de alumínio com ponta de silicone (~R$ 15-25).
    • Terceira mão: o braço articulado com garras jacaré que segura a placa enquanto você solda. Sem ela, você vai queimar os dedos. Com lupa integrada é ainda melhor. Preço: ~R$ 40-80.
    • Esponja de latão: melhor que esponja úmida para limpar a ponta. Não causa choque térmico, não reduz a temperatura da ponta, dura mais. Vem em formato de tigelinha metálica. Preço: ~R$ 15.
    • Fio de solda 60/40 (estanho/chumbo) de 0,8mm: não compre solda lead-free/ sem chumbo para aprender — ela exige temperaturas mais altas e molha pior. A 60/40 tem ponto de fusão mais baixo (183-190°C) e fluxo interno ( luxo de resina — procure por “rosin core”). Preço: ~R$ 15-30 por tubo.

    Total para um setup decente: entre R$ 200 e R$ 400. Parece caro? Compare com o preço de placas que você vai queimar usando ferro ruim.

    Técnica Básica: Os Quatro Passos

    O erro número um de quem aprende a soldar é achar que se trata de “derreter solda no ferro e pingar no componente”. Não é. O que você precisa fazer é aquecer simultaneamente a ilha (pad) da placa e o terminal do componente, e então aplicar o fio de solda no ponto aquecido — não no ferro. O fluxo de calor é: ferro → peça de trabalho → solda. Se você aplicar solda direto no ferro, o fluxo interno (resina) evapora antes de limpar a superfície, e a solda não adere.

    1. Estanhe a ponta: com o ferro ligado (330-350°C para solda 60/40), toque um pouco de solda na ponta para cobri-la com uma camada fina e brilhante. Isso melhora a transferência de calor. Limpe o excesso na esponja de latão.
    2. Aqueça a junta: encoste a ponta do ferro simultaneamente no pad da placa e no terminal do componente. Conte mentalmente “um, dois” — cerca de 1 a 2 segundos para componentes through-hole.
    3. Aplique a solda: com o ferro ainda tocando a junta, encoste o fio de solda no lado oposto ao ferro. A solda deve fluir, formando um cone brilhante ao redor do terminal. Não exagere — uma junta boa parece um pequeno vulcão prateado, não uma bola.
    4. Remova: retire primeiro o fio de solda, depois o ferro. Não sopre a solda para esfriar — deixe solidificar naturalmente, o que leva 1-2 segundos. Mexer o componente enquanto a solda esfria causa solda fria.

    Erros Clássicos (E Como Corrigir)

    • Solda fria: a junta fica opaca, granulada, fosca — em vez de brilhante e lisa. Causa: a peça de trabalho não aqueceu o suficiente ou você mexeu o componente antes da solidificação. Solução: reaqueça a junta com o ferro limpo e, se necessário, adicione um pouquinho de solda fresca (o fluxo fresco ajuda a fluir).
    • Ponte de solda: solda em excesso conecta dois terminais que não deveriam se tocar. Comum em CI com pinos próximos. Solução: use o sugador de solda ou — truque avançado — encoste a ponta limpa do ferro entre os pinos e use malha dessoldadora (solder wick) para absorver o excesso.
    • Superaquecimento: você deixou o ferro tempo demais e a ilha de cobre descolou da placa (lifted pad). Não tem solução fácil — você vai precisar seguir a trilha até o próximo ponto e fazer um jumper com fio fino. Prevenção: 2-3 segundos é suficiente. Se não soldou nesse tempo, a ponta está suja ou a temperatura está baixa.
    • Componente invertido: CI no sentido errado, capacitor eletrolítico com polaridade trocada. Alguns componentes explodem (eletrolítico), outros simplesmente não funcionam. Sempre confira a marcação de orientação — chanfro no CI, faixa no capacitor, lado chato no LED.

    Segurança: Sem Drama, Mas Sério

    Três regras que parecem óbvias até o dia em que você ignora uma:

    1. Ventilação: a fumaça da solda não é fumaça de metal — é o fluxo (resina) queimando. Contém formaldeído e outros irritantes. Abra a janela. Se possível, monte um extrator simples com cooler 12V e filtro de carvão ativado.
    2. Óculos de proteção: cortar terminais de resistor voa estanho para todo lado. O estanho no olho é uma experiência que você não quer ter. Sério.
    3. Nunca segure a peça com a mão: use a terceira mão, um prendedor ou fita crepe. O ferro de solda a 350°C no seu dedo queima antes de você registrar a dor.

    O Que Soldar Ensina (Além de Soldar)

    Depois de 20 anos soldando, a maior lição não tem nada a ver com eletrônica. Tem a ver com o fato de que existe um estado mental — um ritmo, quase — em que você está focado, calmo, preciso, e tudo flui. E existe o estado em que você está apressado, irritado, pensando em dez coisas, e cada solda sai fria, cada terminal entorta, cada placa estraga.

    Soldar é um medidor de ansiedade. Não tem como fazer correndo. Não tem atalho. Não tem undo. É uma das poucas atividades no mundo moderno que exige presença plena — e recompensa na mesma moeda. Quando a junta brilha do jeito certo, é pequeno triunfo. Merecido.

    Fontes e Referências

  • ESP32: O Arduino Que Aprendeu a Falar

    ESP32: O Arduino Que Aprendeu a Falar

    O Arduino Uno é um monge silencioso: faz o que você manda, rápido e sem distrações. O ESP32 é o amigo que acabou de descobrir a internet e quer te mostrar tudo ao mesmo tempo. Dual-core, WiFi, Bluetooth, 240 MHz, 520 KB de SRAM — tudo isso por menos de R$ 30 no Mercado Livre. Quando você conecta um ESP32 pela primeira vez, a pergunta deixa de ser “o que eu posso fazer com um microcontrolador” e passa a ser “o que eu não posso”.

    ESP32: O Arduino Que Aprendeu a Falar
    Wikimedia Commons — CC BY-SA 4.0, autor Brian Krent

    A História da Espressif

    A Espressif Systems foi fundada em 2008 em Xangai por Teo Swee Ann, um engenheiro de Cingapura que estudou na Universidade de Tsinghua. A empresa inicialmente focava em chips de rádio para aplicações de WiFi de baixo consumo. Em 2014, lançaram o ESP8266 — um módulo WiFi barato, originalmente pensado como ponte serial-para-WiFi para outros microcontroladores. Mas a comunidade hacker percebeu algo que a Espressif não tinha planejado: o ESP8266 tinha um processador bom o suficiente para rodar código próprio. Em meses, surgiram firmwares alternativos (NodeMCU, MicroPython) e a placa virou um microcontrolador independente com WiFi — por US$ 3.

    O ESP32 chegou em 2016 como a resposta madura a essa descoberta acidental: processador dual-core Tensilica Xtensa LX6, WiFi 802.11 b/g/n, Bluetooth 4.2 + BLE, 34 GPIOs, touch sensors, DAC, CAN bus, Ethernet MAC. A Espressif entendeu o recado: o mercado não queria um módulo WiFi auxiliar — queria um cérebro conectado.

    ESP32 vs. Arduino Uno vs. Raspberry Pi Pico

    Vamos ser diretos — números na mesa:

    Especificação Arduino Uno R3 ESP32 (WROOM) Raspberry Pi Pico (RP2040)
    Processador ATmega328P 8-bit Xtensa LX6 32-bit dual-core RP2040 ARM Cortex-M0+ dual-core
    Clock 16 MHz 240 MHz 133 MHz
    RAM 2 KB SRAM 520 KB SRAM 264 KB SRAM
    Flash 32 KB 4 MB (externo) 2 MB (externo)
    WiFi Não Sim Não (precisa do Pi Pico W)
    Bluetooth Não Sim Não
    GPIOs 14 (6 PWM) 34 (16 PWM) 26 (16 PWM)
    Preço (BR) ~R$ 70-120 ~R$ 25-50 ~R$ 20-40

    O ESP32 tem um hardware muito superior ao Arduino Uno pelo mesmo preço (ou menos). A diferença é que o ecossistema do Arduino é mais maduro para iniciantes: bibliotecas mais testadas, mais tutoriais, menos armadilhas. O ESP32 exige que você preste atenção em detalhes como nível lógico de 3.3V (conectar 5V nos GPIOs queima a placa), partição de memória e gerenciamento de energia. Mas a recompensa é uma placa que literalmente conversa com a internet.

    Primeiro Projeto Além do Blink: Conectar ao WiFi

    Se o ritual do Arduino é piscar um LED, o ritual do ESP32 é conectar ao WiFi. Vamos fazer isso em três passos.

    1. Preparar o Ambiente

    Na Arduino IDE, instale o suporte a ESP32: vá em Arquivo > Preferências > URLs adicionais de placas e cole:

    https://espressif.github.io/arduino-esp32/package_esp32_index.json

    Depois em Ferramentas > Placa > Gerenciador de Placas, busque por “ESP32” e instale o pacote “esp32 by Espressif Systems”. Selecione a placa “ESP32 Dev Module” e a porta COM correta.

    2. O Código

    #include <WiFi.h>
    
    const char* ssid = "NOME_DA_SUA_REDE";
    const char* password = "SENHA_DA_REDE";
    
    void setup() {
      Serial.begin(115200);
      WiFi.begin(ssid, password);
      
      Serial.print("Conectando");
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      
      Serial.println();
      Serial.print("Conectado! IP: ");
      Serial.println(WiFi.localIP());
    }
    
    void loop() {
      // Seu código principal aqui
    }
    

    3. O Que Fazer Depois

    Com WiFi, o ESP32 pode: enviar dados de sensores para a nuvem (MQTT, HTTP), receber comandos remotos, servir uma página web no seu navegador, acionar relés pelo celular, postar temperatura no ThingSpeak, criar um dashboard no Home Assistant. O limite não é mais o hardware — é sua imaginação.

    Dica Especial: ESP32-CAM

    Se você quer um projeto que impressiona visualmente, compre uma ESP32-CAM (R$ 30-50 no Mercado Livre). É um ESP32 com slot para câmera OV2640 de 2MP, slot para cartão microSD e LED de flash. Com ela você faz: câmera de segurança WiFi, timelapse, reconhecimento facial básico (com a biblioteca ESP-WHO da Espressif), fotografia remota. Só precisa de um programador FTDI externo para o primeiro upload — depois, OTA (Over-The-Air) resolve.

    No meu setup, tenho uma ESP32-CAM apontada para a impressora 3D transmitindo timelapse para um servidor local. Custo total: R$ 45 e uma tarde de sábado. Isso era projeto de empresa em 2015.

    O Futuro: ESP32-S3 e Além

    A Espressif não parou no ESP32 original. A família cresceu: ESP32-S2 (USB nativo, sem Bluetooth), ESP32-S3 (AI acceleration, USB OTG, mais GPIOs), ESP32-C3 (RISC-V, WiFi 6, Bluetooth 5), ESP32-C6 (WiFi 6 + Zigbee + Thread — Matter ready). Cada novo chip resolve uma lacuna diferente. Para começar, o ESP32 WROOM clássico ainda é o rei: barato, maduro, suportado por tudo.

    Fontes e Referências

  • Impressão 3D: A Fábrica na Sua Mesa

    Impressão 3D: A Fábrica na Sua Mesa

    Em 1984, Chuck Hull patenteou a estereolitografia, a primeira tecnologia de impressão 3D. Por quase três décadas, a fabricação aditiva ficou confinada a laboratórios industriais, com máquinas que custavam centenas de milhares de dólares. O que aconteceu entre 2009 e hoje é uma das maiores histórias de democratização tecnológica já contadas — e o protagonista não foi uma empresa, foi um professor britânico com uma ideia maluca: uma impressora capaz de imprimir a si mesma.

    Impressão 3D: A Fábrica na Sua Mesa
    Wikimedia Commons — CC BY-SA 4.0, autor HRostamani

    A Virada da Patente e o Efeito RepRap

    Em 2009, a patente central da tecnologia FDM (Fused Deposition Modeling), expirou. A Stratasys, detentora da patente, não podia mais impedir que outros fabricassem impressoras usando o mesmo princípio: um filamento plástico derretido, depositado camada por camada. Foi o sinal verde que Adrian Bowyer, da Universidade de Bath, esperava.

    Bowyer lançou o projeto RepRap (Replicating Rapid Prototyper) — uma impressora 3D de código aberto projetada para imprimir a maioria de suas próprias peças plásticas. A ideia era darwiniana: se a máquina pode se autorreplicar, ela evolui. E evoluiu. Da RepRap original nasceram dezenas de designs derivados — Mendel, Prusa i3, delta, CoreXY. Josef Průša, um desenvolvedor tcheco do projeto RepRap, fundou a Prusa Research em 2012. Hoje, a empresa dele é uma das maiores fabricantes de impressoras 3D do mundo, com mais de 1000 funcionários em Praga.

    FDM, SLA, SLS: Qual É Qual?

    Para o maker caseiro, três tecnologias importam:

    • FDM (Fused Deposition Modeling): Um filamento plástico (PLA, PETG, ABS, TPU) é derretido e extrudado por um bico aquecido, camada por camada. É a tecnologia mais barata, mais difundida e a que eu recomendo para começar. Resolução típica: 0,1–0,3mm por camada.
    • SLA (Stereolithography): Uma resina líquida é curada com luz UV (laser ou tela LCD). A resolução é absurdamente superior à FDM (0,025–0,05mm por camada), mas o pós-processamento envolve lavagem com álcool isopropílico e cura UV — é mais trabalhoso e os químicos são tóxicos. Para miniaturas, joias e peças de precisão, é imbatível.
    • SLS (Selective Laser Sintering): Um laser sinteriza pó de nylon, camada por camada. Não precisa de suportes (o pó não sinterizado serve como suporte natural). Para o maker caseiro, ainda é proibitivo em custo (~US$ 5000+), mas as patentes estão expirando e máquinas de entrada estão surgindo.

    O Que Procurar na Primeira Impressora em 2026

    O mercado de impressoras 3D FDM está num ponto incrível: máquinas que em 2018 custavam R$ 3000 hoje custam R$ 1200 e são melhores. Aqui está meu checklist:

    • Nivelamento automático: Não compre impressora sem auto-bed-leveling em 2026. Nivelar a mesa manualmente com um papel A4 é o principal motivo de desistência de iniciantes. Sensores de indução, BLTouch ou strain gauge — qualquer um serve, desde que seja automático.
    • Extrusor direct drive: O extrusor puxa o filamento e empurra para o hotend. No sistema Bowden, o motor fica longe do bico, causando retrações inconsistentes com filamentos flexíveis. Direct drive resolve isso.
    • Cama aquecida e magnética flexível: a cama magnética flexível é a melhor invenção desde o filamento PLA: você imprime, tira a placa, dobra levemente e a peça descola sozinha. Fim da espátula e dos dedos queimados.
    • Filamento compatível: no mínimo PLA e PETG. Se a máquina aguentar TPU e ABS, melhor — mas PLA cobre 80% dos casos de uso.

    No Brasil, marcas como Creality (Ender-3 V3 SE), Bambu Lab (A1 Mini) e Sovol (SV06) têm boa representação. A Ender-3 V3 SE é o meu “Arduino das impressoras 3D” — barata, enorme comunidade, peças de reposição em qualquer lugar.

    Não É Ferramenta, É Licença Para Criar

    O que a impressora 3D faz não é “imprimir objetos” — é transformar ideias em coisas num intervalo de horas. Antes dela, entre ter a ideia de um suporte, um encaixe, uma engrenagem e ter o objeto físico na mão, existiam semanas de espera, pedidos mínimos de fábrica, orçamentos que não compensavam para uma unidade.

    Agora você pensa num suporte para o celular que encaixa perfeitamente na sua mesa, modela no Fusion 360 ou no FreeCAD, fatia no PrusaSlicer ou Cura e, três horas depois, ele existe. Essa mudança é cognitiva: você começa a ver o mundo como uma coleção de objetos que poderiam ser diferentes — e você tem o poder de fazer essa diferença.

    Minha dica: comece com PLA (ácido polilático). É biodegradável, não tem cheiro forte, imprime em temperaturas baixas (~200°C) e não exige cama aquecida (embora ajude). Depois migre para PETG quando precisar de resistência mecânica — ele é o meio-termo entre a facilidade do PLA e a robustez do ABS, sem a toxicidade deste último.

    Software Para Começar

    Você vai precisar de dois tipos de software:

    Fontes e Referências

  • Seu Primeiro Projeto: O LED Que Mudou Tudo

    Seu Primeiro Projeto: O LED Que Mudou Tudo

    Existe um ritual de iniciação que todo maker, sem exceção, já executou. Não importa se você vai construir um robô autônomo ou uma estação meteorológica conectada à nuvem — você começa acendendo um LED. E quando aquele pontinho de luz vermelha pisca pela primeira vez obedecendo ao seu código, algo muda. O mundo físico, pela primeira vez, respondeu a você. Não é exagero dizer que esse momento é tão fundador quanto o primeiro “Hello, World” na tela do terminal. Só que aqui a saída não é texto — é fóton.

    Seu Primeiro Projeto: O LED Que Mudou Tudo
    Wikimedia Commons — CC BY-SA 3.0, autor Khaifuture

    Materiais

    Você precisa de quatro coisas. Literalmente quatro — uma quinta se você ainda não tiver instalado o software:

    • Arduino Uno R3 (original ou clone — Robocore R$ 119 ou FilipeFlop ~R$ 69)
    • LED vermelho difuso de 5mm (qualquer cor serve, mas vermelho é o clássico)
    • Resistor de 220Ω (código de cores: vermelho-vermelho-marrom-dourado)
    • Breadboard de 400 pontos (a placa branca com furinhos — FilipeFlop ~R$ 15)
    • Jumpers macho-macho (os fiozinhos coloridos)

    Custo total: entre R$ 80 e R$ 200 dependendo se você comprar o kit completo ou peças avulsas. Se puder, compre um kit iniciante Arduino na Robocore ou FilipeFlop — vem com dezenas de componentes e vai te poupar incontáveis idas ao Mercado Livre.

    Montagem

    O circuito é o mais simples possível depois de uma pilha e uma lâmpada — e ainda assim, cada elemento ensina algo:

    1. Encaixe o LED na breadboard. O LED tem polaridade: a perna mais longa é o ânodo (positivo, +), a mais curta é o cátodo (negativo, -). Se você inverter, nada queima — mas o LED não acende.
    2. Conecte o resistor de 220Ω em série com o cátodo. Um lado do resistor vai no mesmo trilho da breadboard que a perna curta do LED; o outro lado vai em um trilho vazio. Por que 220Ω? Porque o pino digital do Arduino fornece 5V. O LED vermelho consome ~2V e ~20mA. Lei de Ohm: R = (5V – 2V) / 0,02A = 150Ω. Usamos 220Ω para uma margem de segurança — o LED brilha um pouco menos e dura para sempre.
    3. Conecte o jumper do resistor para o GND do Arduino. O trilho onde está o lado livre do resistor vai conectado ao pino GND (terra) do Arduino.
    4. Conecte um jumper do ânodo (perna longa) para o pino digital 13. O pino 13 é especial — ele tem um LED built-in na própria placa. Se seu LED externo acender, o built-in também acende. Dois pelo preço de um.

    Pronto. Circuito montado. Agora a mágica.

    Código

    Abra a Arduino IDE (se ainda não instalou, baixe em arduino.cc/en/software). Copie e cole o código abaixo:

    // Projeto 01 — Blink
    // Seu primeiro código Arduino. Bem-vindo(a).
    
    void setup() {
      // setup() roda uma única vez, no início
      pinMode(13, OUTPUT);  // Configura o pino 13 como saída
    }
    
    void loop() {
      // loop() roda para sempre, repetidamente
      digitalWrite(13, HIGH);  // Liga o pino 13 (5V)
      delay(1000);             // Espera 1000 milissegundos = 1 segundo
      digitalWrite(13, LOW);   // Desliga o pino 13 (0V)
      delay(1000);             // Espera mais 1 segundo
    }
    

    Vamos entender cada linha — porque copiar e colar sem entender é o oposto do que significa ser maker:

    • void setup(): função que roda uma vez quando o Arduino liga. Aqui você configura o hardware: quais pinos são entrada, quais são saída.
    • pinMode(13, OUTPUT): diz ao Arduino que o pino 13 vai ENVIAR sinal (5V ou 0V), não RECEBER.
    • void loop(): função que roda em loop infinito depois do setup. É o coração do programa.
    • digitalWrite(13, HIGH): coloca 5 volts no pino 13 — o LED acende.
    • delay(1000): pausa o programa por 1000 milissegundos. O LED fica aceso por 1 segundo.
    • digitalWrite(13, LOW): coloca 0 volts no pino 13 — o LED apaga.

    Para fazer o upload: conecte o Arduino no USB, selecione em Ferramentas > Porta a porta COM correspondente, clique na seta para direita (Upload). Em segundos, o LED começa a piscar.

    O Que Acabou de Acontecer (E Por Que É Importante)

    Você escreveu instruções em C++ numa tela. Essas instruções foram compiladas para código de máquina. Um chip do tamanho da unha do seu polegar interpretou esse código e controlou a voltagem em um pino específico, fazendo elétrons fluírem por um componente que emite fótons visíveis ao olho humano — tudo isso num ritmo que VOCÊ definiu.

    Isso não é trivial. É a ponte entre o abstrato e o concreto. Daqui pra frente, todo sensor, todo motor, todo display segue o mesmo princípio: pinos que você controla pelo código. Você só precisa aprender a sintaxe de cada um — o conceito fundamental você já domina.

    Troubleshooting: Meu LED Não Acendeu

    Respire. Acontece com todo mundo. Aqui estão as causas mais comuns:

    • LED invertido? A perna longa (+) precisa estar conectada ao pino 13; a curta (-), ao GND via resistor. Inverta e teste.
    • Resistor errado? Se você usou um resistor muito alto (ex: 10kΩ marrom-preto-laranja), o LED acende, mas tão fraco que você não vê. Confira o código de cores.
    • Porta COM errada? Na IDE do Arduino, vá em Ferramentas > Porta e selecione a porta que aparece quando você conecta o Arduino. No Windows, geralmente é COM3, COM4 ou superior. Se nada aparecer, reinstale o driver CH340 (clones chineses usam esse chip).
    • Placa selecionada errada? Ferramentas > Placa > Arduino Uno.
    • Esqueceu o GND? Se o jumper do resistor não estiver conectado ao GND do Arduino, o circuito está aberto — corrente não flui.

    Desafio: Vá Além

    Agora que o LED pisca, modifique o código. Mude o delay para 100 milissegundos e veja o pisca-pisca frenético. Adicione um segundo LED no pino 12, com seu próprio resistor, e faça-os alternar. Use analogWrite() (em pinos PWM: 3, 5, 6, 9, 10, 11) para controlar o brilho do LED com valores de 0 a 255.

    Parabéns. Você acaba de entrar para o clube. A partir daqui, é só expandir — um sensor de cada vez, um módulo de cada vez, um projeto de cada vez. O primeiro LED é sempre o mais difícil. Os próximos são mais fáceis. E logo você estará montando coisas que nem imaginava serem possíveis.

    Fontes e Referências