UC02164

Configurar sensores

Do microcontrolador ao efeito interativo: ligar, ler e calibrar sensores para conteúdos que respondem ao mundo real

Curso profissional · 25h · Técnico de Produção de Conteúdos Interativos

Plano

  1. Da ideia ao sensor: computação física
  2. Microcontroladores: Arduino e ESP32
  3. O IDE Arduino e o primeiro sketch
  4. Sinais digitais e sinais analógicos
  5. Sensores de luz
  6. Sensores de temperatura e humidade
  7. Sensores de proximidade (ultrassons)
  8. Sensores de movimento (PIR e acelerómetro)
  9. Sensores de som
  10. Sensores de toque e capacitivos
  11. Atuadores: LEDs, motores e som
  12. Ligações físicas: protoboard e datasheets
  13. Comunicação série e depuração
  14. Integrar sensores em aplicações interativas
  15. Boas práticas, segurança e fecho

Bloco 1 · Computação física

O que é a computação física

Computação física (physical computing) é o ramo que liga o mundo digital ao mundo real através de sensores (entradas) e atuadores (saídas).

  • Um sensor transforma um fenómeno físico (luz, distância, som) num sinal elétrico.
  • Um microcontrolador lê esse sinal e decide o que fazer.
  • Um atuador (LED, motor, altifalante) produz um efeito observável.
  • É a base de instalações interativas, jogos físicos, cenografia digital e exposições.

Sem sensores, um conteúdo interativo só responde a rato e teclado. Com eles, responde ao corpo, ao espaço e ao ambiente.

O ciclo sensor · processamento · atuador

Todo o sistema de computação física segue o mesmo ciclo, repetido continuamente:

[Fenómeno físico] → [Sensor] → [Microcontrolador] → [Atuador/Aplicação] → [Efeito]
      luz                LDR          Arduino              LED               acende
  • Entrada: o sensor mede uma grandeza (luz, distância, temperatura).
  • Processamento: o microcontrolador lê o valor, compara com um limiar e decide.
  • Saída: acende um LED, move um motor, ou envia o valor a uma aplicação de conteúdos (vídeo, som, animação 3D).

Este ciclo repete-se dezenas ou centenas de vezes por segundo.

Bloco 2 · Microcontroladores

Arduino: a placa de referência

O Arduino é uma placa de microcontrolador de código aberto, pensada para prototipagem rápida em computação física.

  • Microcontrolador: um pequeno computador num só chip (processador + memória + entradas/saídas).
  • Pinos digitais: leem ou escrevem apenas 0 V (LOW) ou 5 V (HIGH).
  • Pinos analógicos (A0…A5): leem uma gama contínua de tensão.
  • Alimentação: por cabo USB (também serve para programar) ou fonte externa.
  • Modelos comuns: Arduino Uno (didático, robusto) e Arduino Nano (compacto).

O Arduino não tem sistema operativo: corre um único programa, em ciclo, a partir do momento em que liga.

ESP32: sensores com ligação à internet

O ESP32 é um microcontrolador com Wi-Fi e Bluetooth integrados, compatível com o mesmo IDE e a mesma linguagem do Arduino.

  • Permite que o valor de um sensor seja enviado pela rede para uma aplicação, um site ou um servidor.
  • Útil quando a instalação interativa precisa de comunicar à distância (ex.: vários pontos de sensores num espaço expositivo).
  • Mais rápido e com mais memória do que um Arduino Uno clássico.
  • Programa-se com o mesmo IDE Arduino, escolhendo a placa "ESP32" no menu de placas.
Arduino Uno ESP32
Ligação sem fios não Wi-Fi + Bluetooth
Velocidade 16 MHz até 240 MHz
Uso típico protótipo local sensores em rede

Bloco 3 · O IDE Arduino

Instalar e configurar o IDE

O IDE Arduino (Integrated Development Environment) é o programa onde se escreve, verifica e envia o código para a placa.

