Resultados de aprendizagem

1. Escrever o código de programação de um microcontrolador.
2. Interligar botões, sensores, motores e relés.
3. Ensaiar e depurar o programa e o circuito.

Microcontrolador contra microprocessador

Plataformas e como escolher

Escolher por: pinos, comunicação, tensão, memória, consumo, custo.

Especificar antes de programar

Três partes: entradas, saídas, regras com números.

Exemplo, rega automática:

• Entrada: humidade do solo (A0).
• Saída: relé da bomba (pino 7), LED de estado.
• Regra: abaixo de 30 % liga a bomba 10 s; no máximo 1 vez por hora; leitura fora da gama desliga e sinaliza erro.

"Regar quando estiver seco" não se programa. "Abaixo de 30 %" já se programa e testa.

Diagrama de blocos do ATmega328P

 Flash (32 KB) --> CPU: contador de programa
                   32 registos R0..R31 <--> ALU
 SRAM (2 KB)  <--> SREG (flags)
 EEPROM (1 KB)         |
                barramento de 8 bits
 Portas B,C,D | Timers 0,1,2 | ADC | UART | I2C | SPI

• Arquitetura Harvard: programa e dados em barramentos separados.
• Periféricos configuram-se por registos.

ALU e registo de estado

A ALU soma, subtrai e faz lógica sobre registos de 8 bits. O SREG guarda as flags: C, Z, N, V, S, H, T, I.

Exemplo · 200 + 100 em 8 bits

• 1100 1000 + 0110 0100 = 1 0010 1100
• O registo guarda 0010 1100 = 44; o nono bit vai para C = 1.

Num uint8_t o resultado em C também é 44.

As três memórias

• EEPROM: cerca de 100 000 escritas por célula (folha de características).
• Pilha cresce para baixo, heap para cima; se se cruzam, comportamento imprevisível.

Pinagem do Arduino UNO

Portas: D0 a D7 = D, D8 a D13 = B, A0 a A5 = C.

Limites elétricos

• Funcionamento a 5 V; nível alto a partir de cerca de 0,6 × Vcc, baixo até cerca de 0,3 × Vcc.
• Corrente por pino: recomendada ~20 mA, máximo absoluto 40 mA.
• Há também um limite para a corrente total do chip.

Do C ao código máquina

C/C++ (sketch) -> avr-gcc -> código máquina (.hex) -> Flash
assembly       -> assembler -> código máquina

Instruções AVR (RISC, ~130):

• Transferência: LDI, MOV, LD, ST, IN, OUT
• Aritméticas: ADD, SUB, INC, DEC
• Lógicas: AND, OR, EOR
• Bits: SBI, CBI
• Salto: CP, BRNE, RJMP, RET

Modos de endereçamento

Registos DDR, PORT e PIN

void setup() {
  DDRB  |= (1 << DDB5);    // pino 13 como saída
  PORTB |= (1 << PORTB5);  // HIGH
}
void loop() {
  PORTB ^= (1 << PORTB5);  // inverte
  delay(500);
}

Operações bit a bit

Exemplo · bits 2 e 5 a 1 com PORTB = 0100 0001:

• máscara 0010 0100
• 0100 0001 OU 0010 0100 = 0110 0101 (0x65)

0b1011 0100 = 0xB4 = 180.

Ambientes de desenvolvimento (IDE)

A linguagem: C/C++ para Arduino; MicroPython em RP2040 e ESP32 (mais fácil, mais pesado).

Configurar a plataforma

1. Instalar o IDE e, se necessário, o suporte da placa.
2. Ligar a placa por USB (driver CH340 nos clones).
3. Escolher placa e porta.
4. Testar com Blink.
5. Abrir o Monitor Série com o mesmo baud rate.

Instalar bibliotecas

Formas de instalar:

1. Gestor de Bibliotecas (recomendado).
2. Ficheiro .zip.
3. lib_deps no PlatformIO.

#include <Servo.h>
Servo braco;

Incluídas com o IDE: Servo, Wire, SPI, EEPROM, LiquidCrystal, Stepper.

Fluxogramas: simbologia

Norma: ISO 5807.

Fluxograma · termóstato com histerese

( Início ) -> [ Configurar pinos e Serial ]
   +-> [ Ler t ]
   |     < t > 26 ? > Sim -> [ Ligar ventoinha ]
   |         Não
   |     < t < 24 ? > Sim -> [ Desligar ventoinha ]
   |         Não
   |   [ Mostrar t ] -> [ Esperar 2 s sem bloquear ] --+
   +--------------------------------------------------+

Entre 24 e 26 o estado mantém-se: é a histerese.

Anatomia de um sketch

#include <Servo.h>            // bibliotecas
const int PINO_LED = 13;      // constantes e globais

