UC02647

Configurar e programar microcontroladores

Arduino, ESP32 e projectos multimédia interactivos

Curso profissional · 25h · TMM

Plano

  1. Microcontroladores
  2. Programação
  3. Sensores e actuadores
  4. Comunicação
  5. Conectividade IoT
  6. Projectos interactivos multimédia

Bloco 1 · Microcontroladores

O que é um microcontrolador

Um microcontrolador é um pequeno computador num único chip: CPU + memória + portas de entrada/saída.

Lê sensores (entradas), processa, e controla actuadores (saídas).

É a base de instalações interactivas, IoT e protótipos electrónicos.

Plataformas

Placa CPU Destaque
Arduino Uno ATmega328 (8-bit) Simples, robusto, didático
ESP32 Dual-core 32-bit WiFi + Bluetooth integrados
Raspberry Pi Pico RP2040 (32-bit) Barato, MicroPython

Para multimédia interactiva com rede, o ESP32 é a escolha mais versátil.

GPIO e alimentação

  • GPIO (General Purpose Input/Output): pinos digitais configuráveis como entrada ou saída.
  • Pinos analógicos: lêem tensões variáveis (ADC).
  • PWM: simula saída analógica (brilho de LED, posição de servo).

Alimentação: USB (5 V) ou fonte externa. Atenção à tensão lógica: 5 V (Arduino) vs 3.3 V (ESP32/Pico).

Cuidados eléctricos

  • Nunca ligar saída directa a 220 V.
  • Usar resistências com LEDs (limitar corrente).
  • Respeitar a corrente máxima por pino (~20-40 mA).
  • Para cargas maiores: transístor ou relé.
  • GND comum entre todos os componentes.

Bloco 2 · Programação

IDE Arduino e estrutura

O programa (sketch) tem duas funções obrigatórias:

void setup() {
  // corre 1 vez ao ligar
  pinMode(13, OUTPUT);
}

void loop() {
  // repete para sempre
  digitalWrite(13, HIGH);
  delay(1000);
  digitalWrite(13, LOW);
  delay(1000);
}

Variáveis e tipos

int contador = 0;        // inteiro
float tensao = 3.3;      // decimal
bool ligado = true;      // verdadeiro/falso
const int LED = 13;      // constante (não muda)

Usar const int para pinos torna o código legível e fácil de alterar.

Entradas e saídas digitais

const int BOTAO = 2;
const int LED = 13;

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

void loop() {
  if (digitalRead(BOTAO) == LOW) {  // premido
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

Leitura analógica

analogRead() devolve 0-1023 (Arduino) conforme a tensão no pino:

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

void loop() {
  int valor = analogRead(A0);   // 0..1023
  Serial.println(valor);
  delay(100);
}

Útil para potenciómetros, sensores de luz (LDR), temperatura.

Bloco 3 · Sensores e actuadores

Componentes essenciais

Entradas (sensores):

  • Botão / interruptor.
  • Potenciómetro.
  • LDR (luz).
  • Sensor de temperatura (TMP36, DHT11).
  • PIR (movimento).

Saídas (actuadores):

  • LED (luz).
  • Buzzer (som).
  • Servo (movimento).
  • Motor, relé.

LED com PWM (brilho)

const int LED = 9;  // pino PWM (~)

void loop() {
  for (int b = 0; b <= 255; b++) {
    analogWrite(LED, b);   // 0..255
    delay(5);
  }
}

analogWrite controla o brilho simulando uma saída analógica.

Sensor de luz (LDR)

const int LDR = A0;
const int LED = 9;

void loop() {
  int luz = analogRead(LDR);
  if (luz < 300) {              // está escuro
    analogWrite(LED, 255);     // acende
  } else {
    analogWrite(LED, 0);       // apaga
  }
}

Base de uma luz automática que reage ao ambiente.

Servo

#include <Servo.h>
Servo s;

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

void loop() {
  s.write(0);    delay(1000);   // posição 0°
  s.write(90);   delay(1000);   // 90°
  s.write(180);  delay(1000);   // 180°
}

Movimento mecânico controlado por ângulo (0-180°).

Bloco 4 · Comunicação

Serial

A porta Serial comunica entre a placa e o computador (debug e dados):

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

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

O Serial Monitor mostra os valores — ferramenta essencial de depuração.

I2C

I2C liga vários dispositivos com apenas 2 fios (SDA, SCL):

  • Cada dispositivo tem um endereço único.
  • Usado por muitos sensores e displays.
  • Ligações: SDA → SDA, SCL → SCL, GND comum.

Permite ligar OLED, sensores e expansores na mesma "linha".

Displays

Display Interface Uso
LCD 16×2 I2C / paralelo Texto simples
OLED 128×64 I2C Gráficos, texto nítido 
#include <Adafruit_SSD1306.h>
display.println("Ola!");
display.display();

Bibliotecas tratam dos detalhes; basta enviar texto/formas.

Bloco 5 · Conectividade IoT

WiFi no ESP32

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.begin("rede", "password");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500); Serial.print(".");
  }
  Serial.println("Ligado!");
}

