- 2 -Laboratório Prático: Desafios Arduino

Baseado nos componentes fundamentais do vídeo, completa os desafios abaixo para dominares a eletrónica digital.

Desafio 1: Led acionado por botão

Objetivo: Acender o led com um botão.

Material: 1x Arduino Uno, 1x LED, 1x Resistor 220Ω, Jumpers, pushbutton.

// Definição dos pinos
const int pinoBotao = 2; 
const int pinoLED = 13;

void setup() {
  pinMode(pinoLED, OUTPUT);    // O LED é uma saída
  pinMode(pinoBotao, INPUT);   // O botão é uma entrada
}

void loop() {
  // Lê o estado do botão (HIGH se pressionado, LOW se solto)
  int estadoBotao = digitalRead(pinoBotao);

  if (estadoBotao == HIGH) {
    digitalWrite(pinoLED, HIGH); // Acende o LED
  } else {
    digitalWrite(pinoLED, LOW);  // Apaga o LED
  }
}

Desafio 1.1: Led acionado por botão

Objetivo: Fazer com LED permanentemente ligado ou desligado com um toque no botão. Para ligar e desligar um LED com um único toque de botão (comutação "flip-flop")

Material: 1x Arduino Uno, 1x LED, 1x Resistor 220Ω, Jumpers, pushbutton.

/*
No código anterior, o LED só brilhava enquanto mantinhas o dedo no botão. 
No Modo Toggle, o Arduino funciona assim:
O botão foi pressionado?
Se sim, inverte o estado do LED (se estava apagado, acende; se estava aceso, apaga).

*/
// Definição dos pinos
const int pinoBotao = 2;
const int pinoLED = 13;

// Variáveis de controlo
int estadoLED = LOW;       // Armazena o estado atual do LED
int leituraAnterior = LOW; // Armazena a última leitura do botão

void setup() {
  pinMode(pinoLED, OUTPUT);
  pinMode(pinoBotao, INPUT);
}

void loop() {
  int leituraAtual = digitalRead(pinoBotao);

  // Verifica se o botão foi pressionado (transição de LOW para HIGH)
  if (leituraAtual == HIGH && leituraAnterior == LOW) {
    estadoLED = !estadoLED;      // Inverte o estado (se era 0 vira 1, vice-versa)
    digitalWrite(pinoLED, estadoLED);
    delay(50);                   // Pequeno delay para evitar ruído (debounce)
  }

  leituraAnterior = leituraAtual; // Atualiza a leitura para o próximo ciclo
}

Desafio 2: potenciómetro com Led.

Objetivo: Potenciómetro para controlar a velocidade com que um LED pisca, rodando o manípulo de um potenciómetro.

Explicação: O Arduino transforma a voltagem (de 0 a 1023) num número inteiro. Se o potenciómetro estiver a meio, o valor lido será aproximadamente 512. Controlo de Tempo: Ao colocar a variável valorLido dentro do delay(), estamos a criar um programa dinâmico. Se rodarmos o potenciómetro para o máximo (1023), o LED pisca a cada 1 segundo. Se rodarmos para o mínimo, ele pisca tão rápido que parece estar sempre aceso.

Material: 1x Arduino Uno, 1x LED, 1x Potenciómetro 220Ω, Jumpers, .

// Definição dos pinos
const int pinoPotenciometro = A0; // O potenciómetro liga a um pino Analógico
const int pinoLED = 13;          // O LED liga a um pino Digital

// Variável para guardar o valor lido
int valorLido = 0; 

void setup() {
  // Configura o pino do LED como saída
  pinMode(pinoLED, OUTPUT);
  
  // Inicia o Monitor Série para podermos ver os valores
  Serial.begin(9600);
}

void loop() {
  // Lê o valor do potenciómetro (varia entre 0 e 1023)
  valorLido = analogRead(pinoPotenciometro);
  
  // Imprime o valor no Monitor Série para verificação
  Serial.print("Valor do Potenciometro: ");
  Serial.println(valorLido);
  
  // Usa o valor lido como tempo de espera (delay) em milissegundos
  digitalWrite(pinoLED, HIGH); // Liga o LED
  delay(valorLido);            // Espera proporcional à rotação
  
  digitalWrite(pinoLED, LOW);  // Desliga o LED
  delay(valorLido);            // Espera proporcional à rotação
}

Desafio 2.1: potenciómetro com Led.

Objetivo: Potenciómetro para controlar a intensidade do brilho de um LED, rodando o manípulo de um potenciómetro.

