UC02842

Artefactos tangíveis — Arduino

Sensores, actuadores, electrónica criativa

Curso profissional · 50h · Hardware + código

Plano

  1. Arduino — landscape
  2. Setup e primeiro sketch
  3. Digital I/O — LEDs e botões
  4. Analog I/O — sensores
  5. PWM, motores, servos
  6. LCD, OLED, displays
  7. Comunicação série, I2C, SPI
  8. Projecto integrado

Bloco 1 · O que é Arduino

Arduino — visão geral

  • Plataforma open-source de microcontroladores.
  • Fundada em 2005 em Ivrea, Itália.
  • Hardware barato (€5-€30 por board) + IDE gratuita.
  • Comunidade enorme, milhares de tutoriais e libraries.

Para makers, estudantes, artistas, engenheiros — quem queira mexer em electrónica + código.

Boards populares

  • Arduino Uno (R3 ou R4): clássico, recomendado para começar.
  • Arduino Nano: pequeno, breadboard-friendly.
  • Arduino Mega: mais pinos, projectos grandes.
  • Arduino Leonardo: USB nativo (pode ser teclado/rato).
  • ESP32 / ESP8266: WiFi + Bluetooth integrados (IoT).
  • Raspberry Pi Pico: alternativa moderna RP2040.

Onde se usa

  • Educação: STEM em escolas.
  • Prototipagem: produtos antes de fabricar.
  • Arte interactiva: instalações museológicas.
  • DIY: domótica, estações meteorológicas.
  • Robótica: amador e académico.
  • Industrial light: PoCs e instrumentação.

Bloco 2 · Setup

IDE + driver

  1. Download Arduino IDE 2.x em arduino.cc.
  2. Liga Uno via USB.
  3. Tools → Board → Arduino Uno.
  4. Tools → Port → selecciona (/dev/ttyUSB0, COM3, etc.).

Alternativa moderna: VSCode + PlatformIO.

Hello world — Blink

// O LED interno (pino 13) pisca cada segundo.

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

Click Upload (seta). LED pisca.

Estrutura de um sketch

// Variáveis globais
int pinoLED = 13;

void setup() {
  // Corre 1 vez no arranque
  pinMode(pinoLED, OUTPUT);
  Serial.begin(9600);    // comunicação série
}

void loop() {
  // Corre repetidamente para sempre
  digitalWrite(pinoLED, HIGH);
  Serial.println("LED ON");
  delay(500);
  digitalWrite(pinoLED, LOW);
  delay(500);
}

Bloco 3 · Digital I/O

LED externo

Pino 8 ──[R 220Ω]──[LED+ → LED-]── GND

const int LED = 8;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(500);
  digitalWrite(LED, LOW);
  delay(500);
}

Sempre resistência (220-330Ω) com LEDs (senão queimam).

Botão como input

5V ──[R 10kΩ pull-up]──┬── Pino 2
                       │
                      [Botão]
                       │
                      GND

Ou usar pull-up interna:

const int BOTAO = 2;
const int LED = 8;

void setup() {
  pinMode(BOTAO, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}

void loop() {
  int estado = digitalRead(BOTAO);
  // INPUT_PULLUP: HIGH = solto, LOW = premido
  digitalWrite(LED, estado == LOW ? HIGH : LOW);
}

Debounce

Botões mecânicos "ressaltam" — várias leituras a cada toque.

int estadoAnterior = HIGH;
unsigned long ultimoToque = 0;
const unsigned long DEBOUNCE_MS = 50;

void loop() {
  int estado = digitalRead(BOTAO);
  
  if (estado != estadoAnterior 
      && millis() - ultimoToque > DEBOUNCE_MS) {
    ultimoToque = millis();
    if (estado == LOW) {
      // Premiu
      Serial.println("Click!");
    }
    estadoAnterior = estado;
  }
}

Bloco 4 · Analog I/O

Analog input (sensores)

Pinos A0-A5: leem 0-5V → valor 0-1023 (10 bits).

const int POT = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int valor = analogRead(POT);
  float voltagem = valor * (5.0 / 1023.0);
  Serial.print("Raw: ");
  Serial.print(valor);
  Serial.print(" → ");
  Serial.print(voltagem, 2);
  Serial.println("V");
  delay(200);
}

