UC00671

Desenvolver e executar sistemas baseados em microcontrolador

Arquitetura, programação em C/C++, sensores, atuadores, comunicação e interface de utilizador

Curso profissional · 50h · Técnico de Eletrónica e Automação

Plano

  1. O microcontrolador e o seu contexto
  2. Arquitetura interna
  3. Periféricos e conversores A/D e D/A
  4. Critérios de seleção
  5. Ferramentas de desenvolvimento
  6. Linguagem C/C++
  7. Estruturas de controlo e manipulação de bits
  8. Assembly
  9. Entradas digitais e debouncing
  10. Entradas analógicas e sensores
  11. Saídas: LEDs e displays
  12. Saídas: motores e relés
  13. Comunicação série UART
  14. Comunicação SPI e I2C
  15. Interrupções
  16. Sensores, atuadores e controlo dinâmico
  17. Interface de utilizador e comunicação sem fios
  18. Design de circuitos e proteção
  19. PCB: layout e interferência
  20. Metodologia de projeto e testes
  21. Fecho

Bloco 1 · O microcontrolador e o seu contexto

O que é um microcontrolador

Um microcontrolador é um circuito integrado que junta, num único chip, um processador, memória e periféricos de entrada/saída. Ao contrário de um computador de uso geral, é feito para uma tarefa específica: ler sensores, decidir e controlar saídas.

  • Está dentro de eletrodomésticos, automóveis, máquinas industriais, brinquedos, equipamento médico.
  • É o "cérebro" de um sistema embutido (embedded system): pequeno, dedicado, muitas vezes invisível ao utilizador.
  • Esta UC cobre o ciclo completo: programar → ler entradas → controlar saídas → comunicar → interagir com o utilizador.

Onde se usa: contexto profissional

O referencial da UC situa o técnico em dois contextos concretos:

  • Empresas de instalação e reparação de equipamentos elétricos e eletrónicos.
  • Departamentos de assistência técnica de empresas de diversos setores.

Nestes contextos, o técnico tem de trabalhar com autonomia, adequar componentes e configurações à função pretendida, respeitar regras e procedimentos, e cumprir as normas de proteção ambiental e de segurança e saúde no trabalho.

Bloco 2 · Arquitetura interna

CPU, memória e o ciclo de execução

O microcontrolador organiza-se em três grandes blocos internos:

  • CPU (Central Processing Unit): executa as instruções do programa, uma a uma, num ciclo fetch → decode → execute.
  • Memória de programa (ROM/Flash): guarda o código, permanente mesmo sem alimentação.
  • Memória de dados (RAM): guarda variáveis durante a execução; perde-se ao desligar.
  • EEPROM: memória não volátil de leitura/escrita, para guardar configurações que sobrevivem a um reset.

Barramentos e endereçamento

A CPU comunica com a memória e periféricos através de barramentos (bus): conjuntos de linhas elétricas que transportam dados, endereços e sinais de controlo.

  • Barramento de dados: transporta a informação (ex.: 8, 16 ou 32 bits de cada vez).
  • Barramento de endereços: identifica onde ler ou escrever (que posição de memória, que registo de periférico).
  • Registos: pequenas células de memória dentro da CPU e dos periféricos, usadas para configurar e controlar o hardware diretamente.

Programar um microcontrolador é, em última análise, ler e escrever registos através destes barramentos, mesmo quando o fazemos com funções de alto nível.

Bloco 3 · Periféricos e conversores A/D e D/A

Periféricos de entrada e saída

Os periféricos são os blocos de hardware que ligam o microcontrolador ao mundo exterior, além da CPU e memória:

  • GPIO (General Purpose Input/Output): pinos configuráveis como entrada ou saída digital.
  • Timers/Contadores: contam ciclos de relógio; geram temporizações precisas, PWM e interrupções periódicas.
  • Comunicação série: UART, SPI, I2C (bloco 13 e 14).
  • Conversores analógico-digital e digital-analógico (ADC/DAC).

Sem periféricos, o microcontrolador só calcularia; são eles que o ligam a sensores, atuadores e outros sistemas.

Conversores A/D (ADC) e D/A (DAC)

O mundo real é analógico (temperatura, luz, tensão contínua variável); o microcontrolador só processa valores digitais.

  • ADC (Analog-to-Digital Converter): converte uma tensão analógica num número digital, com uma resolução em bits (ex.: 10 bits = 1024 valores possíveis).
  • DAC (Digital-to-Analog Converter): faz o inverso, gera uma tensão analógica a partir de um valor digital.
  • Muitos microcontroladores não têm DAC dedicado; simulam saída analógica com PWM (bloco 12).

Sem ADC, ler um sensor de temperatura ou de luz seria impossível diretamente.

Bloco 4 · Critérios de seleção

Como escolher um microcontrolador

Escolher o microcontrolador certo para um projeto é uma das aptidões centrais do referencial. Critérios a pesar:

Critério Porquê importa
Nº de pinos I/O tem de chegar para todos os sensores/atuadores
Memória (Flash/RAM) o programa e as variáveis têm de caber
Velocidade de relógio tarefas em tempo real exigem mais
Periféricos integrados ADC, PWM, UART/SPI/I2C evitam hardware extra
Consumo crítico em sistemas a bateria
Custo e disponibilidade viabilidade do projeto em série
Ecossistema (IDE, bibliotecas) tempo de desenvolvimento

Documentação técnica e datasheets

