Relatório - Prática 6

Alunos: Bruno Véras Schulz, Marcelo Blak, Pedro Kury Kitagawa

Introdução

A utilização da placa Arduino Uno em projetos eletrônicos permite a implementação de diversas

práticas, explorando suas funcionalidades e versatilidade. Neste relatório, são abordadas três
práticas distintas:

1. Conexão de um LCD 16x2 para exibição da temperatura interna;

2. Implementação de um display de 7 segmentos controlado por dois botões (decrescimento e
acréscimo);
3. Decodificação do sinal de um controle infravermelho e exibição no monitor serial.

➢ Conexão do LCD 16x2 para exibição de temperatura

Para a primeira prática, foi estabelecida a conexão de um LCD 16x2 à placa Arduino Uno. O
objetivo era exibir a temperatura no display a partir de um sensor interno do Arduino. O código utiliza
a biblioteca LiquidCrystal.h para manipulação do LCD.
Utilizamos um potenciômetro ligado ao pino V0 para ajustar o contraste do display. O código
implementado realizou a leitura da temperatura interna e exibiu o resultado de forma clara no LCD
16x2.

Código:

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

float temp_celsius;
float temp_fahrenheit;

int GetTemp();

void setup()
{
lcd.begin(16,2);
}

void loop()
{
lcd.clear();
temp_celsius = GetTemp();

lcd.print(temp_celsius);
lcd.print(" C");

lcd.setCursor(0, 1); //second line

temp_fahrenheit = (1.8*temp_celsius)+32;
 lcd.print(temp_fahrenheit);
lcd.print(" F");

delay(2000);
}

double GetTemp(void) {
unsigned int wADC;
double t;
// Configura a referência interna de tensão e o canal 8
ADMUX = (_BV(REFS1) | _BV(REFS0) | _BV(MUX3));
ADCSRA |= _BV(ADEN); // habilita o conversor ADC
delay(20); // espera a tensão se estabilizar.
ADCSRA |= _BV(ADSC); // inicia a conversão ADC

// Detecta o final da conversão

while (bit_is_set(ADCSRA,ADSC));

// Faz a leitura do registrador "ADCW" (ADCL + ADCH).

wADC = ADCW;

//O valor do offset (324.31) foi ajustado para 320.0

t = (wADC - 320.0) / 1.22;

// A temperatura retornada está em graus Celsius

return (t);
}

Tinkercad:
 Foto da Prática:

➢ Implementação de display de 7 segmentos controlado por botões

Na segunda prática, um display de 7 segmentos foi conectado à placa Arduino Uno, sendo
controlado por dois botões - um para decrescimento e outro para acréscimo. O objetivo era criar um
contador. Foi necessário implementar uma lógica de anti-bouncing para detectar a pressão dos
botões e atualizar o display de acordo.
Os botões foram conectados a pinos digitais da placa e o display de 7 segmentos foi conectado
conforme as especificações do seu datasheet. O código desenvolvido realizou a contagem de forma
eficiente, garantindo a correta exibição no display.

Código
//Entradas
const int botao1 = 3; // Replace 2 with the actual pin number you're using
const int botao2 = 2;
const int entradaA = 6;
const int entradaB = 7;
const int entradaC = 10;
const int entradaD = 9;
const int entradaE = 8;
const int entradaF = 5;
const int entradaG = 4;

//Variaveis de controle
int cont = 0;

void atualizaDisplay(int cont);

void acres();
void decres();

void setup() {
 Serial.begin(9600);
pinMode(botao1, INPUT_PULLUP);
pinMode(botao2, INPUT_PULLUP);
pinMode(entradaA, OUTPUT); //A
pinMode(entradaB, OUTPUT); //B
pinMode(entradaC, OUTPUT); //C
pinMode(entradaD, OUTPUT); //D
pinMode(entradaE, OUTPUT); //E
pinMode(entradaF, OUTPUT); //F
pinMode(entradaG, OUTPUT); //G
attachInterrupt(digitalPinToInterrupt(botao1), acres, FALLING);
attachInterrupt(digitalPinToInterrupt(botao2), decres, FALLING);
atualizaDisplay(cont);
}

