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

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

#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).