Nenhuma seleção ou configuração se faz sem consultar a documentação técnica do fabricante:

  • Datasheet: especificações elétricas, pinout, registos, limites absolutos (tensão, corrente, temperatura).
  • Application notes: exemplos de circuitos e configurações recomendadas pelo fabricante.
  • Reference manual: descrição detalhada de cada periférico e dos seus registos.

Consultar especificações técnicas de componentes é uma aptidão avaliada ao longo de toda a UC, não só na escolha do microcontrolador.

Bloco 5 · Ferramentas de desenvolvimento

IDE, compiladores e simuladores

Desenvolver software para microcontrolador segue um fluxo de ferramentas:

  • IDE (Integrated Development Environment): editor de código, gestor de bibliotecas e botão de compilar/carregar, tudo num só programa (ex.: Arduino IDE, PlatformIO, MPLAB X, STM32CubeIDE).
  • Compilador: traduz o código C/C++ em linguagem máquina que o microcontrolador executa.
  • Debugger: permite parar o programa, ver variáveis e avançar instrução a instrução, com hardware dedicado (debugger de hardware).
  • Simulador: executa o código sem hardware físico, útil para testar lógica antes de montar o circuito.

Fluxo típico: escrever → compilar → carregar (upload) → testar → depurar (debug).

O ciclo de desenvolvimento embebido

Ao contrário de um programa de computador normal, o ciclo embebido inclui sempre o hardware:

  1. Escrever o código na IDE.
  2. Compilar: o compilador gera o ficheiro binário (firmware).
  3. Carregar (flash/upload): o firmware é gravado na memória do microcontrolador, via cabo USB ou programador dedicado.
  4. Executar: o programa corre isolado no hardware, sem sistema operativo por trás (na maioria dos casos).
  5. Depurar: usando debugger de hardware, LEDs de diagnóstico ou mensagens pela porta série.

Bloco 6 · Linguagem C/C++

Estrutura de um programa em C/C++

A linguagem C/C++ é a mais usada para programar microcontroladores: é próxima do hardware mas legível, e o compilador otimiza bem o código gerado.

#include <biblioteca.h>

void setup() {
  // corre uma vez: configurar pinos, periféricos
}

void loop() {
  // corre em ciclo infinito: a lógica do programa
}
  • setup(): inicialização (direção dos pinos, velocidade da UART, etc.).
  • loop(): o "coração" do programa, repete indefinidamente enquanto houver alimentação.
  • Sem sistema operativo, não há "sair do programa": o loop corre para sempre.

Tipos de dados e variáveis

Em sistemas com pouca memória, escolher o tipo de dados certo poupa recursos escassos:

Tipo Tamanho típico Uso
bool 1 bit (armazenado em 1 byte) flags, estados on/off
uint8_t 8 bits (0 a 255) contadores pequenos, bytes de comunicação
int / int16_t 16 bits valores com sinal, cálculos gerais
float 32 bits valores decimais (usar com moderação, é lento)

Usar float em excesso num microcontrolador pequeno pode esgotar memória e tornar o programa lento; preferir inteiros sempre que possível.

Bloco 7 · Estruturas de controlo e manipulação de bits

Loops, condicionais e funções

O comportamento do programa constrói-se com três blocos fundamentais:

  • Condicionais (if/else, switch): tomam decisões consoante o estado das entradas.
  • Loops (for, while): repetem ações, como percorrer vários sensores ou piscar um LED N vezes.
  • Funções: organizam o código em blocos reutilizáveis e legíveis (ex.: lerSensor(), acenderLED()).
if (leituraSensor > LIMITE) {
  acenderAlarme();
} else {
  desligarAlarme();
}

Estruturar os programas em funções pequenas e bem nomeadas facilita a depuração e a manutenção.

Manipulação de bits e portas

Muitas vezes é preciso trabalhar diretamente com bits individuais de um registo, sem esperar pela função de alto nível da biblioteca:

  • AND (&): para "ler" ou "limpar" um bit específico.
  • OR (|): para "ligar" (set) um bit sem afetar os outros.
  • XOR (^): para inverter (toggle) um bit.
  • Deslocamento (<<, >>): para posicionar um bit no lugar certo do registo.
PORTB |= (1 << 3);   // liga o bit 3, mantém os restantes
PORTB &= ~(1 << 3);  // desliga o bit 3

Esta é a base de qualquer configuração direta de porta ou registo de periférico.

Bloco 8 · Assembly

Assembly para casos de uso específicos

O Assembly é a linguagem mais próxima do hardware: cada instrução corresponde diretamente a uma operação da CPU. Hoje usa-se pouco, mas continua a ter aplicações específicas:

  • Rotinas críticas de tempo, onde cada ciclo de relógio conta (ex.: geração de sinais de alta frequência).
  • Bootloaders e código de arranque muito próximo do hardware.
  • Otimização de trechos pequenos identificados como o "gargalo" de um programa em C.
  • Compreender o Assembly ajuda a ler o código gerado pelo compilador e a depurar problemas de baixo nível.

Na prática, o fluxo é: programar em C/C++, e recorrer a Assembly só em blocos isolados e justificados.

Bloco 9 · Entradas digitais e debouncing

Ler entradas digitais

Uma entrada digital só tem dois estados possíveis: HIGH (nível alto, tipicamente ligado a Vcc) ou LOW (nível baixo, ligado a GND).

  • Um botão liga ou desliga o pino a Vcc/GND consoante é premido.
  • Uma resistência de pull-up ou pull-down garante um nível estável quando o botão não está premido, evitando um estado "flutuante" indefinido.
  • Configuração típica: pino como entrada, com pull-up interno ativado, botão liga o pino a GND quando premido.