O ESP32 traz WiFi integrado — ideal para projectos ligados à rede.

HTTP

A placa pode enviar dados para um servidor ou receber comandos:

  • GET para ler dados de uma API.
  • POST para enviar leituras de sensores.

Exemplo: enviar a temperatura para um serviço cloud que a regista e mostra num dashboard.

MQTT (básico)

MQTT é um protocolo leve de mensagens ideal para IoT:

  • Publish: a placa publica num tópico (ex: sala/luz).
  • Subscribe: outro dispositivo escuta esse tópico.
  • Um broker distribui as mensagens.

Perfeito para instalações onde várias placas/dispositivos reagem entre si em tempo real.

Bloco 6 · Projectos interactivos multimédia

A lógica sensor → resposta

Toda a instalação interactiva segue o padrão:

ENTRADA (sensor)  →  PROCESSAMENTO  →  SAÍDA (resposta)
movimento/luz/som    condição/regra     luz/som/vídeo

O microcontrolador é o "cérebro" que liga o mundo físico à resposta multimédia.

Exemplos de instalação

  • Luz que segue a pessoa (PIR → tira LED).
  • Som reactivo ao gesto (sensor de distância → notas).
  • Quadro interactivo (toque → animação no ecrã via Serial/MQTT).
  • Iluminação ambiente que muda com o ruído ou a luz.

Ligar a software multimédia

A placa pode controlar software no computador:

  • Enviar dados por Serial para Processing, TouchDesigner ou Unity.
  • Publicar por MQTT/HTTP para uma página web que reage.

Assim, um sensor físico pode disparar vídeo, som ou visuais generativos.

Do protótipo à instalação

  1. Esquema do circuito (sensores, actuadores, alimentação).
  2. Código testado por partes.
  3. Montagem robusta (soldar/fixar, cabos arrumados).
  4. Teste com utilizadores reais.
  5. Documentação (esquema + código + foto/vídeo).

UC02647 · resumo

  • Microcontroladores (Arduino, ESP32, Pico) ligam o mundo físico ao digital.
  • Programação com setup/loop, digitalRead/Write e analogRead.
  • Sensores (luz, botão, temperatura) e actuadores (LED, servo, buzzer).
  • Comunicação por Serial, I2C e displays (OLED/LCD).
  • IoT com WiFi do ESP32, HTTP e MQTT.
  • Instalações interactivas: sensor → processamento → resposta visual/sonora.

NOTAS DO PROFESSOR 📖 O microcontrolador como ponte físico-digital A ideia fundadora deste módulo é simples: um microcontrolador lê o mundo físico (sensores), decide (programa) e age sobre ele (actuadores). É este ciclo que permite uma instalação multimédia reagir a quem passa. Ajuda começar com a analogia de um pequeno cérebro com sentidos e músculos, antes de qualquer detalhe técnico. 🗣️ Pontos a desenvolver oralmente • Apresentar o ciclo entrada → processamento → saída. • Dar exemplos do quotidiano com microcontroladores embutidos. • Ligar o conceito a uma instalação interactiva que reage à presença.

NOTAS DO PROFESSOR 📖 Escolher a placa para o projecto Cada placa tem o seu lugar: o Arduino Uno é didático e robusto, o ESP32 traz WiFi e Bluetooth, o Pico é barato e usa MicroPython. Para instalações multimédia ligadas à rede, o ESP32 destaca-se. Convém que os formandos aprendam a escolher a placa pelas necessidades do projecto e não por hábito. 🗣️ Pontos a desenvolver oralmente • Justificar o ESP32 pela conectividade integrada. • Posicionar o Arduino Uno como placa de aprendizagem. • Referir o Pico e o MicroPython como alternativa acessível.