Explicação: Vamos utilizar a função map(). Esta função é essencial em Arduino porque permite converter uma gama de valores noutra.
Neste caso, o potenciómetro fornece valores entre 0 e 1023, mas o brilho do LED (através do PWM) só aceita valores entre 0 e 255.
Atenção: Para controlar o brilho, o LED tem de estar ligado a um pino com PWM (identificado com o símbolo ~). No Arduino Uno, os pinos comuns são 3, 5, 6, 9, 10 ou 11. Vamos usar o pino 9.

Material: 1x Arduino Uno, 1x LED, 1x Potenciómetro 220Ω, Jumpers, .

// Definição dos pinos
const int pinoPotenciometro = A0; // Entrada analógica
const int pinoLED = 9;           // Pino digital com suporte PWM (~)

void setup() {
  pinMode(pinoLED, OUTPUT);
  Serial.begin(9600); // Para monitorizar os valores no PC
}

void loop() {
  // 1. Lê a posição do potenciómetro (0 a 1023)
  int valorBruto = analogRead(pinoPotenciometro);

  // 2. Converte o valor de 0-1023 para a escala de brilho 0-255
  // Sintaxe: map(valor, deBaixo, deCima, paraBaixo, paraCima)
  int brilho = map(valorBruto, 0, 1023, 0, 255);

  // 3. Aplica o brilho ao LED usando sinal PWM
  analogWrite(pinoLED, brilho);

  // Exibe os valores no Monitor Série para o aluno entender a conversão
  Serial.print("Entrada: ");
  Serial.print(valorBruto);
  Serial.print(" -> Brilho: ");
  Serial.println(brilho);

  delay(10); // Pequena pausa para estabilizar a leitura
}

Desafio 3: Monitor de Temperatura Inteligente.

Objetivo: Criar um sistema de monitorização térmico utilizando um sensor LM35 e três LEDs (Verde, Amarelo e Vermelho) para indicar o estado do ambiente.

Explicação: Leitura Analógica: O sistema deve ler o valor de tensão do sensor LM35 e converter para graus Celsius (°C).
Interface Visual:
Verde: Temperatura ideal (abaixo de 25°C).
Amarelo: Atenção (entre 25°C e 30°C).
Vermelho: Alerta de calor (acima de 30°C).
A temperatura atualizada deve ser enviada para o Monitor Serial a cada 2 segundos.

Material: 1x Arduino Uno, 1x LED, 1x ~sensor de temperatura 220Ω, Jumpers, .

Nota: Neste código foi utilizada uma função para facilitar a organização e leitura.

/**
 * Projeto: Monitor de Temperatura com LM35
 * Descrição: Aciona LEDs baseados na temperatura lida.
 */

// Definição dos pinos para os LEDs (Uso de nomes claros)
#define PIN_LED_RED 13
#define PIN_LED_YELLOW 12
#define PIN_LED_GREEN 11
#define PIN_LM35 A0

// Configurações iniciais
void setup() {
  pinMode(PIN_LED_RED, OUTPUT);
  pinMode(PIN_LED_YELLOW, OUTPUT);
  pinMode(PIN_LED_GREEN, OUTPUT);
  
  // Inicializa a comunicação serial para debug
  Serial.begin(9600);
  Serial.println("--- Sistema Iniciado ---");
  
  // Muda a referência para 1.1V (mais precisa para sensores de baixa tensão)
  analogReference(INTERNAL);
}

void loop() {
  // 1. Leitura do sensor (0 a 1023)
int leituraADC = analogRead(PIN_LM35);
  
  // Novo cálculo baseado na referência interna de 1.1V
  // 1.1V / 1024 passos = 0.001074V por unidade ADC
  // Como o sensor é 10mV/°C, dividimos por 0.01
  //float temperatura = (leituraADC * 1.1 * 100.0) / 1024.0;
  //float temperatura = int((float(analogRead(leituraADC))*5/(1024.0))/0.01);

  // 3. Exibição no Monitor Serial
  Serial.print("Temperatura Atual: ");
  Serial.print(temperatura);
  Serial.write(176); // Envia "º" o caractere de grau diretamente
  Serial.println(" C");

  // 4. Chamada da FUNçÃO - Lógica de controlo dos LEDs
  gerirAlertas(temperatura);

  // Intervalo de amostragem
  delay(2000);
}

/**
 * Função auxiliar para organizar a lógica dos LEDs
 */