Sensores comuns

  • Potenciómetro: tensão variável manual.
  • LDR (foto-resistência): mede luz.
  • NTC: termistor (temperatura).
  • TMP36: temperatura linear precisa.
  • MQ-x: gases.
  • HC-SR04: distância ultrassónica.
  • DHT11/22: temperatura + humidade.
  • MPU6050: acelerómetro + giroscópio.

Sensor de temperatura TMP36

TMP36: pino + → 5V
       pino sinal → A0
       pino - → GND

void loop() {
  int raw = analogRead(A0);
  float voltagem = raw * (5.0 / 1023.0);
  float tempC = (voltagem - 0.5) * 100.0;
  
  Serial.print("Temp: ");
  Serial.print(tempC, 1);
  Serial.println(" °C");
  delay(1000);
}

DHT22 (mais fiável)

#include <DHT.h>

#define DHT_PIN 2
DHT dht(DHT_PIN, DHT22);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  if (isnan(h) || isnan(t)) {
    Serial.println("Erro de leitura!");
    return;
  }
  
  Serial.print(t, 1);
  Serial.print("°C, ");
  Serial.print(h, 1);
  Serial.println("%");
  delay(2000);
}

Instalar library "DHT sensor library" (Tools → Manage Libraries).

Bloco 5 · PWM, motores, servos

PWM — analogWrite

Pinos com "~" (3, 5, 6, 9, 10, 11) suportam PWM.

analogWrite(pin, valor) — valor 0 (off) a 255 (full).

// LED fade
const int LED = 9;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  for (int v = 0; v <= 255; v++) {
    analogWrite(LED, v);
    delay(10);
  }
  for (int v = 255; v >= 0; v--) {
    analogWrite(LED, v);
    delay(10);
  }
}

Servo motor

#include <Servo.h>

Servo meuServo;

void setup() {
  meuServo.attach(9);
}

void loop() {
  // Varrer 0° → 180°
  for (int ang = 0; ang <= 180; ang += 5) {
    meuServo.write(ang);
    delay(50);
  }
  // E voltar
  for (int ang = 180; ang >= 0; ang -= 5) {
    meuServo.write(ang);
    delay(50);
  }
}

Servos: 5V, GND, sinal. Library <Servo.h> built-in.

Motor DC com transistor / ponte H

  • LED é fraco — pode ligar directo ao pino.
  • Motor DC puxa muita corrente — usar transistor (BC547, 2N2222) ou ponte H (L293D, L298N).
  • Para bidireccional: ponte H obrigatória.
// L293D — controlar motor
const int IN1 = 7, IN2 = 8, EN = 9;

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(EN, OUTPUT);
}

void andarFrente(int velocidade) {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(EN, velocidade);   // 0-255
}

Bloco 6 · Displays

LCD 16x2 (HD44780, com I2C)

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.print("Ola mundo!");
  lcd.setCursor(0, 1);
  lcd.print("Linha 2");
}

void loop() {}

Endereço I2C varia (0x27, 0x3F). Sketch i2c_scanner detecta-o.

OLED (SSD1306)

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define WIDTH 128
#define HEIGHT 64
Adafruit_SSD1306 display(WIDTH, HEIGHT, &Wire, -1);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("Olá!");
  display.display();
}

void loop() {}

Bonitos, monocromáticos, baixo consumo. €3-5.

Bloco 7 · Comunicação

Serial — debug

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.print("Valor: ");
  Serial.println(analogRead(A0));
  delay(500);
}

Serial Monitor (Tools → Serial Monitor, 9600 baud) mostra output.

Util para debugging — Serial.println() em vez de print do Python.

I2C — dois fios (SDA, SCL)

Protocolo para vários dispositivos com 2 fios. Cada dispositivo tem endereço único.

Comum em: LCDs, OLEDs, RTCs, sensores BME280/MPU6050.

#include <Wire.h>

void setup() {
  Wire.begin();   // master
  Serial.begin(9600);
}

// I2C scanner para encontrar dispositivos
void loop() {
  for (int a = 1; a < 127; a++) {
    Wire.beginTransmission(a);
    if (Wire.endTransmission() == 0) {
      Serial.print("Found: 0x");
      Serial.println(a, HEX);
    }
  }
  delay(5000);
}

SPI — mais rápido, 4 fios