pinMode(BOTAO, INPUT_PULLUP);
if (digitalRead(BOTAO) == LOW) { /* premido */ }

O problema do debouncing

Um botão mecânico não muda de estado de forma limpa: os contactos "ressaltam" (bounce) durante alguns milissegundos, gerando várias transições falsas.

  • Sem tratamento, um único clique pode ser lido como vários cliques.
  • Debouncing por software: ignorar novas leituras durante um pequeno intervalo (ex.: 20-50 ms) depois de detetada uma mudança.
  • Debouncing por hardware: um pequeno condensador RC filtra as oscilações antes do sinal chegar ao pino.
if (digitalRead(BOTAO) == LOW) {
  delay(30);  // aguarda o ressalto estabilizar
  if (digitalRead(BOTAO) == LOW) { /* confirma o clique */ }
}

Bloco 10 · Entradas analógicas e sensores

Ler sensores analógicos

Sensores como os de temperatura, luz (LDR) ou pressão entregam uma tensão analógica proporcional à grandeza medida. O microcontrolador lê-a através do ADC.

int leitura = analogRead(SENSOR);       // 0 a 1023 (ADC de 10 bits)
float tensao = leitura * (5.0 / 1023);  // converter para volt
  • A leitura bruta (0 a 1023, num ADC de 10 bits) tem de ser convertida para unidades reais usando a fórmula do sensor (datasheet).
  • Sensores de fim de curso e células fotoelétricas também entram nesta categoria de deteção de entradas.

Exemplo resolvido: sensor de temperatura analógico

Um sensor entrega 10 mV por grau Celsius, com 0 V a 0°C. Alimentado a 5 V, ligado a um ADC de 10 bits.

  1. O ADC lê o valor bruto: leitura = analogRead(PIN).
  2. Converter para tensão: tensao = leitura * (5.0 / 1023).
  3. Converter para temperatura: temperatura = tensao / 0.01.

Se leitura = 205: tensao = 205 × (5/1023) ≈ 1,0 V → temperatura ≈ 1,0 / 0,01 = 100°C.

Este raciocínio (leitura bruta → tensão → grandeza física) aplica-se a qualquer sensor analógico, basta trocar a fórmula pela do datasheet.

Bloco 11 · Saídas: LEDs e displays

Controlar LEDs e outros indicadores

A saída digital mais simples é ligar/desligar um pino:

pinMode(LED, OUTPUT);
digitalWrite(LED, HIGH);  // liga
digitalWrite(LED, LOW);   // desliga
  • Um LED precisa sempre de uma resistência limitadora de corrente em série, para não exceder a corrente máxima do pino nem a do LED.
  • Vários LEDs podem representar estados de um sistema (ex.: verde = ok, vermelho = alarme).
  • Relés e outros atuadores de maior potência usam a mesma lógica digital, mas exigem circuitos de interface (bloco 18).

Escrever em displays

Os displays são a forma mais direta de dar feedback visual complexo ao utilizador:

  • LED de 7 segmentos: mostra dígitos, controlado bit a bit ou por driver dedicado.
  • LCD alfanumérico (ex.: 16x2): mostra texto, comunica normalmente por barramento paralelo ou I2C.
  • OLED: pequeno, nítido, tipicamente controlado por I2C ou SPI.
lcd.begin(16, 2);
lcd.print("Temp: 23.5 C");

A escolha do display depende da quantidade de informação a mostrar, do espaço físico e dos pinos/periféricos disponíveis.

Bloco 12 · Saídas: motores e relés

Controlar motores com PWM

O PWM (Pulse Width Modulation) simula uma saída "analógica" ligando e desligando o pino muito rapidamente, variando a percentagem de tempo ligado (duty cycle).

analogWrite(MOTOR, 128);  // ~50% duty cycle, de 0 a 255
  • Duty cycle 0% = sempre desligado; 100% = sempre ligado; valores intermédios controlam a velocidade média de um motor DC ou o brilho de um LED.
  • Motores exigem normalmente um driver de motor (ponte H) entre o microcontrolador e o motor, porque o pino não fornece corrente suficiente.

Relés e atuadores de potência

Um relé é um interruptor eletromecânico (ou de estado sólido) que permite ao microcontrolador controlar cargas de maior tensão e corrente (ex.: 230 V AC) com um sinal digital de baixa potência.

  • O microcontrolador ativa uma bobina de baixa potência; esta fecha um contacto que liga a carga real.
  • É preciso um transístor ou driver de relé entre o pino e a bobina, porque o pino não tem corrente suficiente para a acionar diretamente.
  • Um díodo de roda livre (flyback) protege o circuito da tensão inversa gerada quando a bobina desliga.

Bloco 13 · Comunicação série UART

UART: comunicação série assíncrona

A UART (Universal Asynchronous Receiver-Transmitter) transmite dados bit a bit, em série, sem um sinal de relógio partilhado entre os dois dispositivos.

  • Ambos os lados têm de acordar a mesma velocidade (baud rate), ex.: 9600 ou 115200 bps.
  • Usa apenas 2 fios de dados: TX (transmissão) e RX (receção), cruzados entre os dois dispositivos.
  • É a base da porta série usada para depuração (enviar mensagens para o computador) e para ligar módulos como GPS ou Bluetooth clássico.