NOTAS DO PROFESSOR 📖 GPIO, tipos de pino e tensão lógica Os pinos são a interface da placa com o mundo: digitais, analógicos e PWM, cada um com a sua função. O ponto crítico de segurança é a tensão lógica — ligar um sinal de 5 V a um pino de 3.3 V pode danificar a placa. Insistir nesta diferença entre Arduino e ESP32 evita muitos componentes queimados em sala. 🗣️ Pontos a desenvolver oralmente • Distinguir pino digital, analógico e PWM com exemplos. • Alertar para o perigo de misturar tensões de 5 V e 3.3 V. • Explicar o que é o PWM e como simula uma saída analógica.

NOTAS DO PROFESSOR 📖 Segurança eléctrica em primeiro lugar Antes de programar, há que respeitar a electricidade. As regras deste slide são inegociáveis: nunca tocar em 220 V, limitar corrente com resistências, não exceder a corrente do pino e ter GND comum. O conceito de GND comum costuma ser o que falha em montagens de iniciantes e gera comportamentos "fantasma". Reforçar com uma demonstração de um LED com e sem resistência. 🗣️ Pontos a desenvolver oralmente • Explicar por que um LED precisa de resistência limitadora. • Demonstrar o que significa GND comum num circuito. • Introduzir relé e transístor para cargas maiores.

NOTAS DO PROFESSOR 📖 A estrutura setup/loop de um sketch Todo o programa Arduino assenta em duas funções: setup() corre uma vez ao ligar, loop() repete-se para sempre. Esta estrutura é a base de tudo o que se segue, por isso convém fixá-la bem. O exemplo do LED a piscar é o "olá mundo" da electrónica e o melhor ponto de partida prático. 🗣️ Pontos a desenvolver oralmente • Explicar o que pertence a setup() e o que pertence a loop(). • Demonstrar o LED a piscar numa placa real. • Esclarecer o papel do delay() e os seus inconvenientes.

NOTAS DO PROFESSOR 📖 Variáveis e tipos no Arduino As variáveis guardam dados, e o tipo declara que dados são — inteiro, decimal, booleano. O hábito de usar const int para os números de pino é uma boa prática profissional: torna o código legível e fácil de mudar quando se altera a montagem. Reforçar a diferença entre uma constante e uma variável que muda no tempo. 🗣️ Pontos a desenvolver oralmente • Relacionar cada tipo (int, float, bool) com o seu uso. • Explicar a vantagem de const int para pinos. • Mostrar como mudar um pino num só sítio do código.

NOTAS DO PROFESSOR 📖 Ler botões e acender LEDs Este exemplo junta entrada e saída digital: ler o estado de um botão e responder com um LED. O detalhe pedagógico é o INPUT_PULLUP, que evita leituras erráticas e inverte a lógica (premido = LOW). É um ponto que confunde iniciantes e merece explicação cuidada com o multímetro ou um esquema simples. 🗣️ Pontos a desenvolver oralmente • Explicar para que serve a resistência pull-up interna. • Esclarecer por que premido corresponde a LOW. • Propor variações: botão que alterna em vez de manter.

NOTAS DO PROFESSOR 📖 Leitura analógica e o Serial Monitor Nem tudo é ligado/desligado: o mundo real é analógico, e analogRead() traduz tensões variáveis num número (0-1023 no Arduino). O Serial Monitor é a janela para ver esses valores em tempo real — ferramenta essencial para compreender e depurar. Levar os formandos a observar os números a mudar enquanto rodam um potenciómetro fixa o conceito. 🗣️ Pontos a desenvolver oralmente • Explicar a escala 0-1023 e a sua relação com a tensão. • Demonstrar valores a mudar no Serial Monitor ao vivo. • Dar exemplos de sensores analógicos (LDR, potenciómetro, TMP36).