Passo a passo

  1. Descarregar o IDE em arduino.cc (Windows, macOS, Linux).
  2. Ligar a placa por cabo USB.
  3. Em Ferramentas → Placa, escolher o modelo (ex.: Arduino Uno).
  4. Em Ferramentas → Porta, escolher a porta série onde a placa apareceu.
  5. Escrever o código e clicar em Verificar (compila) e depois Carregar (envia para a placa).

Sem a placa e a porta certas selecionadas, o carregamento falha logo no primeiro passo.

Anatomia de um sketch

Um programa Arduino chama-se sketch e tem sempre duas funções obrigatórias:

void setup() {
  // corre UMA VEZ, ao ligar ou reiniciar
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  // corre em CICLO, para sempre, enquanto a placa está ligada
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}
  • setup(): configura pinos, inicia a comunicação série. Corre uma vez só.
  • loop(): é o ciclo sensor → processamento → atuador do Bloco 1, em código.
  • pinMode(pino, modo): define se um pino é INPUT (entrada, sensor) ou OUTPUT (saída, atuador).

Bloco 4 · Digital vs analógico

Sinais digitais

Um sinal digital só tem dois estados possíveis: LOW (0 V, "desligado") ou HIGH (5 V, "ligado").

  • Exemplos de sensores digitais: botão, interruptor, PIR (deteta presença sim/não).
  • Lê-se com digitalRead(pino), que devolve HIGH ou LOW.
  • Configura-se o pino como entrada com pinMode(pino, INPUT).
int estado = digitalRead(2);
if (estado == HIGH) {
  Serial.println("Presença detetada");
}

O digital responde a uma pergunta de sim/não: há luz ou não há, há alguém ou não há.

Sinais analógicos

Um sinal analógico varia de forma contínua entre um mínimo e um máximo, não só entre dois estados.

  • Exemplos: LDR (luz), termístor (temperatura), potenciómetro.
  • Lê-se com analogRead(pino), nos pinos A0 a A5, que devolve um valor entre 0 e 1023.
  • 1023 corresponde a 5 V; 0 corresponde a 0 V. É uma conversão analógico → digital (ADC) de 10 bits.
int leitura = analogRead(A0);
float tensao = leitura * (5.0 / 1023.0);
Serial.println(tensao);

A leitura bruta (0 a 1023) raramente é a que interessa mostrar: converte-se para unidades reais (volts, graus, lux).

Bloco 5 · Sensores de luz

O LDR (fotorresistência)

O LDR (Light Dependent Resistor) é uma resistência cuja resistência elétrica diminui com mais luz.

  • Liga-se num divisor de tensão com uma resistência fixa (ex.: 10 kΩ), para converter a variação de resistência numa variação de tensão legível pelo analogRead.
  • Mais luz → menor resistência do LDR → maior tensão no ponto de leitura (ou o inverso, conforme a montagem).
  • Usos em conteúdos interativos: acender uma projeção ao escurecer a sala, ativar um efeito quando alguém tapa o sensor com a mão.
int luz = analogRead(A0);
if (luz < 300) {
  Serial.println("Ambiente escuro: ativar efeito");
}

Calibrar um sensor de luz

Calibrar é ajustar o limiar (threshold) de decisão às condições reais do espaço, não a um número de manual.

Exemplo resolvido

  1. Ligar o LDR e imprimir a leitura no Serial Monitor durante 30 segundos, em condições normais da sala.
  2. Anotar o valor com luzes acesas (ex.: ~700) e com luzes apagadas (ex.: ~150).
  3. Definir o limiar a meio caminho: int LIMIAR = 400;
  4. Testar em condições reais e ajustar se o efeito disparar por engano.

Sem calibração no local, um sensor que funcionava no laboratório falha na sala de exposição.

Bloco 6 · Temperatura e humidade

O sensor DHT11/DHT22

O DHT11 (e a versão mais precisa DHT22) mede temperatura e humidade num único componente, com três pinos: alimentação, sinal e terra.

  • Comunica por um protocolo digital próprio (não é um analogRead simples): precisa de uma biblioteca (ex.: DHT.h) instalada no IDE.
  • Devolve dois valores por leitura: temperatura em °C e humidade relativa em %.
  • Usos em conteúdos interativos: ambientes que reagem ao calor do público, instalações que mudam de cor conforme a humidade do espaço.