void gerirAlertas(float temp) {
  // Apaga todos os LEDs antes de ligar o correto (evita sobreposição)
  digitalWrite(PIN_LED_GREEN, LOW);
  digitalWrite(PIN_LED_YELLOW, LOW);
  digitalWrite(PIN_LED_RED, LOW);

  if (temp < 25.0) {
    digitalWrite(PIN_LED_GREEN, HIGH); // Temperatura Ideal
  } 
  else if (temp >= 25.0 && temp <= 30.0) {
    digitalWrite(PIN_LED_YELLOW, HIGH); // Atenção
  } 
  else {
    digitalWrite(PIN_LED_RED, HIGH); // Alerta / Calor
  }
}

Desafio 4: Monitor de Temperatura Inteligente com LCD.

Objetivo: Criar um sistema de monitorização térmico utilizando um sensor LM35 e um LCD LiquidCrystal.

Explicação: Leitura Analógica: O sistema deve ler o valor de tensão do sensor LM35 e converter para graus Celsius (°C).
Interface Visual:
LCD (liquid crystal display).
A temperatura atualizada deve ser enviada para o Monitor Serial a cada 2 segundos.

Material: 1x Arduino Uno, 1x LED, 1x ~sensor de temperatura 220Ω, Jumpers, LCD (liquid crystal display) .

Nota: Neste código foi utilizada uma função para facilitar a organização e leitura.

// Biblioteca LCD 
#include <LiquidCrystal.h>

// Inicializa a biblioteca LCD
LiquidCrystal LCD(12,11,5,4,3,2);

// Define o pino analogico A0 como entrada do Sensor de Temperatura
int SensorTempPino=0;

// Define o pino 8 para o alerta de temperatura baixa
int AlertaTempBaixa=8;
// Define o pino 13 para o alerta de temperatura alta
int AlertaTempAlta=13;

// Define temperatura baixa como abaixo de zero grau Celsius
int TempBaixa=0;
// Define temperatura alta como acima de 40 graus Celsius
int TempAlta=40;

void setup() {
	// Define o pino de alerta de temperatura baixa como saida
  	pinMode(AlertaTempBaixa, OUTPUT);
	// Define o pino de alerta de temperatura alta como saida
	pinMode(AlertaTempAlta, OUTPUT);

	// Define a quantidade de colunas e linhas do LCD
	LCD.begin(16,2);
	// Imprime a mensagem no LCD
	LCD.print("Temperatura:");
	// Muda o cursor para a primeira coluna e segunda linha do LCD
	LCD.setCursor(0,1);
	// Imprime a mensagem no LCD
	LCD.print("      C        F");
}

void loop() {
	// Faz a leitura da tensao no Sensor de Temperatura
	int SensorTempTensao=analogRead(SensorTempPino);

  	// Converte a tensao lida
	float Tensao=SensorTempTensao*5;
	Tensao/=1024;

  	// Converte a tensao lida em Graus Celsius
	float TemperaturaC=(Tensao-0.5)*100;

  	// Converte a temperatura em Graus Celsius para Fahrenheit
	float TemperaturaF=(TemperaturaC*9/5)+32;
  

  	// Muda o cursor para a primeira coluna e segunda linha do LCD
  	LCD.setCursor(0,1);

  	// Imprime a temperatura em Graus Celsius
	LCD.print(TemperaturaC);

  	// Muda o cursor para a decima coluna e segunda linha do LCD
	LCD.setCursor(9,1);

  	// Imprime a temperatura em Graus Fahrenheit
  	LCD.print(TemperaturaF);
  	

	// Acende ou apaga os alertas luminosos de temperatura baixa e alta
  	if (TemperaturaC>=TempAlta) {
  		digitalWrite(AlertaTempBaixa, LOW);
  		digitalWrite(AlertaTempAlta, HIGH);
    }
  	else if (TemperaturaC<=TempBaixa){
  		digitalWrite(AlertaTempBaixa, HIGH);
  		digitalWrite(AlertaTempAlta, LOW);
  	}
  	else {
  		digitalWrite(AlertaTempBaixa, LOW);
  		digitalWrite(AlertaTempAlta, LOW);
    }

  	// Aguarda 1 segundo
  	delay(1000);
}

🏆 Desafio Final: Sistema de Estacionamento

O Desafio: Cria um sistema onde o **Sensor Ultrassónico** deteta um carro. Se a distância for menor que 10cm, o **LED** acende e o **Servo Motor** levanta 90º (abre a cancela).

Integração Total: Este desafio combina Lógica de Entrada (Sensor), Processamento (IF/ELSE) e Saídas (LED e Servo).

Tenta escrever o código sozinho usando os exemplos anteriores como base!

Solução