Serial.begin(9600);
Serial.println("Sistema iniciado");

Trama e uso prático da UART

Cada byte enviado por UART segue uma trama: bit de start, bits de dados, bit de paridade (opcional), bit(s) de stop.

  • A UART é ideal para comunicação ponto a ponto entre dois dispositivos (microcontrolador ↔ computador, microcontrolador ↔ módulo GPS/Bluetooth).
  • Não é adequada, sem hardware extra, para ligar muitos dispositivos à mesma linha; para isso usam-se SPI ou I2C (bloco 14).
  • Boas práticas: confirmar sempre o baud rate de ambos os lados no datasheet do módulo, e usar Serial.println() como ferramenta de diagnóstico em qualquer bloco do programa.

Bloco 14 · Comunicação SPI e I2C

SPI: rápido e síncrono

O SPI (Serial Peripheral Interface) é um protocolo série síncrono (com relógio partilhado), usado para ligar periféricos rápidos como cartões SD, displays e alguns sensores.

  • 4 linhas: SCK (relógio), MOSI (dados mestre→escravo), MISO (dados escravo→mestre), SS/CS (seleção do escravo).
  • Um único mestre pode controlar vários escravos, cada um com a sua linha CS dedicada.
  • Muito mais rápido que UART e I2C, ao custo de mais fios.

I2C: poucos fios, muitos dispositivos

O I2C (Inter-Integrated Circuit) é também síncrono, mas usa apenas 2 fios partilhados por todos os dispositivos: SDA (dados) e SCL (relógio).

  • Cada dispositivo tem um endereço único na linha, permitindo até dezenas de sensores/módulos partilharem os mesmos 2 fios.
  • Mais lento que SPI, mas muito mais económico em pinos: ideal quando há muitos periféricos e poucos pinos livres.
  • Requer resistências de pull-up em SDA e SCL para o barramento funcionar corretamente.
Protocolo Fios Velocidade Nº de dispositivos
UART 2 (TX/RX) média 2 (ponto a ponto)
SPI 4+ alta vários (1 CS cada)
I2C 2 (SDA/SCL) média/baixa vários (endereço único)

Bloco 15 · Interrupções

O conceito de interrupção

Uma interrupção é um sinal que suspende temporariamente o programa principal para executar imediatamente uma rotina prioritária, chamada ISR (Interrupt Service Routine), voltando depois ao ponto onde estava.

  • Alternativa a "verificar constantemente" (polling) uma entrada no loop, o que desperdiça tempo de processamento e pode falhar eventos rápidos.
  • Uma interrupção garante resposta imediata, mesmo que o programa esteja ocupado noutra tarefa.
  • Exemplo clássico: um botão de emergência que tem de parar o sistema de imediato, não "na próxima passagem do loop".

Interrupções externas e internas

  • Interrupções externas: disparadas por um sinal físico num pino dedicado (ex.: mudança de nível ao premir um botão).
  • Interrupções internas: disparadas por periféricos internos, como um timer a atingir um valor, ou o fim de uma receção UART.
attachInterrupt(digitalPinToInterrupt(PINO), rotinaISR, FALLING);

void rotinaISR() {
  flagEvento = true;  // marcar o evento; tratar fora da ISR
}

Boa prática: a ISR deve ser curta, apenas marcar uma variável (flag); o processamento pesado faz-se no loop() principal.

Bloco 16 · Sensores, atuadores e controlo dinâmico

Aplicar sensores e atuadores num sistema de controlo

Um sistema de controlo típico segue o ciclo: ler sensor → decidir → atuar, repetido continuamente.

void loop() {
  int temperatura = lerSensor();
  if (temperatura > LIMITE) {
    ligarVentoinha();
  } else {
    desligarVentoinha();
  }
}
  • O sensor entrega o estado do mundo real (temperatura, distância, posição).
  • A lógica de decisão aplica algoritmos de controlo, do simples if/else a lógica mais elaborada.
  • O atuador (motor, relé, LED) traduz a decisão numa ação física.

Resposta dinâmica a entradas sensoriais

Nem todo o controlo é um simples limiar fixo. Algoritmos de controlo de resposta dinâmica ajustam a saída de forma mais suave ou robusta:

  • Histerese: usar dois limiares diferentes (ligar acima de X, desligar abaixo de Y) para evitar oscilações rápidas junto ao limiar.
  • Filtragem/média móvel: suavizar leituras ruidosas de um sensor antes de decidir.
  • Controlo proporcional simples: a intensidade da resposta (ex.: velocidade do motor) varia com a diferença entre o valor lido e o valor desejado, em vez de ser tudo ou nada.

Estas técnicas evitam que pequenas variações de ruído façam um atuador "piscar" constantemente entre ligado e desligado.

Bloco 17 · Interface de utilizador e comunicação sem fios

Interfaces de utilizador locais

O sistema tem de comunicar com quem o usa. As formas mais simples são locais, no próprio hardware:

  • Botões: para o utilizador dar comandos diretos (ligar, ajustar, confirmar).
  • Displays (LED, LCD, OLED): para mostrar estado, valores lidos, mensagens.
  • Interfaces gráficas simples: menus navegáveis com botões e um display, para configurar parâmetros sem precisar de computador.

O desafio de desenho é combinar poucos botões com informação clara no display, sem sobrecarregar o utilizador.

Comunicação sem fios com o utilizador