#include <DHT.h>
DHT dht(2, DHT11);

void setup() { dht.begin(); }
void loop() {
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();
}

Ler e validar valores de sensores

Sensores reais falham: fios soltos, interferência, leituras fora da gama esperada.

  • Verificar sempre se o valor devolvido é válido antes de o usar (ex.: isnan() para o DHT).
  • Comparar com uma gama esperada (ex.: temperatura interior entre 5 °C e 40 °C); fora disso, é provável erro de leitura.
  • Fazer uma média de várias leituras reduz o ruído de sensores instáveis.
float temp = dht.readTemperature();
if (isnan(temp)) {
  Serial.println("Erro de leitura");
} else {
  Serial.println(temp);
}

Um projeto interativo que confia cegamente no sensor falha em público; um que valida, recupera-se.

Bloco 7 · Sensores de proximidade

O sensor ultrassons HC-SR04

O HC-SR04 mede distância por eco de ultrassons, com dois pinos de sinal: Trig (dispara o impulso) e Echo (recebe o eco).

Princípio de funcionamento

1. Trig envia um impulso de ultrassons.
2. O som viaja, bate num obstáculo, e volta.
3. Echo fica HIGH durante o tempo de ida e volta.
4. Distância = (tempo × velocidade do som) / 2
  • Velocidade do som ≈ 340 m/s (0,034 cm/µs).
  • Gama típica: 2 cm a 400 cm, com boa precisão até cerca de 4 m.
  • Usos: contar visitantes, ativar um efeito quando alguém se aproxima de um ecrã.

Exemplo resolvido: medir e reagir à distância

long duracao;
float distancia;

digitalWrite(TRIG, LOW);
delayMicroseconds(2);
digitalWrite(TRIG, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG, LOW);

duracao = pulseIn(ECHO, HIGH);
distancia = duracao * 0.034 / 2;

if (distancia < 50) {
  Serial.println("Visitante próximo: ativar animação");
}
  • pulseIn() mede quanto tempo o pino Echo ficou em HIGH, em microssegundos.
  • O limiar (50 cm, neste exemplo) calibra-se no espaço real, tal como no Bloco 5.

Bloco 8 · Movimento

O sensor PIR (deteção de presença)

O PIR (Passive Infrared) deteta movimento de calor corporal numa área, devolvendo um sinal digital: HIGH quando há movimento.

  • Muito usado em instalações interativas para disparar um efeito quando alguém entra numa zona.
  • Tem um tempo de retenção ajustável (o HIGH mantém-se alguns segundos após o movimento parar).
  • Um potenciómetro no próprio módulo ajusta a sensibilidade e o alcance.
int movimento = digitalRead(PIR_PIN);
if (movimento == HIGH) {
  Serial.println("Movimento detetado");
}

O PIR responde a corpos quentes em movimento, não a objetos parados nem a luzes.

Acelerómetro e giroscópio

O acelerómetro mede aceleração (incluindo a gravidade) em três eixos (X, Y, Z); o giroscópio mede rotação.

  • Módulos comuns: MPU6050 (acelerómetro + giroscópio combinados), comunica por protocolo I2C.
  • Usos em conteúdos interativos: controlar uma animação inclinando um objeto, detetar gestos, sincronizar som com movimento.
  • Requer biblioteca própria e, normalmente, calibração inicial (posição de repouso = zero).
Sensor Mede Exemplo de uso
Acelerómetro inclinação, choque controlo por gesto
Giroscópio rotação orientação de um objeto

Bloco 9 · Som

Sensores de som

Um módulo de som (com microfone de eletreto e comparador) deteta presença ou intensidade de som, em duas variantes:

  • Digital: devolve HIGH quando o som ultrapassa um limiar ajustável por potenciómetro no módulo.
  • Analógico: devolve um valor contínuo (0 a 1023) proporcional ao volume captado.