void setup() {                // UMA vez
  pinMode(PINO_LED, OUTPUT);
}
void loop() {                 // para sempre
  piscar(3);
  delay(2000);
}
void piscar(int vezes) { /* ... */ }

Comentar o porquê, não o óbvio.

Tipos de dados (AVR)

Noutras placas int tem 4 bytes: usar uint8_t, int16_t, uint32_t.

Exemplo · overflow de um int

T (°C) = leitura × 500 / 1024 (LM35, 5 V, ADC 10 bits; graus inteiros)

int leitura = 66;
int graus = leitura * 500 / 1024;          // ERRADO
long graus2 = (long)leitura * 500 / 1024;  // certo

• 66 × 500 = 33 000 passa 32 767 e dá a volta: -32 536.
• -32 536 / 1024 = -31.
• Certo: 33 000 / 1024 = 32.

Converter o operando, não o resultado.

Variáveis e operadores

Operadores: + - * / %, == != < > <= >=, && \|\| !, & \| ^ ~ << >>.

Funções e modularidade

float lerTemperatura() {
  int leitura = analogRead(A0);
  float tensao = leitura * 5.0 / 1024.0;
  return tensao * 100.0;           // LM35
}
void aplicarControlo(float t) {
  digitalWrite(LED_ALERTA, t > 30.0 ? HIGH : LOW);   // LED de aviso
}

Uma função, uma responsabilidade. O loop() só orquestra.

Saída digital e LED

pinMode(9, OUTPUT);
digitalWrite(9, HIGH);   // 5 V
digitalWrite(9, LOW);    // 0 V

R = (Vcc - Vf) / I

Exemplo · LED vermelho: Vf ≈ 2,0 V, I = 15 mA.

• R = 3 / 0,015 = 200 Ω, normalizado 220 Ω
• I real = 3 / 220 = 13,6 mA
• P = 220 × 0,0136² = 0,041 W

Entrada digital: pull-up

pinMode(2, INPUT_PULLUP);
bool premido = (digitalRead(2) == LOW);

Pino sem nada ligado flutua e lê ruído.

Ressalto (debounce)

Contactos mecânicos saltam durante alguns ms: o µC lê vários toques.

// bloqueante (só em exemplos)
if (digitalRead(BTN) == LOW) {
  delay(20);
  if (digitalRead(BTN) == LOW) { /* válido */ }
}

Melhor: versão com millis(), que só aceita a mudança depois de 30 ms estáveis. Ou filtro RC em hardware.

Exemplo · botão que liga e desliga

bool ledLigado = false;
int anterior = HIGH;

void loop() {
  int atual = digitalRead(BTN);
  if (anterior == HIGH && atual == LOW) {  // flanco
    ledLigado = !ledLigado;
    digitalWrite(LED, ledLigado);
    delay(30);
  }
  anterior = atual;
}

Reage à mudança, não ao nível. Sem anterior, o LED piscaria enquanto o dedo estivesse no botão.

O conversor ADC

10 bits: 1024 níveis (0 a 1023) entre 0 V e Vref.

tensão = leitura × Vref / 1024

Resolução com 5 V: 4,88 mV. Com 1,1 V: 1,07 mV.

Conversão: cerca de 104 µs (~9600 leituras/s).

Exemplo · LM35 e resolução

LM35: 10 mV/°C. A 25 °C, 250 mV.

analogReference(INTERNAL); dá cerca de 4,5 vezes mais resolução, mas só mede até 1,1 V (110 °C no cálculo; confirmar a gama da variante do LM35 usada). Valores nominais: a referência real mede-se e calibra-se.

PWM: saída pseudo-analógica

O pino liga e desliga depressa; a fração ligada é o duty cycle.

analogWrite(pino, valor), valor 0 a 255, duty = valor / 255.

• Pinos PWM: 3, 5, 6, 9, 10, 11.
• ~490 Hz (3, 9, 10, 11) e ~980 Hz (5, 6).
• Duty 25 % dá 1,25 V médios; 50 %, 2,5 V; 75 %, 3,75 V.
• Servo usa o Timer1 e inutiliza o PWM em 9 e 10.

Divisor de tensão e LDR

Vcc -- [ LDR ] --+-- A0
                 |
              [10 kΩ]
                 |
                GND

Vout = Vcc × Rfixa / (Rfixa + Rsensor)

Exemplo · NTC de 10 kΩ

NTC (B = 3950) a Vcc, 10 kΩ a GND. Leitura 754.

1. R = 10 000 × (1024/754 - 1) = 3580 Ω
2. 1/T = 1/298,15 + ln(3580/10000)/3950
3. ln(0,358) = -1,0275 → 1/T = 0,003094 → T = 323,2 K
4. 50,0 °C

Valores R0 e B vêm da folha de características do NTC.

HC-SR04: distância por eco