MISO, MOSI, SCK, SS. Para SD cards, displays grandes, sensores rápidos.

Library <SPI.h> para o bus, library do dispositivo para o protocolo.

Bloco 8 · Boas práticas

Hardware

  • Sempre desligar antes de mexer em fios.
  • Polaridade: LEDs, capacitores electrolíticos, ICs.
  • Resistências de protecção em LEDs (220-330Ω) e bases de transistores.
  • Pull-ups/pull-downs em entradas (evita flutuar).
  • GND comum entre tudo.
  • Tensão certa (5V Uno, 3.3V ESP32 / Nano 33).

Software

  • delay() bloqueia — para multi-tarefas, usar millis().
  • Variáveis globais poucas e bem nomeadas.
  • const quando não muda.
  • Modularizar com funções e tabs (.h/.cpp no projecto).
  • Libraries quando possível (não reinventar).

Multi-tasking com millis()

// Pisca LED + lê sensor sem bloquear

unsigned long ultimoBlink = 0;
unsigned long ultimaLeitura = 0;
bool ledOn = false;

void loop() {
  unsigned long agora = millis();
  
  if (agora - ultimoBlink > 500) {
    ultimoBlink = agora;
    ledOn = !ledOn;
    digitalWrite(LED, ledOn ? HIGH : LOW);
  }
  
  if (agora - ultimaLeitura > 1000) {
    ultimaLeitura = agora;
    Serial.println(analogRead(A0));
  }
}

UC02842 · resumo

  • Arduino = microcontrolador acessível, perfeito para começar.
  • Digital I/O (LEDs, botões) com pull-ups.
  • Analog input (0-1023) lê sensores.
  • PWM (analogWrite) controla intensidade.
  • Servos e motores com libraries.
  • LCD/OLED via I2C.
  • Serial Monitor essencial para debug.
  • millis() > delay() para multi-tarefas.
  • Base para IoT, robótica, projectos físicos.

NOTAS DO PROFESSOR 📖 Arduino como porta de entrada na electrónica O Arduino democratizou a electrónica embebida ao juntar hardware barato, software gratuito e uma comunidade enorme. O valor pedagógico está em poder errar sem grande custo: uma board de poucos euros tolera muitas experiências. Convém transmitir que o Arduino não é só para hobby, mas serve também de prototipagem séria em engenharia. 🗣️ Pontos a desenvolver oralmente • Situar o nascimento do projecto em Ivrea e a filosofia open source • Dar exemplos reais de electrónica criativa feita com Arduino • Reforçar que o baixo custo permite aprender por tentativa e erro

NOTAS DO PROFESSOR 📖 Escolher a board certa para cada projecto Existe um Arduino para cada necessidade, e parte do trabalho do técnico é saber escolher. O Uno é o ponto de partida natural pela robustez e quantidade de tutoriais; o Nano cabe numa breadboard; o ESP32 abre as portas ao IoT com WiFi e Bluetooth integrados. Distinguir as boards evita comprar a errada para o projecto. 🗣️ Pontos a desenvolver oralmente • Justificar começar pelo Uno antes de avançar para boards mais específicas • Explicar quando o ESP32 se torna obrigatório por causa da conectividade • Comparar número de pinos e tamanho consoante a aplicação

NOTAS DO PROFESSOR 📖 O alcance transversal da plataforma A diversidade de aplicações mostra que estas competências são transferíveis para muitas áreas. Da sala de aula à instalação de arte interactiva, da domótica caseira à instrumentação industrial, o mesmo conjunto de princípios aplica-se. Esta amplitude motiva e ajuda cada formando a relacionar a matéria com os seus próprios interesses. 🗣️ Pontos a desenvolver oralmente • Pedir exemplos de projectos que cada formando gostaria de construir • Mostrar um caso de arte interactiva e um caso de domótica • Esclarecer os limites do Arduino face a controlo industrial pesado

NOTAS DO PROFESSOR 📖 Preparar o ambiente e selecção de porta A selecção correcta da board e da porta é o primeiro obstáculo prático e onde muitos iniciantes ficam presos. Vale a pena dedicar tempo a mostrar como identificar a porta certa em diferentes sistemas operativos e a resolver problemas de driver. Mencionar o PlatformIO abre caminho para quem queira um fluxo mais profissional. 🗣️ Pontos a desenvolver oralmente • Demonstrar a selecção de Board e Port com a board ligada por USB • Antecipar erros comuns de driver e como diagnosticá-los • Comparar a IDE oficial com o ecossistema VSCode mais PlatformIO