Para interfaces mais ricas, o microcontrolador comunica com uma aplicação de computador ou smartphone, via:

  • Bluetooth (clássico ou BLE): curto alcance, baixo consumo, ideal para configuração local e apps móveis.
  • Wi-Fi: alcance maior, liga o sistema à rede local ou à internet; permite dashboards web e notificações remotas.
  • Outros protocolos sem fios dedicados, conforme o projeto.

O microcontrolador expõe dados e comandos (ex.: um pequeno servidor web, ou mensagens por Bluetooth) que a app do smartphone lê e apresenta de forma amigável.

Bloco 18 · Design de circuitos e proteção

Alimentação e proteção do circuito

Um sistema baseado em microcontrolador precisa de um circuito de suporte à volta do chip, não só do código:

  • Alimentação estável: o microcontrolador exige uma tensão dentro de limites apertados (ex.: 3,3 V ou 5 V), muitas vezes com um regulador dedicado.
  • Condensadores de desacoplamento: junto aos pinos de alimentação, filtram ruído e picos de corrente.
  • Proteção de entradas: díodos ou resistências limitadoras protegem pinos contra tensões fora dos limites ou descargas eletrostáticas.
  • Interface com periféricos: transístores, drivers e optoacopladores isolam e adaptam sinais entre o microcontrolador e o mundo exterior de maior potência.

Osciloscópio e multímetro no laboratório

Para verificar se o circuito de suporte está a funcionar, o técnico usa dois instrumentos essenciais:

  • Multímetro: mede tensão, corrente e resistência em pontos do circuito; primeira ferramenta para confirmar alimentação correta.
  • Osciloscópio: mostra a forma de onda de um sinal ao longo do tempo; essencial para ver sinais que mudam rápido (PWM, comunicação série, ruído).

Procedimento típico: medir a tensão de alimentação com o multímetro antes de ligar o microcontrolador; usar o osciloscópio para confirmar que um sinal PWM ou de comunicação tem a forma esperada.

Bloco 19 · PCB: layout e interferência

Do protótipo à placa de circuito impresso

Depois de validado em protótipo (breadboard ou simulação), o circuito passa a PCB (Printed Circuit Board), uma placa definitiva com as pistas de cobre a substituir os fios.

  • Layout básico: posicionar os componentes de forma lógica, agrupando por função, e traçar as pistas o mais curtas possível.
  • Camadas: sinal, alimentação, plano de massa; organizadas como as layers de um software de desenho.
  • Ferramentas: software de desenho de PCB, seguido de fabrico por tanque de revelação ou impressora CNC, e soldadura dos componentes.

Ruído e interferência na PCB

Uma PCB mal desenhada pode introduzir ruído elétrico que afeta o funcionamento do microcontrolador e dos sensores:

  • Pistas de sinal analógico devem ficar afastadas de pistas de potência ou de comutação rápida (PWM, relógios).
  • Um plano de massa contínuo reduz interferência e dá um caminho de retorno curto à corrente.
  • Pistas longas e paralelas podem acoplar sinais indesejados entre si (crosstalk).
  • Componentes sensíveis (sensores analógicos) ficam fisicamente afastados de motores e bobinas de relé.

Uma boa PCB é tão importante para a fiabilidade do sistema como o próprio código.

Bloco 20 · Metodologia de projeto e testes

Do requisito ao esboço de solução

Um projeto profissional com microcontrolador segue sempre uma metodologia, não um "começar a programar":

  1. Levantar requisitos: o que o sistema tem de fazer, que sensores/atuadores envolve, que restrições existem (custo, tamanho, consumo).
  2. Esboçar soluções: alternativas de arquitetura, antes de comprar ou soldar nada.
  3. Selecionar hardware e software: microcontrolador, sensores, atuadores, IDE, com base nos critérios do bloco 4.
  4. Configurar, montar e simular: em software de desenho e simulação de circuitos, antes do hardware físico.

Implementação, montagem e testes

Depois da simulação validada, segue-se o ciclo de implementação real:

  1. Implementar o código, com base no que foi simulado.
  2. Montar o circuito físico, seguindo o esquema e o layout de PCB.
  3. Testar cada bloco isoladamente (alimentação, sensor, atuador, comunicação) antes de testar o sistema completo.
  4. Medir e validar com multímetro e osciloscópio, comparando com o esperado da simulação.
  5. Documentar: registar decisões, esquema final e resultados dos testes.

Testar por blocos isola problemas rapidamente; testar só no fim torna quase impossível saber onde está a falha.

Bloco 21 · Fecho

Síntese e ligação ao projeto

Ao longo desta UC construíste o percurso completo de um sistema baseado em microcontrolador:

  • Arquitetura e ferramentas: CPU, memória, periféricos, IDE, critérios de seleção.
  • Programação: C/C++, estruturas de controlo, manipulação de bits, noções de Assembly.
  • Entradas e saídas: digitais, analógicas, LEDs, displays, motores, relés.
  • Comunicação: UART, SPI, I2C, interrupções, Bluetooth/Wi-Fi.
  • Hardware de suporte: circuitos de alimentação e proteção, PCB, osciloscópio e multímetro.
  • Metodologia: requisitos → simulação → implementação → testes.

Nas fichas e no mini-projeto vais aplicar tudo isto num sistema real, do esboço à validação com instrumentos de laboratório.