void loop() {
atualizaDisplay(cont);
}

void acres() {
cont++;
if (cont > 9) cont = 0;
}

void decres() {
cont--;
if (cont < 0) cont = 9;
}

void atualizaDisplay(int cont){

switch(cont){
case 0:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, HIGH);
digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, LOW);
break;
case 1:
digitalWrite(entradaA, LOW);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, LOW);
 digitalWrite(entradaE, LOW);
digitalWrite(entradaF, LOW);
digitalWrite(entradaG, LOW);
break;
case 2:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, LOW);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, HIGH);
digitalWrite(entradaF, LOW);
digitalWrite(entradaG, HIGH);
break;
case 3:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, LOW);
digitalWrite(entradaF, LOW);
digitalWrite(entradaG, HIGH);
break;
case 4:
digitalWrite(entradaA, LOW);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, LOW);
digitalWrite(entradaE, LOW);
digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, HIGH);
break;
case 5:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, LOW);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, LOW);
digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, HIGH);
break;
case 6:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, LOW);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, HIGH);
 digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, HIGH);
break;
case 7:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, LOW);
digitalWrite(entradaE, LOW);
digitalWrite(entradaF, LOW);
digitalWrite(entradaG, LOW);
break;
case 8:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, HIGH);
digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, HIGH);
break;
case 9:
digitalWrite(entradaA, HIGH);
digitalWrite(entradaB, HIGH);
digitalWrite(entradaC, HIGH);
digitalWrite(entradaD, HIGH);
digitalWrite(entradaE, LOW);
digitalWrite(entradaF, HIGH);
digitalWrite(entradaG, HIGH);
break;
default:
break;
}
}

Tinkercad:
Fotos:
➢ Decodificação do sinal de controle inframavelho

Na terceira prática, um controle infravermelho foi utilizado para enviar sinais à placa Arduino
Uno. O objetivo era decodificar esses sinais e exibir as informações correspondentes no monitor
serial. O sensor infravermelho foi conectado aos pinos adequados da placa.
O código desenvolvido utilizou uma biblioteca específica para a decodificação dos sinais
infravermelhos, a IrRemote.hpp. Os resultados hexadecimais foram mapeados, baseado nos sinais
emitidos pelo controle usado no laboratório, e impressos no monitor serial de maneira legível ao
usuário. Exemplificando, o botão 0 do controle imprimia “0” no console, ao invés do código
hexadecimal.

Código:
#define IR_RECEIVE_PIN 3
#include <IRremote.hpp>

void setup()
{
Serial.begin(9600);
delay(1000);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK); //configura o lcd
}

void loop() {

if (IrReceiver.decode()) {
//IrReceiver.printIRResultShort(&Serial); //imprime os sinais captados

switch(IrReceiver.decodedIRData.command){ //códigos mapeados

case 0x45: Serial.println("1"); break;
case 0x46: Serial.println("2"); break;
case 0x47: Serial.println("3"); break;
case 0x44: Serial.println("4"); break;
 case 0x40: Serial.println("5"); break;
case 0x43: Serial.println("6"); break;
case 0x7: Serial.println("7"); break;
case 0x15: Serial.println("8"); break;
case 0x9: Serial.println("9"); break;
case 0x19: Serial.println("0"); break;
case 0x16: Serial.println("*"); break;
case 0xD: Serial.println("#"); break;
case 0x18: Serial.println("^"); break;
case 0x8: Serial.println("<"); break;
case 0x52: Serial.println("v"); break;
case 0x5A: Serial.println(">"); break;
case 0x1C: Serial.println("OK"); break;
}
IrReceiver.resume(); // prepara o receptor pro proximo valor

}
}

Tinkercad:

Fotos:
Conclusão

As práticas realizadas demonstraram a capacidade da placa Arduino Uno em lidar com

diferentes dispositivos e sensores. A conexão do LCD 16x2 permitiu a exibição da temperatura
interna de forma eficiente. A implementação do display de 7 segmentos controlado por botões
adicionou uma aplicação prática de contagem. Por fim, a decodificação do controle infravermelho
ampliou as possibilidades de interação remota.