NOTAS DO PROFESSOR 📖 O Blink como primeiro sucesso garantido O Blink é o "Olá mundo" do hardware e o primeiro momento em que o código produz um efeito físico visível. Esse instante em que o LED pisca é poderoso pedagogicamente: prova que toda a cadeia, da IDE ao chip, funciona. Usar o LED interno evita ter de montar circuito, garantindo um arranque sem frustração. 🗣️ Pontos a desenvolver oralmente • Sublinhar o efeito motivador de ver código a controlar algo físico • Explicar linha a linha o pinMode e o digitalWrite com delay • Mostrar que alterar o delay muda imediatamente o comportamento

NOTAS DO PROFESSOR 📖 As duas funções obrigatórias do sketch Todo o sketch Arduino assenta em duas funções: setup, que corre uma vez no arranque, e loop, que se repete indefinidamente. Compreender esta estrutura é essencial para perceber onde colocar cada coisa: configuração no setup, comportamento contínuo no loop. O Serial.begin no setup é o que permite depois ver mensagens no computador. 🗣️ Pontos a desenvolver oralmente • Distinguir claramente o que vai para setup e o que vai para loop • Explicar que o loop nunca termina enquanto a board estiver ligada • Introduzir o Serial como ferramenta de diagnóstico desde já

NOTAS DO PROFESSOR 📖 Porque o LED precisa sempre de resistência Ligar um LED a um pino exige uma resistência em série para limitar a corrente, sob pena de o queimar a ele ou de danificar o pino. Este é um ponto de segurança eléctrica que deve ser repetido até virar hábito. Também é a oportunidade para introduzir polaridade: o LED só acende na orientação correcta. 🗣️ Pontos a desenvolver oralmente • Explicar a função da resistência limitadora com a lei de Ohm de forma simples • Mostrar o que distingue o ânodo do cátodo num LED real • Demonstrar que inverter o LED simplesmente não acende

NOTAS DO PROFESSOR 📖 Ler entradas e o papel da pull-up Ler um botão exige perceber que uma entrada digital não pode ficar "a flutuar": precisa de uma resistência pull-up ou pull-down para ter um estado definido. O INPUT_PULLUP interno simplifica o circuito ao dispensar a resistência externa, mas inverte a lógica (premido = LOW). Esta inversão confunde muitos iniciantes e merece atenção. 🗣️ Pontos a desenvolver oralmente • Explicar o conceito de entrada a flutuar e os seus efeitos erráticos • Comparar pull-up externa com a pull-up interna do microcontrolador • Reforçar que com INPUT_PULLUP o botão premido lê LOW

NOTAS DO PROFESSOR 📖 Debounce: domar o ressalto mecânico Os contactos mecânicos não fecham de forma limpa: ressaltam, gerando várias leituras por toque. Sem debounce, um único clique pode contar como vários, o que estraga contadores e menus. A técnica baseada em millis introduz, de forma natural, a ideia de comparar tempos sem bloquear o programa. 🗣️ Pontos a desenvolver oralmente • Mostrar com o Serial as múltiplas leituras de um clique sem debounce • Explicar o intervalo de 50 ms como janela de estabilização • Antecipar o uso de millis para temporização não bloqueante

NOTAS DO PROFESSOR 📖 Do mundo analógico ao número As entradas analógicas convertem uma tensão contínua num número de 0 a 1023, através do conversor analógico-digital de 10 bits. Perceber esta conversão é a chave para ler qualquer sensor de tensão variável. O cálculo da tensão real a partir do valor bruto é um exercício de regra de três que liga a teoria à prática. 🗣️ Pontos a desenvolver oralmente • Explicar a resolução de 10 bits e o que significam os 1024 níveis • Mostrar ao vivo a leitura a variar com um potenciómetro • Deduzir a fórmula de conversão de valor bruto para volts