Recapitulando

  • Um microcontrolador integra CPU, memória e periféricos num só chip, dedicado a uma função.
  • Programa-se sobretudo em C/C++, manipulando registos, bits e portas, com Assembly para casos pontuais.
  • Entradas (digitais com debouncing, analógicas via ADC) e saídas (LEDs, displays, PWM, motores, relés) ligam o sistema ao mundo real.
  • UART, SPI e I2C comunicam com módulos e periféricos; interrupções garantem resposta imediata a eventos.
  • Circuito de suporte, PCB cuidada e uma metodologia de requisitos → simulação → montagem → testes fazem o sistema funcionar de forma fiável.

Próximo: fichas e mini-projeto, desenvolver e testar um sistema com microcontrolador de raiz.

NOTAS DO PROFESSOR - Enfatizar: microcontrolador não é "um computador pequeno em geral", é um chip dedicado a uma função. Distinguir de microprocessador (que precisa de memória e periféricos externos). - Erro comum: confundir microcontrolador com placa de desenvolvimento (ex.: Arduino é a placa; o ATmega328 é o microcontrolador nela). - Pedir à turma que aponte 5 aparelhos em casa com microcontrolador lá dentro (micro-ondas, comando, máquina de lavar).

NOTAS DO PROFESSOR - Ligar desde já os critérios de desempenho do referencial (autonomia, adequação, normas, segurança) às atitudes que vão ser avaliadas ao longo da UC. - Perguntar: que equipamento de proteção individual (EPI) é relevante num laboratório de eletrónica? (óculos, ventilação para soldadura). - Referir que "adequar componentes à função" volta em quase todos os blocos seguintes: escolher o sensor certo, o microcontrolador certo.

NOTAS DO PROFESSOR - Analogia: ROM/Flash é o "livro de instruções" (fixo); RAM é o "caderno de rascunho" (apaga-se); EEPROM é o "post-it" que fica colado mesmo desligando a luz. - Erro comum: achar que Flash e RAM são a mesma coisa. Perguntar: se desligar o microcontrolador, o que se perde? - Exemplo: guardar na EEPROM o último valor de um contador para retomar depois de um corte de energia.

NOTAS DO PROFESSOR - Mostrar que uma função como digitalWrite() acaba por escrever um bit num registo de porta. Ligar a teoria à prática do bloco 7. - Erro comum: pensar que "programar hardware" é só C++; é sempre, no fundo, manipulação de registos. - Se houver tempo, mostrar o datasheet de um microcontrolador comum e apontar um registo (ex.: PORTB).

NOTAS DO PROFESSOR - Fazer o mapa mental: CPU pensa, memória guarda, periféricos ligam ao mundo real. - Erro comum: esquecer de configurar um pino como entrada ou saída antes de o usar (registo de direção). - Perguntar: para ler um botão, o pino é entrada ou saída? E para acender um LED?

NOTAS DO PROFESSOR - Exemplo de cálculo: ADC de 10 bits, referência 5 V, leitura 512 → tensão = 512/1023 × 5 ≈ 2,5 V. Fazer este cálculo com a turma. - Erro comum: confundir resolução (bits) com precisão real (ruído, referência de tensão instável degradam a precisão). - Ligar ao bloco 10, onde este cálculo é aplicado a um sensor real.

NOTAS DO PROFESSOR - Erro comum: escolher o microcontrolador "mais potente" por defeito. Sobredimensionar custa dinheiro e energia sem necessidade. - Exercício rápido: dado um projeto (ex.: termómetro a pilhas), a turma prioriza 3 critérios da tabela. - Exemplo: comparar rapidamente um micro de 8 bits simples (poucos periféricos, barato) com um de 32 bits com Wi-Fi integrado (mais caro, mais capaz).

NOTAS DO PROFESSOR - Trazer um datasheet real (ex.: ATmega328P ou ESP32) e mostrar em conjunto o pinout e a tabela de limites absolutos. - Erro comum: ignorar os limites absolutos (tensão/corrente máxima por pino) e queimar o microcontrolador. - Reforçar: ler datasheet é uma competência profissional transversal, não um exercício académico.

NOTAS DO PROFESSOR - Escolher UMA ferramenta para a turma praticar (ex.: Arduino IDE por acessibilidade) e mencionar as outras como equivalentes profissionais. - Erro comum: alterar o código e esquecer de recompilar/carregar antes de testar no hardware. - Perguntar: que vantagem tem simular antes de montar o circuito físico? (poupa tempo, evita danificar componentes).

NOTAS DO PROFESSOR - Sublinhar a diferença chave: não há "terminal" nem sistema operativo a correr por baixo do programa, na maioria dos microcontroladores simples. - Erro comum: à falta de debugger, esquecer que a porta série (bloco 13) é a ferramenta de diagnóstico mais acessível. - Exercício mental: descrever o que acontece do clique em "Upload" até o LED da placa acender.

NOTAS DO PROFESSOR - Usar o modelo setup()/loop() do Arduino como referência didática; mostrar o equivalente em C puro (main() com while(1)). - Erro comum: colocar código de configuração dentro do loop() e repeti-lo desnecessariamente a cada ciclo. - Perguntar: porque é que um programa embebido nunca "termina"? (não há para onde voltar, como um SO).

NOTAS DO PROFESSOR - Erro comum: usar int para tudo "por hábito", desperdiçando memória num sistema com apenas 2 KB de RAM. - Exemplo: um contador de 0 a 200 cabe num uint8_t; não precisa de int. - Ligar à atitude "rigor" do referencial: escolher o tipo certo é rigor técnico, não perfecionismo.