int nivel = analogRead(SOM_PIN);
if (nivel > 600) {
  Serial.println("Som alto: ativar efeito de luz");
}

Usos em conteúdos interativos: cenografia que reage a palmas ou música, instalações sonoras participativas.

De sensor a efeito sonoro

O caminho do som captado até ao efeito produzido segue sempre o ciclo do Bloco 1:

[Som ambiente] → [Módulo de som] → [analogRead/threshold] → [LED, motor ou envio à aplicação]
  • Um valor instável (ruído de fundo) pede uma média móvel de várias leituras, tal como no Bloco 6.
  • Combinar som com outro sensor (ex.: proximidade) cria interações mais ricas: só reagir ao som se houver alguém perto.
  • O valor lido pode ser enviado por Serial para controlar volume, cor ou velocidade de uma animação numa aplicação externa.

Bloco 10 · Toque

Sensores de toque e capacitivos

Um sensor de toque capacitivo deteta o contacto (ou a proximidade) da pele humana, que altera um pequeno campo elétrico.

  • Módulos dedicados (ex.: TTP223) devolvem um sinal digital simples, tal como um botão.
  • O próprio Arduino pode fazer deteção capacitiva com uma biblioteca (CapacitiveSensor) e uma resistência de alto valor, sem módulo dedicado.
  • Diferença chave face a um botão mecânico: não tem partes móveis, é mais discreto visualmente e resiste melhor ao uso repetido em exposições públicas.
int toque = digitalRead(TOQUE_PIN);
if (toque == HIGH) {
  Serial.println("Toque detetado");
}

Debounce: filtrar leituras falsas

O debounce (anti-ressalto) evita que um único toque ou clique seja lido como vários, devido a ruído elétrico no instante da mudança de estado.

Exemplo resolvido

int ultimoEstado = LOW;
unsigned long ultimaMudanca = 0;

int atual = digitalRead(TOQUE_PIN);
if (atual != ultimoEstado && millis() - ultimaMudanca > 50) {
  ultimaMudanca = millis();
  ultimoEstado = atual;
  if (atual == HIGH) Serial.println("Toque válido");
}
  • millis() devolve o tempo (em milissegundos) desde que a placa ligou; usa-se para medir intervalos sem bloquear o programa com delay().
  • Um intervalo de 50 ms entre mudanças é suficiente para filtrar a maioria do ruído.

Bloco 11 · Atuadores

Dar resposta ao sensor: LEDs e motores

Um atuador é o componente que produz o efeito físico observável, em resposta ao que o sensor leu.

  • LED: liga-se com digitalWrite(pino, HIGH/LOW), ou com brilho variável usando analogWrite() (PWM) num pino marcado com ~.
  • Servomotor: gira para um ângulo exato (0° a 180°), controlado com a biblioteca Servo.h. Ideal para mover um elemento cenográfico.
  • Motor DC / vibração: liga-se normalmente através de um módulo driver, nunca diretamente ao pino (corrente insuficiente e risco de danificar a placa).
#include <Servo.h>
Servo motor;
motor.attach(9);
motor.write(90);   // move para 90 graus

PWM: simular saída analógica

O Arduino não tem saída analógica verdadeira nos pinos digitais comuns, mas simula-a por PWM (Pulse Width Modulation, modulação por largura de impulso).

  • analogWrite(pino, valor), com valor entre 0 e 255, só funciona nos pinos marcados com ~ na placa.
  • Liga e desliga o pino muito depressa; a proporção de tempo em HIGH determina o brilho ou a velocidade percebidos.
  • 0 = sempre desligado; 255 = sempre ligado; 128 ≈ metade do brilho/velocidade.
int luz = analogRead(A0);
int brilho = map(luz, 0, 1023, 0, 255);
analogWrite(9, brilho);

map() converte um valor de uma escala (0-1023, do sensor) para outra (0-255, do atuador): a ponte direta entre leitura e efeito.

Bloco 12 · Ligações físicas

A protoboard e o kit de instalações