NOTAS DO PROFESSOR 📖 Um sensor para cada grandeza física Cada grandeza do mundo real tem um sensor adequado, e parte da competência é saber escolher. Distinguir sensores analógicos simples (LDR, potenciómetro) de módulos digitais com protocolo próprio (DHT, MPU6050) ajuda a planear o circuito e o código. Mostrar este catálogo abre o leque de projectos possíveis. 🗣️ Pontos a desenvolver oralmente • Agrupar os sensores por grandeza medida (luz, temperatura, distância) • Distinguir sensores analógicos de módulos com saída digital • Relacionar cada sensor com um projecto concreto onde faria sentido

NOTAS DO PROFESSOR 📖 Converter leitura em grandeza física com sentido O TMP36 ilustra como passar de um valor de tensão a uma temperatura em graus, aplicando a fórmula do sensor. Este é um passo conceptual importante: o Arduino lê tensão, mas nós queremos uma unidade física. Perceber a folha de características do componente para obter a fórmula é uma competência transferível a qualquer sensor. 🗣️ Pontos a desenvolver oralmente • Mostrar de onde vem o offset de 0,5 V na fórmula do TMP36 • Reforçar o hábito de consultar o datasheet do componente • Comparar a leitura com um termómetro de referência para validar

NOTAS DO PROFESSOR 📖 Usar libraries e validar leituras Muitos sensores trazem um protocolo próprio que seria penoso implementar à mão; é aí que as libraries poupam imenso trabalho. O DHT22 mostra também a importância de validar as leituras: o teste isnan evita usar valores inválidos quando o sensor falha. Verificar antes de usar é uma boa prática de robustez. 🗣️ Pontos a desenvolver oralmente • Demonstrar a instalação de uma library pelo gestor da IDE • Explicar porque não reinventar protocolos já bem resolvidos • Realçar o tratamento de erro com isnan como reflexo de código fiável

NOTAS DO PROFESSOR 📖 PWM: simular analógico com pulsos O PWM permite controlar intensidade variando a proporção de tempo ligado, mesmo com pinos que só sabem HIGH e LOW. Apenas alguns pinos, marcados com til, o suportam, e isso deve ser destacado para evitar erros de ligação. O exemplo do fade de LED torna o conceito imediatamente visível. 🗣️ Pontos a desenvolver oralmente • Explicar duty cycle e como a média de tensão controla o brilho • Identificar na board quais os pinos com capacidade PWM • Mostrar o fade suave e relacioná-lo com o varrimento de 0 a 255

NOTAS DO PROFESSOR 📖 Controlar posição com servo motores O servo é o primeiro actuador que se move de forma controlada para um ângulo, o que abre a porta à robótica e a mecanismos. A library Servo abstrai a geração dos pulsos, bastando indicar o ângulo desejado. Convém avisar que servos com binário elevado podem exigir alimentação externa para não sobrecarregar a board. 🗣️ Pontos a desenvolver oralmente • Explicar a diferença entre rodar continuamente (motor DC) e posicionar (servo) • Mostrar o varrimento de 0 a 180 graus e o seu uso em mecanismos • Alertar para o consumo de corrente e a alimentação externa quando necessário

NOTAS DO PROFESSOR 📖 Quando o pino não chega: transistores e pontes H Um motor DC consome muito mais corrente do que um pino aguenta, pelo que é preciso um andar de potência: transistor ou ponte H. A ponte H é indispensável para inverter o sentido de rotação, controlando duas linhas. Este é um momento-chave para reforçar a separação entre circuito de comando e circuito de potência. 🗣️ Pontos a desenvolver oralmente • Explicar porque ligar o motor directo ao pino o pode danificar • Mostrar como a combinação de IN1 e IN2 define o sentido de marcha • Relacionar o pino EN com PWM para controlar a velocidade

NOTAS DO PROFESSOR 📖 Displays para dar informação ao utilizador Um display permite que o projecto comunique com o utilizador sem depender do computador. O LCD por I2C reduz a cablagem a apenas dois fios de dados, o que simplifica muito a montagem. O detalhe do endereço I2C variável é uma armadilha comum: se nada aparece, o problema costuma ser o endereço errado. 🗣️ Pontos a desenvolver oralmente • Mostrar a vantagem do I2C ao reduzir o número de fios face ao LCD paralelo • Demonstrar o uso do scanner para descobrir o endereço real do módulo • Explicar setCursor e a organização em linhas e colunas do ecrã