NOTAS DO PROFESSOR - Erro comum: um loop() gigante com tudo misturado. Incentivar a dividir em funções desde o início. - Exercício: reescrever um bloco de código repetitivo com um for. - Ligar à atitude "sentido de organização": código organizado é uma competência profissional, não estética.

NOTAS DO PROFESSOR - Fazer o exercício no quadro bit a bit: partir de PORTB = 00000000 e aplicar cada operação. - Erro comum: usar = em vez de |= e apagar acidentalmente os outros bits da porta. - Analogia: cada bit é um interruptor numa fila; |= liga um sem mexer nos outros, = desliga todos e liga só o que escreveste.

NOTAS DO PROFESSOR - Enfatizar: não se espera que a turma escreva programas inteiros em Assembly, mas que entenda porque existe e quando aparece. - Erro comum: achar que Assembly está "obsoleto". Continua presente em firmware de baixo nível e em otimizações críticas. - Exemplo simples: mostrar uma instrução Assembly (ex.: mover um valor para um registo) e o C equivalente lado a lado.

NOTAS DO PROFESSOR - Erro comum: deixar um pino de entrada sem pull-up/pull-down, obtendo leituras aleatórias (pino "flutuante"). - Desenhar no quadro o circuito do botão com a resistência de pull-up e explicar porque LOW significa "premido" neste caso. - Perguntar: porque é mais prático usar o pull-up interno do microcontrolador do que uma resistência externa?

NOTAS DO PROFESSOR - Demonstrar o problema: sem debounce, um contador incrementa vários números por cada clique. Depois corrigir com debounce. - Erro comum: usar delay() longo dentro do loop, bloqueando outras tarefas. Referir que técnicas não bloqueantes (millis()) existem para casos mais exigentes. - Analogia: é como uma porta com mola que bate várias vezes antes de fechar; só a "última" batida conta.

NOTAS DO PROFESSOR - Fazer o exercício de conversão em conjunto: dado leitura=614, calcular a tensão (≈3 V) e depois a grandeza física usando a curva do sensor. - Erro comum: esquecer a referência de tensão do ADC (nem sempre é 5 V; pode ser 3,3 V) e obter valores errados. - Trazer um LDR físico e mostrar a leitura a variar em tempo real ao tapar/destapar com a mão.

NOTAS DO PROFESSOR - Refazer o cálculo com outro valor de leitura à escolha da turma, para fixar o método. - Erro comum: aplicar a fórmula da grandeza diretamente à leitura bruta, saltando o passo intermédio da tensão. - Reforçar que o datasheet do sensor é sempre a fonte da fórmula de conversão; não há uma fórmula universal.

NOTAS DO PROFESSOR - Recordar o cálculo da resistência limitadora do LED (lei de Ohm), já visto noutras UCs, e aplicá-lo aqui a um pino do microcontrolador. - Erro comum: ligar um LED diretamente ao pino sem resistência, ou exceder a corrente máxima por pino (ver datasheet). - Perguntar: um pino de microcontrolador tem corrente suficiente para um motor? (não, precisa de circuito de interface).

NOTAS DO PROFESSOR - Mostrar fisicamente um LCD 16x2 e um display de 7 segmentos, comparando a quantidade de pinos e a complexidade de ligação. - Erro comum: subestimar o número de pinos necessários para um LCD paralelo; o módulo I2C resolve isso com apenas 2 fios (bloco 14). - Ligar à aptidão "utilizar displays" do referencial, avaliada nas fichas e no projeto.

NOTAS DO PROFESSOR - Demonstrar com um LED: variar o duty cycle e mostrar visualmente o brilho a mudar (o "flicker" é rápido demais para o olho ver). - Erro comum: ligar um motor diretamente ao pino do microcontrolador. Recordar a corrente máxima por pino do datasheet. - Introduzir a ponte H como o "interruptor de potência" que o microcontrolador comanda.

NOTAS DO PROFESSOR - Desenhar o circuito completo: pino → transístor → bobina do relé → díodo de proteção em paralelo com a bobina. - Erro comum: esquecer o díodo de proteção e queimar o transístor de comando com o pico de tensão da bobina. - Segurança: relembrar que o lado de potência do relé pode ter 230 V; nunca mexer com tensão aplicada.

NOTAS DO PROFESSOR - Demonstrar ao vivo: enviar valores de um sensor pela porta série e ver no monitor série da IDE. É a ferramenta de debug mais usada em toda a UC. - Erro comum: baud rate diferente nos dois lados, dá "lixo" ilegível no monitor série. - Perguntar: porque é que TX de um lado liga ao RX do outro, e não TX-TX? (o que um envia, o outro recebe).

NOTAS DO PROFESSOR - Mostrar a trama num diagrama simples: start bit, 8 bits de dados, stop bit, para desmistificar "o que viaja no fio". - Erro comum: ignorar mensagens de erro que aparecem no monitor série durante o desenvolvimento. - Ligar à prática: sempre que algo "não funciona", a primeira ferramenta de diagnóstico é imprimir valores pela série.

NOTAS DO PROFESSOR - Desenhar o esquema de ligação de um mestre a dois escravos SPI, com CS individual para cada um. - Erro comum: esquecer de "baixar" o CS do dispositivo certo antes de comunicar, ou deixar dois CS ativos ao mesmo tempo. - Comparar com I2C no slide seguinte: mais fios, mas mais velocidade.