A protoboard (breadboard) permite ligar componentes sem soldar, através de furos ligados internamente em linhas e colunas.

  • Linhas verticais (nas laterais): normalmente alimentação (+ e −), partilhadas por toda a placa.
  • Colunas horizontais (no centro): ligadas em grupos de 5, usadas para os componentes.
  • Fios de ligação (jumpers): macho-macho, macho-fêmea, fêmea-fêmea, conforme o que se liga.
  • O kit de instalações eletrónicas da UC junta protoboard, fios, resistências, LEDs e os sensores estudados.

Uma montagem organizada (fios curtos, cores consistentes) poupa tempo a depurar e evita curto-circuitos.

Ler um datasheet

O datasheet é a ficha técnica de um componente: tensão de funcionamento, pinout (a que serve cada pino), gama de valores, condições de uso.

O que procurar primeiro

  1. Tensão de alimentação (ex.: 3,3 V ou 5 V): ligar à tensão errada danifica o componente.
  2. Pinout: qual pino é VCC (alimentação), GND (terra) e sinal.
  3. Gama de funcionamento: ex.: o HC-SR04 mede de 2 a 400 cm; fora disso, não é fiável.
  4. Corrente máxima: importante para decidir se precisa de driver (motores) ou não (LEDs pequenos).

Um esquema de ligações copiado sem confirmar no datasheet é a causa mais comum de sensores que "não funcionam".

Bloco 13 · Série e depuração

O Serial Monitor

O Serial Monitor do IDE mostra, em tempo real, o que o Arduino envia pela porta USB: é a principal ferramenta de depuração.

void setup() {
  Serial.begin(9600);
}
void loop() {
  int valor = analogRead(A0);
  Serial.print("Sensor: ");
  Serial.println(valor);
  delay(200);
}
  • Serial.begin(9600): inicia a comunicação, à velocidade de 9600 bauds (tem de ser igual dos dois lados).
  • Serial.print() não muda de linha; Serial.println() muda.
  • O Plotter Série (Ferramentas → Plotter Série) desenha o valor ao longo do tempo, útil para ver ruído e tendências.

Metodologia de depuração de sensores

Quando um sensor não dá o resultado esperado, seguir sempre a mesma sequência:

  1. Confirmar a ligação física contra o datasheet (VCC, GND, sinal).
  2. Imprimir o valor bruto no Serial Monitor, sem lógica nenhuma à volta.
  3. Comparar com o valor esperado (ex.: luz alta deve dar leitura alta).
  4. Isolar: testar o sensor sozinho, sem o resto do circuito, se houver dúvida.
  5. Só depois adicionar a lógica (limiares, condições, atuadores).

Depurar de fora para dentro, do fio ao efeito, é mais rápido do que adivinhar.

Bloco 14 · Integrar com aplicações

Enviar dados de sensores para aplicações interativas

O valor lido por um sensor não fica preso ao Arduino: pode ser enviado por porta série para software de conteúdos interativos e modelação 3D no computador.

  • Processing: lê a porta série com Serial.list() e serialEvent(), usa o valor para controlar formas, cor ou vídeo.
  • TouchDesigner: tem um operador Serial DAT dedicado a receber dados de Arduino em tempo real.
  • Unity: com bibliotecas de porta série (System.IO.Ports), o valor do sensor pode mover um objeto 3D ou disparar uma animação.
  • O ESP32 (Bloco 2) permite o mesmo, mas por Wi-Fi, sem cabo, ideal para instalações espalhadas por um espaço.
Serial.println(valorSensor);  // uma linha por leitura, fácil de ler do lado da aplicação

Protocolo simples de comunicação

Para que a aplicação do outro lado leia os dados sem erros, define-se um formato fixo antes de programar os dois lados.

Exemplo resolvido

// Arduino: um valor por linha, sempre neste formato
Serial.print("LUZ:");
Serial.println(analogRead(A0));