NOTAS DO PROFESSOR 📖 Gráficos com displays OLED O OLED permite ir além do texto, desenhando gráficos, ícones e barras de progresso com as bibliotecas Adafruit GFX. O baixo consumo e o contraste tornam-no ideal para projectos portáteis a pilhas. Vale a pena mostrar que a mesma biblioteca gráfica serve muitos displays diferentes. 🗣️ Pontos a desenvolver oralmente • Contrastar o LCD de caracteres com o OLED gráfico pixel a pixel • Explicar o papel da biblioteca GFX como camada de desenho comum • Realçar o display obrigatório no fim para enviar o buffer ao ecrã

NOTAS DO PROFESSOR 📖 O Serial Monitor como ferramenta de diagnóstico Sem ecrã nem teclado, o Serial Monitor é a janela para o que se passa dentro da board. É a ferramenta número um para depurar: imprimir valores ajuda a perceber porque algo não funciona. Reforçar a correspondência do baud rate entre o sketch e o monitor evita o clássico texto ilegível. 🗣️ Pontos a desenvolver oralmente • Mostrar como imprimir valores intermédios para encontrar a origem de um erro • Alertar para a igualdade do baud rate dos dois lados da comunicação • Comparar este fluxo de depuração com o print de outras linguagens

NOTAS DO PROFESSOR 📖 I2C: muitos dispositivos, dois fios O I2C é um protocolo elegante que liga vários dispositivos com apenas dois fios partilhados, cada um identificado por um endereço único. Compreender o conceito de endereço é o que permite resolver conflitos e diagnosticar problemas. O scanner é uma ferramenta prática que todo o formando deve guardar no seu kit. 🗣️ Pontos a desenvolver oralmente • Explicar SDA e SCL e a ideia de barramento partilhado • Mostrar como vários sensores convivem na mesma ligação • Usar o scanner para listar os endereços presentes no circuito

NOTAS DO PROFESSOR 📖 SPI: velocidade à custa de mais fios O SPI é o protocolo a escolher quando a velocidade importa, como em cartões SD ou displays grandes, ao preço de usar mais fios do que o I2C. A linha SS permite seleccionar qual o dispositivo activo quando há vários. Apresentar I2C e SPI lado a lado ajuda a decidir qual usar em cada situação. 🗣️ Pontos a desenvolver oralmente • Comparar I2C e SPI em número de fios e velocidade • Explicar o papel de cada linha MISO, MOSI, SCK e SS • Dar exemplos típicos onde a rapidez do SPI compensa os fios extra

NOTAS DO PROFESSOR 📖 Disciplina de hardware evita avarias As boas práticas de hardware não são opcionais: proteger entradas, respeitar polaridades e usar a tensão certa evita componentes queimados. O erro mais perigoso para iniciantes é misturar 5V e 3,3V, que pode destruir uma board. O GND comum entre todos os módulos é outro ponto que, quando esquecido, gera comportamentos inexplicáveis. 🗣️ Pontos a desenvolver oralmente • Insistir em desligar a alimentação antes de mexer no circuito • Explicar o perigo de aplicar 5V a uma board de 3,3V • Mostrar como a falta de GND comum provoca leituras erráticas

NOTAS DO PROFESSOR 📖 Código limpo também no Arduino Escrever bom código é tão importante no Arduino como em qualquer linguagem. O alerta sobre o delay que bloqueia tudo é central e prepara o terreno para o uso de millis. Nomear bem as variáveis, usar const e modularizar em funções torna projectos maiores sustentáveis e fáceis de depurar. 🗣️ Pontos a desenvolver oralmente • Explicar porque o delay impede o programa de fazer mais nada entretanto • Mostrar o ganho de legibilidade com nomes claros e const • Defender a divisão do sketch em funções e ficheiros à medida que cresce

NOTAS DO PROFESSOR 📖 Multitarefa sem bloquear com millis() O padrão baseado em millis é a chave para fazer várias coisas em simultâneo sem que o delay congele o programa. Em vez de esperar, o código compara o tempo decorrido e age quando chega o momento. Dominar esta técnica é o salto de qualidade que separa um sketch de brincadeira de um projecto que faz várias tarefas a sério. 🗣️ Pontos a desenvolver oralmente • Contrastar a abordagem millis com a paragem total provocada por delay • Explicar a comparação agora menos último intervalo como temporizador • Mostrar dois temporizadores independentes a correr no mesmo loop