NOTAS DO PROFESSOR - Fazer a turma decidir, para um projeto com 6 sensores e poucos pinos livres, qual protocolo escolher (I2C). - Erro comum: esquecer as resistências de pull-up no barramento I2C; sem elas a comunicação falha ou é instável. - Fixar a tabela comparativa: é a pergunta de exame/ficha mais provável deste bloco.

NOTAS DO PROFESSOR - Analogia: polling é olhar repetidamente para o telemóvel à espera de uma chamada; interrupção é o telemóvel tocar e tu atenderes na hora. - Erro comum: pôr código demorado (delay, cálculos pesados) dentro de uma ISR, bloqueando o resto do sistema. - Perguntar: que evento no projeto da turma merece ser tratado por interrupção em vez de polling?

NOTAS DO PROFESSOR - Explicar os modos de disparo (RISING, FALLING, CHANGE) e qual escolher consoante o circuito (pull-up vs pull-down). - Erro comum: esquecer de declarar a variável partilhada com a ISR como volatile, o que pode causar comportamento imprevisível. - Exercício: identificar, num sistema com botão + sensor + timer, quais eventos justificam interrupção.

NOTAS DO PROFESSOR - Este é o "esqueleto" que todo o projeto da UC vai seguir; vale a pena escrevê-lo no quadro e voltar a ele várias vezes. - Erro comum: misturar a leitura, a decisão e a atuação numa só linha confusa; incentivar a separar em funções (bloco 7). - Perguntar: que sensores e atuadores estão previstos nos recursos da UC? (fim de curso, células fotoelétricas, temperatura, pressão, motores PWM, relés).

NOTAS DO PROFESSOR - Demonstrar o problema sem histerese: um limiar único faz o relé ligar/desligar repetidamente perto do valor de corte. Depois corrigir com dois limiares. - Erro comum: confundir histerese com debouncing; são conceitos parecidos (evitar oscilação) mas aplicados a sinais diferentes (analógico vs digital). - Exemplo real: o termóstato de uma casa nunca liga/desliga no exato valor definido, usa uma margem.

NOTAS DO PROFESSOR - Mostrar exemplos reais de interfaces locais: micro-ondas (botões + display), impressora 3D (ecrã + botão rotativo). - Erro comum: um menu confuso, com demasiados níveis para uma ação simples. Rever a experiência de utilizador mesmo em hardware. - Ligar à aptidão "configurar interfaces gráficos" e "desenvolver interfaces de utilizador" do referencial.

NOTAS DO PROFESSOR - Mostrar um exemplo simples de app (ex.: uma app genérica de Bluetooth serial) a acender/apagar um LED remotamente. - Erro comum: subestimar o consumo de energia do Wi-Fi num projeto a bateria; Bluetooth de baixa energia costuma ser mais eficiente. - Perguntar: para um projeto a bateria, com pouca troca de dados, que protocolo escolher? (BLE, por consumo).

NOTAS DO PROFESSOR - Recordar que "adequar os componentes e configurações à função" (critério de desempenho) começa aqui: escolher o regulador e a proteção certos. - Erro comum: ligar diretamente um sensor ou atuador de maior tensão a um pino, sem circuito de interface. - Mostrar fisicamente um condensador de desacoplamento junto a um microcontrolador numa placa.

NOTAS DO PROFESSOR - Demonstrar no laboratório: medir Vcc com o multímetro e depois observar um sinal PWM no osciloscópio, comparando o duty cycle visualmente. - Erro comum: ligar o microcontrolador sem confirmar a tensão de alimentação primeiro, arriscando danificá-lo. - Ligar à atitude "rigor": medir antes de assumir é rigor técnico, não perda de tempo.

NOTAS DO PROFESSOR - Mostrar (foto ou placa física) a diferença entre um protótipo em breadboard e uma PCB definitiva do mesmo circuito. - Erro comum: desenhar o layout sem pensar na ordem de montagem ou no acesso para soldadura/reparação. - Ligar aos recursos da UC: equipamentos de execução de PCB (tanque de revelação, impressora CNC) e de soldadura, com extração de fumos.

NOTAS DO PROFESSOR - Analogia: pistas paralelas próximas são como dois fios de auscultadores encostados, "ouvem-se" um ao outro (crosstalk). - Erro comum: colocar a pista do sensor de temperatura mesmo ao lado da pista do motor PWM, injetando ruído na leitura. - Se houver tempo, mostrar num software de PCB como visualizar o plano de massa.

NOTAS DO PROFESSOR - Este bloco resume o método que o mini-projeto da UC vai exigir; vale a pena mapear cada fase à fase correspondente do enunciado do projeto. - Erro comum: saltar direto para "ligar e programar", sem levantar requisitos nem esboçar a solução primeiro. - Ligar à atitude "sentido crítico": escolher entre alternativas de solução é pensamento crítico aplicado.

NOTAS DO PROFESSOR - Insistir na ordem: testar por blocos primeiro, sistema completo depois. É o erro mais caro que se vê em projetos de alunos. - Erro comum: montar tudo de uma vez e só ligar no fim, sem testes intermédios. - Ligar à atitude "responsabilidade": documentar o processo é parte do trabalho profissional, não um extra.

NOTAS DO PROFESSOR - Recapitular a lista com a turma, pedindo um exemplo prático de cada linha (já visto em aula). - Perguntar: qual foi o bloco que mais surpreendeu ou foi mais difícil? Serve de termómetro para reforçar antes do projeto. - Anunciar as fichas e o mini-projeto: agora é a vez de desenhar, programar e testar um sistema de raiz.