Saída no Serial Monitor:
LUZ:812
LUZ:809
LUZ:340
  • A aplicação recebe a linha, separa pelo :, e usa só o número.
  • Com vários sensores, usar um rótulo por sensor (LUZ:, DIST:, SOM:) evita confundir os valores do lado da aplicação.

Bloco 15 · Fecho

Segurança e boas práticas

  • Nunca ligar a placa e mexer nas ligações ao mesmo tempo: desligar a alimentação (ou o USB) antes de alterar fios.
  • Confirmar a tensão de cada componente antes de ligar (3,3 V vs 5 V é o erro mais comum e mais destrutivo).
  • Usar resistências sempre que o datasheet ou o exemplo de referência as indicar; um LED sem resistência queima.
  • Testar sensor a sensor, isoladamente, antes de montar o sistema completo.
  • Documentar as ligações (foto ou esquema) para conseguir repetir ou reparar a montagem depois.

Rigor na montagem é o que separa um protótipo que funciona uma vez de uma instalação que aguenta uma exposição inteira.

Recapitulando

  • O ciclo sensor → processamento → atuador é a base de toda a computação física.
  • Arduino e ESP32 leem sensores digitais (HIGH/LOW) e analógicos (0-1023) através do IDE Arduino.
  • Sensores de luz, temperatura, proximidade, movimento, som e toque: cada um com o seu princípio, ligação e calibração.
  • Atuadores (LED, servo, PWM) fecham o ciclo; Serial Monitor e depuração metódica resolvem o que falha.
  • O valor do sensor integra-se em aplicações interativas e de modelação 3D, ponte final entre hardware e conteúdo.

Próximo: fichas e mini-projeto, configurar sensores para uma instalação interativa real.

NOTAS DO PROFESSOR - Enfatizar: esta UC é a "ponte" entre o mundo físico e o software de conteúdos interativos que os alunos já usam noutras UCs. - Erro comum: achar que "configurar sensores" é só ligar fios. Envolve também ler, calibrar e interpretar o sinal. - Analogia: o sensor é o "sentido" (visão, tato), o microcontrolador é o "cérebro" que decide, o atuador é o "músculo" que reage.

NOTAS DO PROFESSOR - Desenhar o ciclo no quadro com um exemplo concreto escolhido pela turma (ex.: porta automática, torneira sem toque). - Erro comum: esquecer que o ciclo é contínuo (loop), não uma execução única. - Pedir à turma para identificar sensor/processamento/atuador em três objetos do dia a dia.

NOTAS DO PROFESSOR - Mostrar uma placa Arduino Uno física e apontar USB, pinos digitais, pinos analógicos, alimentação. - Erro comum: confundir pino digital com analógico e tentar ler um sensor analógico num pino digital. - Curiosidade: "Arduino" nasceu em Itália (Ivrea) para estudantes de design, não de engenharia; por isso é tão acessível.

NOTAS DO PROFESSOR - Ligar ao recurso "dispositivos tecnológicos com acesso à internet" do referencial: o ESP32 é a ponte entre sensor e IoT. - Erro comum: pensar que o ESP32 é "outra linguagem"; é o mesmo código C/C++ do Arduino, só muda a placa selecionada. - Exemplo: uma instalação com sensores em três salas, cada ESP32 a enviar dados para um painel central.

NOTAS DO PROFESSOR - Fazer a instalação em conjunto na primeira aula; confirmar que todos veem a placa em Ferramentas → Porta. - Erro comum: cabo USB só de carga, sem dados. Não aparece porta nenhuma. - No Windows pode ser preciso instalar o driver CH340 (placas Nano/clones); referir se a turma tiver esse hardware.

NOTAS DO PROFESSOR - Este exemplo (pisca-pisca) é o "hello world" da computação física; correr em direto na primeira aula prática. - Erro comum: esquecer o pinMode. Sem ele, o pino não responde como esperado. - Pergunta: o que acontece se tirarmos o delay()? (o LED pisca tão depressa que parece sempre aceso).

