Arduino — Microcontroladores e Sistemas Embarcados
Microcontrolador vs Microprocessador
Ao longo deste curso estudamos CPUs (microprocessadores) em placas-mãe ATX e SoC. O Arduino representa um paradigma diferente: o microcontrolador — um computador completo em um único chip, projetado para controlar hardware diretamente.
Microprocessador (ex.: Intel Core i9): Microcontrolador (ex.: ATmega328P):
┌───────────────────────────────┐ ┌─────────────────────────────────┐
│ CPU Die │ │ ATmega328P │
│ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │ │ ┌─────┐ ┌──────┐ ┌─────────┐ │
│ │Core│ │Core│ │Core│ │Core│ │ │ │ CPU │ │Flash │ │ SRAM │ │
│ └────┘ └────┘ └────┘ └────┘ │ │ │(ALU)│ │ 32KB │ │ 2KB │ │
│ ┌─────────────────────────┐ │ │ └─────┘ └──────┘ └─────────┘ │
│ │ Cache L1/L2/L3 │ │ │ ┌───────┐ ┌─────────────────┐ │
│ └─────────────────────────┘ │ │ │ I/O │ │ Periféricos │ │
└───────────────────────────────┘ │ │ GPIO │ │ UART/SPI/I2C │ │
│ │ ADC │ │ Timer / PWM │ │
Precisa de: RAM externa (DDR5) │ └───────┘ └─────────────────┘ │
SSD externo └─────────────────────────────────┘
Chipset (PCH)
Placa-mãe Tudo já está dentro do chip.
Sistema operacional Roda sem SO — código direto.
| Aspecto | Microprocessador | Microcontrolador |
|---|---|---|
| Memória | RAM e armazenamento externos | Flash + SRAM + EEPROM integrados |
| Periféricos | Via chipset / expansão PCIe | GPIO, ADC, UART, I2C, SPI no chip |
| Sistema Operacional | Necessário (Linux, Windows) | Não necessário — bare metal |
| Potência | Alta (watt a centenas de watts) | Muito baixa (mW a watts) |
| Clock | GHz | MHz (8–240 MHz típico) |
| Preço chip | $100–$1.000 | $1–$10 |
| Uso | Computação geral | Controle de hardware embarcado |
Um microcontrolador executa o código diretamente no hardware, sem sistema operacional intermediário. O programa gravado na Flash executa a partir do reset — ciclo infinito, controle total e previsível sobre cada pino e temporização.
Arquitetura do ATmega328P — Arduino Uno
O ATmega328P é o microcontrolador do Arduino Uno, baseado na arquitetura AVR (RISC de 8 bits da Atmel/Microchip).
ATmega328P — Diagrama de blocos:
┌─────────────────────────────────────────────────────────────┐
│ ATmega328P │
│ │
│ ┌─────────────┐ ┌──────────┐ ┌────────────────────┐ │
│ │ Flash │ │ SRAM │ │ EEPROM │ │
│ │ 32 KB │ │ 2 KB │ │ 1 KB │ │
│ │ (programa) │ │ (variáv.)│ │ (dados permanentes│ │
│ └──────┬──────┘ └────┬─────┘ └────────────────────┘ │
│ │ │ │
│ ┌──────┴───────────────┴──────────────────────────────┐ │
│ │ CPU — ALU 8-bit │ │
│ │ Program Counter · Stack Pointer │ │
│ │ Registradores (R0–R31) │ │
│ └──────────────────────┬───────────────────────────────┘ │
│ │ │
│ ┌──────────────────────┴───────────────────────────────┐ │
│ │ Periféricos integrados │ │
│ │ ┌────────┐ ┌────────┐ ┌───────┐ ┌────────────────┐ │ │
│ │ │ GPIO │ │ ADC │ │ UART │ │ Timer/PWM/SPI/ │ │ │
│ │ │23 pinos│ │ 6 ch. │ │(TX/RX)│ │ I2C │ │ │
│ │ └────────┘ └────────┘ └───────┘ └────────────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Clock: até 16 MHz · Tensão: 3,3 V ou 5 V · TDP: ~0,2 W
Memória no Arduino
A memória do Arduino mapeia diretamente os tipos que estudamos no módulo de Tipos de Memória:
| Tipo | Onde | Uso | Tamanho (Uno) |
|---|---|---|---|
| Flash | Não volátil | Armazena o programa (sketch) | 32 KB |
| SRAM | Volátil | Variáveis em execução, stack | 2 KB |
| EEPROM | Não volátil | Dados que devem persistir após reset | 1 KB |
Com apenas 2 KB de SRAM, variáveis grandes, strings e buffers podem esgotar a memória. No Serial Monitor, a mensagem "SRAM overflow" causa comportamento imprevisível — não há sistema operacional para lidar com isso.
Pinos e Periféricos
GPIO — General Purpose Input/Output
Os pinos GPIO são o coração do Arduino — cada um pode ser configurado como entrada ou saída digital, ler sensores ou acionar atuadores:
Arduino Uno — layout de pinos:
┌─────────────────────────────────────────────┐
│ ARDUINO UNO │
│ │
│ Pinos Digitais: D0–D13 (14 pinos) │
│ ┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐ │
│ │D0││D1││D2││D3││D4││D5││D6││D7│... │
│ └──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘ │
│ D0=RX, D1=TX (UART) │
│ D3,D5,D6,D9,D10,D11 = PWM (~ marcado) │
│ D10=SS, D11=MOSI, D12=MISO, D13=SCK (SPI) │
│ D18=SDA, D19=SCL (I2C) │
│ │
│ Pinos Analógicos: A0–A5 (6 pinos) │
│ ┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐ │
│ │A0││A1││A2││A3││A4││A5│ │
│ └──┘└──┘└──┘└──┘└──┘└──┘ │
│ ADC 10-bit: 0–5V → 0–1023 (1024 níveis) │
└─────────────────────────────────────────────┘
PWM — Pulse Width Modulation
O PWM simula uma saída analógica variando a largura do pulso digital:
PWM 0% (LOW): ___________________________________________
PWM 25%: ████___████___████___████___████___████___
PWM 50%: ████████____████████____████████____
PWM 75%: ████████████____████████████____
PWM 100% (HIGH): ████████████████████████████████████████
Usado para: intensidade de LEDs, velocidade de motores DC, controle de servos.
ADC — Conversor Analógico-Digital
O Arduino não entende tensões contínuas diretamente — o ADC converte um sinal analógico (0–5V) em um número digital (0–1023):
Sensor de temperatura → 2,5V analógico
│
┌────┴────┐
│ ADC │
│ 10-bit │ → 512 (valor digital)
└─────────┘
(2,5V / 5V) × 1024 = 512
Barramentos no Arduino
Os barramentos seriais do Arduino correspondem exatamente aos barramentos que existem na placa-mãe, em versões menores e mais simples. Consulte o módulo Barramentos para o contexto em PCs.
UART — Universal Asynchronous Receiver-Transmitter
Arduino ──TX──►──RX── Computador (via USB-Serial)
Arduino ◄─RX──◄──TX── Computador
Características:
- 2 fios (TX e RX)
- Assíncrono: não usa clock separado
- Full-duplex: envia e recebe ao mesmo tempo
- Velocidade típica: 9600 a 115200 baud
- Uso: Serial Monitor, GPS, módulo Bluetooth HC-05
I2C — Inter-Integrated Circuit
Arduino ──SDA──────┬────┬────┬── Dispositivos
──SCL──────┴────┴────┘
Dev.1 Dev.2 Dev.3
Características:
- 2 fios (SDA = dados, SCL = clock)
- Multi-master, multi-slave (até 127 dispositivos)
- Endereçamento: cada dispositivo tem endereço único (7 bits)
- Velocidade: 100 kHz (Standard) / 400 kHz (Fast)
- Uso: sensores (temperatura, pressão), displays OLED, RTC
SPI — Serial Peripheral Interface
Arduino ──MOSI──────┬────┬── Dispositivos
──MISO──────┴────┘
──SCK───────┬────┘
──SS(CS)────┴──── (um pino CS por dispositivo)
Características:
- 4 fios (MOSI, MISO, SCK, SS/CS)
- Síncrono: usa clock (SCK)
- Full-duplex e muito rápido (até MHz)
- Um pino SS por dispositivo escravo
- Uso: cartão SD, display TFT, módulo RF nRF24L01
| Barramento | Fios | Velocidade | Dispositivos | Uso típico |
|---|---|---|---|---|
| UART | 2 (TX, RX) | ~115 kbps | 1–1 (ponto a ponto) | Debug, GPS, Bluetooth |
| I2C | 2 (SDA, SCL) | 100–400 kbps | Até 127 | Sensores, displays |
| SPI | 4 (MOSI, MISO, SCK, SS) | 1–10 Mbps | Múltiplos (1 SS/dev.) | SD card, TFT, RF |
Família Arduino — Evolução
| Placa | Chip | Arquitetura | Flash | SRAM | Clock | Destaques |
|---|---|---|---|---|---|---|
| Uno R3 | ATmega328P | AVR 8-bit | 32 KB | 2 KB | 16 MHz | Mais popular, fácil de usar |
| Mega 2560 | ATmega2560 | AVR 8-bit | 256 KB | 8 KB | 16 MHz | Mais pinos (54 digitais) |
| Nano | ATmega328P | AVR 8-bit | 32 KB | 2 KB | 16 MHz | Compacto (mini breadboard) |
| Due | AT91SAM3X8E | ARM Cortex-M3 | 512 KB | 96 KB | 84 MHz | 32-bit, 3,3V |
| Nano 33 IoT | SAMD21 + NINA-W102 | ARM Cortex-M0+ | 256 KB | 32 KB | 48 MHz | WiFi + Bluetooth integrados |
| Portenta H7 | STM32H747 | ARM Cortex-M7+M4 | 2 MB | 1 MB | 480 MHz | Dual-core, visão computacional |
Ciclo de Execução — Como o Arduino Roda
RESET / POWER ON
│
▼
Bootloader (gravado em Flash) → verifica se há upload pendente via USB
│
▼ (nenhum upload → executa o programa)
setup() executa uma vez
└── configura pinos, inicia UART, inicializa sensores
│
▼
loop() executa para sempre (while true)
├── lê sensores (digitalRead, analogRead)
├── processa dados
└── age sobre atuadores (digitalWrite, analogWrite)
│
└────────────────────── (repete loop() indefinidamente)
Diferente de um PC que tem um scheduler de SO gerenciando processos, o Arduino executa uma coisa por vez, sem interrupções externas (exceto se programadas via ISR — Interrupt Service Routines).
Shields — Expansão Modular
Os shields são placas de expansão que se encaixam sobre o Arduino — analogia direta aos cards PCIe de uma placa-mãe ATX:
| Shield | Função | Analogia PC |
|---|---|---|
| Ethernet Shield | Conectividade de rede | Placa de rede PCIe |
| Motor Shield | Controle de motores DC/paso a paso | Controladora SATA (move coisas) |
| SD Card Shield | Armazenamento em cartão SD | SSD M.2 |
| GSM Shield | Comunicação celular 2G/3G | Modem |
| Sensor Shield | Facilita conexão de sensores | Hub USB |
Stack de Shields:
┌────────────────┐ ← Shield 3 (ex.: LCD/Display)
├────────────────┤ ← Shield 2 (ex.: Motor Driver)
├────────────────┤ ← Shield 1 (ex.: Ethernet)
└────────────────┘ ← Arduino Uno (base)
Cada shield se conecta aos pinos do Arduino por baixo
e expõe os mesmos pinos por cima (pass-through)
Arduino vs Raspberry Pi
Dois dos dispositivos mais usados em educação de hardware — mas com propósitos fundamentalmente diferentes:
| Aspecto | Arduino Uno | Raspberry Pi 5 |
|---|---|---|
| Tipo | Microcontrolador | Computador SoC completo |
| Sistema operacional | Não — bare metal | Sim — Linux (Raspberry Pi OS) |
| CPU | ATmega328P @ 16 MHz | ARM Cortex-A76 @ 2,4 GHz |
| RAM | 2 KB SRAM | 4–8 GB LPDDR4X |
| Armazenamento | 32 KB Flash | Cartão microSD (8 GB+) |
| GPIO | 23 pinos (direto no chip) | 40 pinos (via chip de I/O) |
| Tempo de boot | Instantâneo (~ms) | ~10–30 segundos |
| Consumo | ~0,2 W | ~5–12 W |
| Custo | ~$25 | ~$80 |
| Ideal para | Controle em tempo real, sensores, atuadores | Processamento, câmera, IA, servidor |
Arduino: quando precisar de resposta em tempo real (ex.: piscar LED exatamente a cada 100ms, ler sensor a cada 10ms, controlar motor DC com precisão).
Raspberry Pi: quando precisar de processamento de dados, rede, câmera, interface gráfica ou rodar software complexo (Python, servidor web, reconhecimento de imagem).
Os dois juntos: Arduino faz o controle de hardware em tempo real e envia dados via UART/I2C para o Raspberry Pi, que processa e exibe resultados — arquitetura híbrida muito comum.
Aplicações e Contexto
O Arduino é amplamente usado em:
- Educação: ensino de eletrônica, programação e sistemas embarcados
- Robótica: controle de motores, servos e sensores de distância
- IoT (Internet of Things): coleta de dados ambientais, automação residencial
- Prototipagem rápida: validar ideias de produto antes de produzir hardware customizado
- Arte e instalações interativas: sensores + LEDs + motores em instalações artísticas
Os conceitos deste curso aparecem diretamente no Arduino:
- Tipos de Memória → Flash (programa), SRAM (variáveis), EEPROM (dados persistentes)
- Barramentos → UART, I2C, SPI implementados nos pinos do chip
- Fatores de Forma → a placa Arduino Uno é um Mini-PCB de 68 mm × 53 mm
- Gestão Térmica → microcontroladores consomem mW — dissipação raramente é um problema
Explorar Mais
Após entender os microcontroladores, vale revisitar os módulos principais com esse novo olhar:
- ➡️ Barramentos → — I2C, SPI e UART do Arduino existem em versões mais rápidas na placa-mãe (DMI, PCIe, USB)
- ➡️ Integração dos Componentes → — o fluxo CPU↔RAM↔GPU em PCs contrasta com o ciclo setup/loop bare-metal do Arduino
- ➡️ Atividades Práticas → — exercícios que consolidam o conteúdo completo do curso