Pulso de 10 µs no TRIG; o ECHO fica HIGH durante a ida e volta.

distância = tempo × 0,0343 / 2 (cm, µs)

Exemplo: 5830 µs → 5830 × 0,0343 = 199,97 → 100 cm.

unsigned long d = pulseIn(ECHO, HIGH, 30000UL);
if (d == 0) return -1.0;     // sem eco
return d * 0.0343 / 2.0;

Outros sensores e calibração

• PIR: HIGH ao detetar; tempo de estabilização depois de ligar.
• Fim de curso: pull-up e debounce.
• MQ-x: aquecimento e calibração; não é detetor certificado.
• Humidade do solo: calibrar com dois pontos.

Calibrar: dois pontos de referência → map → constrain → comparar com um instrumento fiável.

Atuadores: o pino comanda, não alimenta

Pino: ~20 mA. Ordens de grandeza das cargas:

• LED com resistência: 10 a 20 mA, ligação direta
• Relé (bobina): dezenas de mA, transístor ou módulo
• Motor DC pequeno: centenas de mA, transístor ou ponte H
• Motor de passo: driver dedicado
• Fitas de LED, bombas: amperes, MOSFET ou relé

Fonte própria e massa comum.

Exemplo · transístor para um relé

Bobina 70 mA, Vpino 5 V, Vbe ≈ 0,7 V.

Ganho mínimo hFE: o da folha de características do transístor (aqui assumimos 100).

1. Ganho forçado 10: Ib = 70 / 10 = 7 mA
2. Rb = (5 - 0,7) / 0,007 = 614 Ω
3. Normalizado 560 Ω: Ib = 4,3 / 560 = 7,7 mA (menos de 20 mA)

+V -- [CARGA] -- C
pino -- [Rb] -- B  NPN
                E -- GND (comum)

Cargas indutivas e alimentação

Motores e relés geram picos ao cortar a corrente.

• Díodo de roda livre em antiparalelo (1N4007 ou 1N4148).
• Fonte dimensionada para a corrente de arranque.
• GND comum entre Arduino e fonte.
• Não alimentar motores a partir da USB.
• Condensador junto à carga contra quedas e reinícios.

Servomotor

PWM de 50 Hz (período 20 ms); a largura do impulso é a posição (~1 a 2 ms).

#include <Servo.h>
Servo s;
void setup() { s.attach(9); }
void loop() {
  s.write(0);   delay(1000);
  s.write(180); delay(1000);
}

Por omissão 0° = 544 µs e 180° = 2400 µs; 90° = 1472 µs. Fonte própria, massa comum.

Motor DC e ponte H

void motor(int v) {            // -255 a 255
  digitalWrite(IN1, v > 0);
  digitalWrite(IN2, v < 0);
  analogWrite(ENA, abs(v));
}

motor(150) ≈ 59 % de duty. Parar antes de inverter.

Motor de passo

1,8° por passo → 360 / 1,8 = 200 passos por volta.

Driver (A4988): STEP e DIR; micropasso 1/16 = 3200 passos/volta.

Exemplo · 60 rpm:

• 1 volta/s = 200 passos/s
• intervalo = 1/200 = 5 ms
• com 1/16: 3200 passos/s → ~312 µs

Sondagem contra interrupção

• Polling: o programa pergunta a cada volta. Se o loop() é lento, o evento perde-se.
• Interrupção: o hardware pára a CPU, corre a ISR e retoma.

loop() ... ----[evento]----> ISR() ----> volta ao mesmo ponto

UNO: pinos 2 (INT0) e 3 (INT1). Modos: LOW, CHANGE, RISING, FALLING.

Escrever uma ISR

volatile unsigned int toques = 0;
void contar() { toques++; }

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), contar, FALLING);
}
void loop() {
  noInterrupts();
  unsigned int copia = toques;   // leitura atómica
  interrupts();
}

Regras: ISR curta; sem delay() (o millis() não avança lá dentro); variáveis partilhadas volatile; debounce comparando millis() com o último evento.

millis() em vez de delay()

const unsigned long INTERVALO = 1000;
unsigned long ultimo = 0;

void loop() {
  unsigned long agora = millis();
  if (agora - ultimo >= INTERVALO) {
    ultimo = agora;
    // tarefa periódica
  }
}

millis() volta a zero ao fim de 49,7 dias (2³² ms). A subtração funciona na mesma: 200 - 4 294 967 000 = 496 ms.

Temporizadores e modo CTC

Timer0 (8 bits), Timer1 (16 bits), Timer2 (8 bits). Prescaler 1, 8, 64, 256, 1024 no Timer0 e no Timer1; o Timer2 tem ainda 32 e 128.

O Timer0 dá o millis(): 16 MHz / 64 / 256 → overflow a cada 1,024 ms.

OCR1A = f_clk / (prescaler × f) - 1