NOTAS DO PROFESSOR - Enfatizar a diferença de vocabulário: digital = HIGH/LOW; analógico = um número numa escala. - Erro comum: usar digitalRead num sensor que devolve uma gama de valores (ex.: LDR). O resultado nunca varia como esperado. - Exercício rápido: a turma lista 3 sensores digitais e 3 analógicos do dia a dia.

NOTAS DO PROFESSOR - Fazer a conta 0-1023 = 10 bits (2^10 = 1024) no quadro; ligar a conceitos de eletrónica digital. - Erro comum: esquecer que analogRead só funciona nos pinos A0-A5, não em qualquer pino. - Exemplo prático: rodar um potenciómetro no Serial Monitor e ver o valor mudar em tempo real.

NOTAS DO PROFESSOR - Mostrar fisicamente o divisor de tensão com LDR + resistência de 10 kΩ na protoboard. - Erro comum: ligar o LDR sem a resistência em série; o circuito não varia como esperado ou satura. - Analogia: o LDR é como uma pupila ao contrário, "estreita" (menos resistência) quando há mais luz.

NOTAS DO PROFESSOR - Este é o procedimento que se repete para QUALQUER sensor analógico: medir extremos reais, definir limiar a meio. - Erro comum: copiar um valor de limiar de um tutorial online sem testar no espaço real. - Ligar à atitude "rigor" do referencial: calibrar é um passo, não um extra.

NOTAS DO PROFESSOR - Mostrar como instalar uma biblioteca: Ferramentas → Gerir Bibliotecas → procurar "DHT sensor library". - Erro comum: esquecer o dht.begin() no setup(); as leituras vêm sempre como "nan" (not a number). - Curiosidade: o DHT11 lê a cada ~1 segundo; ler mais depressa dá valores repetidos ou inválidos.

NOTAS DO PROFESSOR - Ligar à atitude "resolução de problemas": um sensor mau não deve travar toda a instalação. - Erro comum: não tratar o caso de erro e deixar a aplicação "crashar" ou mostrar valores absurdos. - Exercício: a turma propõe o que fazer quando 3 leituras seguidas falham (ex.: mostrar último valor válido).

NOTAS DO PROFESSOR - Fazer a analogia do eco numa sala vazia versus numa sala com móveis (o som "bate" e volta). - Erro comum: esquecer de dividir por 2 (o tempo medido é ida E volta). - Mostrar fisicamente os dois "olhos" do sensor (emissor e recetor de ultrassons).

NOTAS DO PROFESSOR - Correr este exemplo ao vivo com o Serial Monitor aberto; pedir a alunos que se aproximem e afastem. - Erro comum: trocar Trig por Echo na ligação física; o sensor não responde. - Ligar ao ciclo do Bloco 1: sensor (HC-SR04) → processamento (distância + limiar) → atuador (animação).

NOTAS DO PROFESSOR - Erro comum: colocar o PIR perto de fontes de calor (radiadores, luz direta do sol), que geram falsos positivos. - Mostrar o potenciómetro de sensibilidade físico no módulo, se disponível. - Exemplo: portas automáticas, iluminação de corredor, o início de uma experiência interativa ao entrar numa sala.

NOTAS DO PROFESSOR - Não é preciso aprofundar I2C nesta UC; basta que a turma saiba que existe e que precisa de biblioteca. - Erro comum: esperar valores absolutos sem calibrar o "zero" em repouso. - Ligar à aplicação de modelação 3D: um objeto virtual pode seguir a inclinação do sensor físico.

NOTAS DO PROFESSOR - Testar ao vivo: bater palmas perto do sensor e ver o valor mudar no Serial Monitor. - Erro comum: confundir "microfone" com sensor de reconhecimento de voz. Este módulo só mede intensidade, não interpreta fala. - Exercício: calibrar o limiar para reagir a palmas mas não à conversa normal da sala.

NOTAS DO PROFESSOR - Reforçar que combinar sensores (condições "E") é uma técnica central em instalações interativas de qualidade. - Erro comum: um único sensor de som a disparar tudo sozinho, gerando falsos positivos com o ruído da sala. - Preparar a ponte para o Bloco 14 (integração com aplicações), onde este valor é enviado por Serial.