NOTAS DO PROFESSOR 📖 O vocabulário de sensores e actuadores Este slide é o "inventário" do kit: de um lado, sensores que percebem (luz, movimento, temperatura); do outro, actuadores que agem (luz, som, movimento). Compreender esta divisão é o que permite imaginar projectos. Mostrar fisicamente cada componente em sala ajuda a fixar nomes e funções muito melhor do que a lista escrita. 🗣️ Pontos a desenvolver oralmente • Passar os componentes pela turma e nomeá-los. • Classificar cada um como entrada ou saída. • Pedir aos formandos que combinem um sensor com um actuador.

NOTAS DO PROFESSOR 📖 PWM — controlar o brilho de um LED O analogWrite não envia mesmo uma tensão variável: liga e desliga muito depressa (PWM), e a média percebida parece brilho. Este conceito é a chave para controlar LEDs, velocidade de motores e muito mais. O efeito de "respiração" do LED com o ciclo for é visualmente satisfatório e ajuda a fixar a ideia. 🗣️ Pontos a desenvolver oralmente • Explicar PWM como ligar/desligar rápido com duty cycle. • Demonstrar o LED a aumentar e diminuir de brilho. • Listar outras aplicações: velocidade de motor, som de buzzer.

NOTAS DO PROFESSOR 📖 Sensor de luz que decide Este exemplo é o primeiro projecto "inteligente": lê a luz ambiente e decide acender ou apagar com base num limiar. Introduz a noção de threshold — o valor de corte da decisão. O número 300 não é mágico; depende do LDR e da luz da sala, por isso convém calibrá-lo ao vivo lendo valores no Serial Monitor. 🗣️ Pontos a desenvolver oralmente • Explicar o conceito de threshold e como o calibrar. • Relacionar este exemplo com candeeiros automáticos reais. • Propor a inversão da lógica (acender quando há luz).

NOTAS DO PROFESSOR 📖 O servo dá movimento à instalação O servo é o primeiro actuador de movimento: posiciona-se por ângulo, de 0 a 180 graus, usando uma biblioteca que esconde a complexidade do sinal. É a base de braços, painéis e mecanismos interactivos. Alertar para a alimentação: servos consomem corrente e podem precisar de fonte externa, não devendo ser alimentados só pela USB em montagens maiores. 🗣️ Pontos a desenvolver oralmente • Demonstrar o servo a varrer entre 0° e 180°. • Explicar o papel da biblioteca Servo.h. • Alertar para o consumo de corrente e a necessidade de fonte.

NOTAS DO PROFESSOR 📖 Comunicação Serial — depurar e enviar dados A Serial é a linha de vida entre a placa e o computador: serve para depurar e para enviar dados a outro software. Sem ela, programar microcontroladores seria às escuras. Reforçar que o baud rate (9600, 115200) tem de coincidir entre placa e monitor, senão aparecem caracteres ilegíveis — um erro frequente e fácil de diagnosticar. 🗣️ Pontos a desenvolver oralmente • Explicar a importância do baud rate coincidir. • Demonstrar print vs println e a leitura no monitor. • Antecipar o uso da Serial para falar com Processing/Unity.

NOTAS DO PROFESSOR 📖 I2C — vários dispositivos, dois fios O I2C resolve um problema prático: ligar muitos periféricos sem ficar sem pinos. Com apenas dois fios (SDA e SCL) e um endereço por dispositivo, partilha-se a mesma linha. Os formandos devem perceber que cada dispositivo I2C tem um endereço único, e que existem scanners de endereço para o descobrir quando não vem documentado. 🗣️ Pontos a desenvolver oralmente • Explicar a analogia do endereço como "morada" de cada dispositivo. • Mostrar como ligar SDA, SCL e GND comuns. • Mencionar o sketch de I2C scanner para encontrar endereços.

NOTAS DO PROFESSOR 📖 Mostrar informação em displays Os displays dão feedback visual sem precisar de computador: o LCD para texto simples, o OLED para gráficos nítidos. A grande mensagem é que as bibliotecas (como a Adafruit_SSD1306) escondem a complexidade — basta enviar texto ou formas. É um bom momento para mostrar como usar bibliotecas de terceiros e ler a respectiva documentação. 🗣️ Pontos a desenvolver oralmente • Comparar LCD 16×2 e OLED em legibilidade e gráficos. • Demonstrar a escrita de texto num display em sala. • Explicar como instalar e usar uma biblioteca no IDE.