Exemplo · 1 Hz, prescaler 256: 16 000 000 / 256 = 62 500; OCR1A = 62 499.

UART e Monitor Série

Assíncrona, TX e RX, velocidade combinada. Trama 8N1 = 10 bits por byte.

Exemplo · 9600 baud: Valor: 1023\r\n = 13 bytes → 130 bits → 130/9600 = 13,5 ms.

Serial.begin(9600);
if (Serial.available() > 0) { char c = Serial.read(); }

Velocidade diferente no Monitor = carateres estranhos.

I²C

Dois fios: SDA (A4) e SCL (A5), pull-ups, mestre e vários escravos de 7 bits.

Wire.beginTransmission(addr);
if (Wire.endTransmission() == 0) { /* presente */ }

SPI, 1-Wire e comparação

SPI no UNO: MOSI 11, MISO 12, SCK 13, SS 10.

Wi-Fi e Internet das Coisas

[sensor] -> [ESP32] --Wi-Fi--> [broker MQTT] -> [painel]

• HTTP: pedido e resposta.
• MQTT: publicar e subscrever por tópicos; leve.

Cuidados: sem palavras-passe no código partilhado, ligação cifrada quando possível, firmware atualizado, não expor sem necessidade.

Três tipos de erro

A linha reportada pelo compilador pode estar depois do erro real.

Depurar com o Monitor Série

1. Imprimir valores brutos (ADC, estado do pino).
2. Marcas de fluxo: "entrei em X".
3. Serial Plotter para ver o sinal ao longo do tempo.
4. Etiquetar: Serial.print("T="); Serial.println(t);
5. Remover as mensagens no fim (ocupam tempo e SRAM).

Num simulador (Wokwi, Tinkercad) vê-se o estado dos pinos sem risco.

Depuradores e breakpoints

Um depurador controla a execução no próprio µC:

• Pontos de pausa (breakpoints)
• Passo a passo: step over, step into, step out
• Watch de variáveis, pilha de chamadas, registos

Depurador de hardware: SWD ou JTAG nos ARM (ST-LINK no STM32); debugWIRE ou JTAG em alguns AVR (UNO precisa de sonda externa).

O Arduino IDE 2 e o PlatformIO integram-no nas placas que o suportam.

Depurar o circuito

Método: um periférico de cada vez, mudar uma coisa por vez.

Plano de ensaios

Os casos de fronteira são os que mais revelam erros.

Padrão ler, decidir, atuar

SENSOR -> DECISÃO (programa) -> ATUADOR
   ^                                |
   +----------- mundo físico <------+

Histerese em código:

const int RELE = 7;
const int RELE_ATIVO = LOW;   // módulo ativo a LOW; se for a HIGH, trocar

if (!ventoinha && t > LIGA)    ventoinha = true;
if (ventoinha  && t < DESLIGA) ventoinha = false;
digitalWrite(RELE, ventoinha ? RELE_ATIVO : !RELE_ATIVO);

Máquina de estados: alarme

            botão               PIR deteta
DESARMADO --------> ARMADO --------------> DISPARADO
    ^                 ^                        |
    +-----------------+---- botão -------------+

enum Estado { DESARMADO, ARMADO, DISPARADO };
switch (estado) {
  case DESARMADO: /* ... */ break;
  case ARMADO:    /* ... */ break;
  case DISPARADO: tone(BUZZER, 1000); break;
}

EEPROM e organização do projeto

#include <EEPROM.h>
EEPROM.get(0, limiar);
if (limiar < 0 || limiar > 1023) {
  limiar = 512;
  EEPROM.put(0, limiar);
}

update e put só escrevem se o valor mudou.

Projeto: cabeçalho, constantes, funções pequenas, loop() curto, F("..."), esquema atualizado, registo de ensaios, Git.

Erros comuns

• Entrada a flutuar; esquecer a lógica invertida.
• = em vez de ==.
• Divisão inteira e overflow de int.
• Motor ou relé direto no pino; sem díodo de roda livre.
• delay() longo.
• ISR demorada ou sem volatile.
• Baud rate diferente; placa e porta erradas.
• 5 V num pino de 3,3 V.
• Sensor sem calibração.
• Escrever na EEPROM a cada volta.

Síntese

• µC = CPU + Flash + SRAM + EEPROM + periféricos.
• Especificar, desenhar o fluxograma, depois programar.
• Cuidado com tipos: overflow e divisão inteira.
• Pull-up, debounce, ADC (V = L × Vref / 1024), PWM.
• Potência: transístor, driver ou relé, fonte própria, GND comum, flyback.
• millis(), interrupções e timers.
• UART, I²C, SPI, Wi-Fi.
• Depurar: Serial, simulador, multímetro, depurador.
• Ler, decidir, atuar, com plano de ensaios.