NOTAS DO PROFESSOR - Mostrar o módulo TTP223 físico e comparar com um botão mecânico comum. - Erro comum: montar um sensor capacitivo perto de metal ou de outros condutores, que geram falsos positivos. - Ligar a exemplos reais: superfícies interativas em museus, botões escondidos em cenografia.

NOTAS DO PROFESSOR - Este problema (debounce) aparece em qualquer sensor digital com transições rápidas, não só no toque; vale a pena generalizar. - Erro comum: usar delay() para "esperar" o debounce, o que bloqueia toda a leitura de outros sensores entretanto. - Deixar claro: millis() não pára o programa, delay() pára. Por isso millis() é preferível em sistemas com vários sensores.

NOTAS DO PROFESSOR - Mostrar a diferença física entre um LED simples e um servomotor a rodar em resposta a um valor. - Erro comum: ligar um motor diretamente a um pino digital sem driver; pode queimar o pino ou a placa. - Enfatizar o PWM como "simular" um valor analógico de saída através de pulsos rápidos.

NOTAS DO PROFESSOR - Desenhar no quadro um sinal PWM (onda quadrada) com diferentes larguras de impulso, para visualizar "duty cycle". - Erro comum: tentar analogWrite() num pino sem o símbolo ~; o código compila mas não faz PWM real. - Este exemplo (LDR → map → LED) fecha o ciclo completo do Bloco 1 num código só.

NOTAS DO PROFESSOR - Fazer a turma identificar fisicamente as linhas de alimentação e as colunas de componentes numa protoboard real. - Erro comum: assumir que todas as colunas estão ligadas entre si ao longo de toda a placa; só dentro do mesmo grupo de 5. - Convenção a incentivar: fio vermelho para +, fio preto para GND, sempre.

NOTAS DO PROFESSOR - Trazer um datasheet real (PDF do HC-SR04 ou do DHT11) e navegá-lo em conjunto na aula. - Erro comum: inverter VCC e GND por não confirmar o pinout; pode danificar o componente. - Ligar à atitude "rigor": ler o datasheet antes de ligar, não depois de o sensor falhar.

NOTAS DO PROFESSOR - Abrir o Plotter Série ao vivo com um LDR ou potenciómetro; a turma vê o gráfico a variar em tempo real. - Erro comum: velocidades (bauds) diferentes entre o código e o Serial Monitor; aparecem só símbolos estranhos. - Regra de ouro: quando um sensor "não funciona", o primeiro passo é sempre imprimir o valor no Serial Monitor.

NOTAS DO PROFESSOR - Este é o método a exigir sempre que um grupo disser "o sensor não funciona" nas aulas práticas. - Erro comum: alterar o código todo de uma vez quando algo falha, em vez de isolar a causa passo a passo. - Ligar à atitude "resolução de problemas" do referencial: depurar é uma competência, não sorte.

NOTAS DO PROFESSOR - Escolher UMA aplicação (a que a turma já usa noutra UC) e fazer uma demonstração completa, sensor a mover algo no ecrã. - Erro comum: enviar dados em formatos inconsistentes (às vezes só o número, às vezes com texto à volta); combinar um formato fixo. - Esta ponte é o objetivo final da UC: o sensor deixa de ser um exercício isolado e passa a controlar conteúdo real.

NOTAS DO PROFESSOR - Reforçar que combinar sensores nesta fase é o que separa um exercício de sala de uma instalação interativa completa. - Erro comum: mudar o formato de envio depois de já ter escrito o código do lado da aplicação; combinar o formato primeiro. - Ligar diretamente ao mini-projeto: os alunos vão construir exatamente este tipo de ponte sensor → aplicação.

NOTAS DO PROFESSOR - Recapitular os erros mais caros vistos nas aulas práticas (curto-circuito, componente ao contrário, tensão errada). - Ligar às atitudes do referencial: rigor, sentido de organização, responsabilidade. - Anunciar as fichas e o mini-projeto: configurar um conjunto de sensores para uma instalação interativa completa.