NOTAS DO PROFESSOR 📖 Ligar o ESP32 à rede WiFi A conectividade WiFi do ESP32 é o que o eleva de microcontrolador a dispositivo IoT. O padrão de ligação — esperar em loop até WL_CONNECTED — é o ponto de partida de qualquer projecto ligado. Avisar que credenciais em texto no código não devem ser publicadas e que a 2.4 GHz é a banda suportada, ao contrário da 5 GHz. 🗣️ Pontos a desenvolver oralmente • Explicar o ciclo de espera pela ligação. • Alertar para não expor SSID e password em repositórios. • Referir que o ESP32 liga em 2.4 GHz, não 5 GHz.

NOTAS DO PROFESSOR 📖 HTTP — falar com servidores e APIs Com HTTP, a placa deixa de estar isolada: pode buscar dados (GET) ou enviar leituras (POST) para a nuvem. Este é o conceito que liga o projecto físico a dashboards e serviços online. O exemplo de enviar temperatura para um serviço que a regista torna concreta a ideia de IoT e abre caminho a projectos com valor real. 🗣️ Pontos a desenvolver oralmente • Distinguir GET (ler) de POST (enviar) com exemplos. • Mostrar um serviço cloud simples que regista dados. • Relacionar com aplicações reais de monitorização.

NOTAS DO PROFESSOR 📖 MQTT — mensagens leves para IoT O MQTT introduz um modelo diferente do HTTP: publish/subscribe via um broker, ideal quando muitos dispositivos comunicam em tempo real. A analogia de um quadro de avisos (tópicos) onde uns publicam e outros escutam ajuda a interiorizar. É a tecnologia certa para instalações com várias placas a reagir umas às outras. 🗣️ Pontos a desenvolver oralmente • Explicar publish, subscribe e o papel do broker. • Contrastar MQTT com HTTP em cenários de tempo real. • Dar exemplo de tópicos hierárquicos (sala/luz, sala/temperatura).

NOTAS DO PROFESSOR 📖 O padrão sensor → processamento → resposta Este é o coração conceptual do módulo aplicado à multimédia: toda a instalação interactiva segue este padrão. Quando os formandos o interiorizam, conseguem desenhar qualquer projecto a partir das três perguntas — o que detecto, que regra aplico, como respondo. Vale a pena reescrever projectos conhecidos nesta estrutura para treinar o raciocínio. 🗣️ Pontos a desenvolver oralmente • Decompor uma instalação famosa nas três etapas. • Reforçar que a "regra" é onde mora a criatividade. • Pedir à turma que invente uma resposta para um dado sensor.

NOTAS DO PROFESSOR 📖 Ideias de instalações interactivas Estes exemplos servem de catálogo de inspiração para os projectos dos formandos. O importante é mostrar que cada um nasce da combinação de um sensor com uma resposta — e que a complexidade pode crescer a partir de ideias simples. Incentivar a turma a apropriar-se destes conceitos e a propor variações para o seu projecto final. 🗣️ Pontos a desenvolver oralmente • Mapear cada exemplo no padrão sensor → resposta. • Mostrar vídeos de instalações interactivas reais. • Pedir um esboço de instalação a cada grupo.

NOTAS DO PROFESSOR 📖 A placa como controladora de software multimédia Aqui fecha-se o curso com a aplicação mais rica: a placa não acende só LEDs, dispara vídeo, som e visuais em software como Processing, TouchDesigner ou Unity. A Serial e o MQTT/HTTP são as pontes. É o momento de mostrar que electrónica e multimédia se cruzam, e que o microcontrolador é o gatilho físico de experiências digitais. 🗣️ Pontos a desenvolver oralmente • Demonstrar a Serial a controlar um sketch de Processing. • Explicar quando usar Serial vs MQTT/HTTP para multimédia. • Inspirar com exemplos de visuais generativos accionados por sensor.

NOTAS DO PROFESSOR 📖 Do protótipo à instalação robusta Um projecto que funciona na bancada nem sempre aguenta o uso real: este slide ensina o processo de o tornar fiável. Os passos — esquema, código por partes, montagem robusta, teste com utilizadores, documentação — são a metodologia profissional. Insistir na documentação: é o que permite reparar e replicar a instalação no futuro. 🗣️ Pontos a desenvolver oralmente • Explicar por que testar com utilizadores reais revela falhas. • Distinguir protótipo em breadboard de montagem soldada. • Reforçar a documentação como parte do projecto, não extra.