Aula pratica Sistemas digitais e microprocessadores

Prévia do material em texto

UNIVERSIDADE PITÁGORAS UNOPAR ANHANGUERA
ENGENHARIA ELÉTRICA
ATIVIDADE PRÁTICA
SISTEMAS DIGITAIS E MICROPROCESSADORES
Araraquara - Sp
2025
ATIVIDADE PRÁTICA
SISTEMAS DIGITAIS E MICROPROCESSADORES
Trabalho apresentado à Universidade, como requisito parcial para a obtenção de média semestral nas disciplinas norteadoras do semestre letivo.
Araraquara - Sp
2025
SUMÁRIO
1 INTRODUÇÃO	3
2 ATIVIDADE PRÁTICA 1	4
2 ATIVIDADE PRÁTICA 2	10
3 ATIVIDADE PRÁTICA 3	14
4 ATIVIDADE PRÁTICA 4	22
5 ATIVIDADE PRÁTICA 5	28
CONCLUSÃO	38
REFERÊNCIAS BIBLIOGRÁFICAS	39
1 INTRODUÇÃO 
Este portfólio detalha diversas atividades práticas executadas durante o curso de Sistemas Digitais e Microprocessadores, com o objetivo de oferecer uma compreensão abrangente dos conceitos essenciais ligados a circuitos digitais e microcontroladores. As atividades englobam desde a construção de circuitos básicos até a programação avançada de microcontroladores Arduino.
Na Aula Prática 1, foi desenvolvido e implementado um circuito para monitorar a produção de uma fábrica, utilizando 8 teclas, cada uma correspondendo a uma quantidade específica de itens fabricados. O simulador Logisim foi empregado para explorar o uso de entradas e saídas, além dos conceitos de codificador de prioridade e decodificador. O principal objetivo foi simular o funcionamento do circuito digital e analisar seu efeito na produção.
Na Aula Prática 2, o foco foi ampliado para o design, simulação e construção de circuitos lógicos mais avançados. Utilizou-se a ferramenta Logisim para desenvolver um contador binário de 4 bits e um contador decimal codificado em binário (BCD), aprimorando as habilidades na manipulação de circuitos digitais.
Na Aula Prática 3, foram apresentados os microcontroladores, com ênfase no Arduino. Além de explorar o funcionamento fundamental do Arduino, foram programados algoritmos básicos, marcando o início do desenvolvimento de sistemas de controle.
Na Aula Prática 4, o estudo sobre microcontroladores foi aprofundado com a programação de algoritmos para desenvolver um relógio em tempo real e uma estação meteorológica, incorporando sensores de temperatura e umidade.
Por último, a Aula Prática 5 focou na aplicação prática dos microcontroladores Arduino em contextos específicos, incluindo a implementação de um sensor ultrassom com LED RGB e um sensor ultrassom combinado com um timer.
Durante essas atividades, foi adotada uma abordagem prática e hands-on, reforçando os conceitos teóricos adquiridos em sala de aula. Este portfólio não apenas demonstra o avanço das habilidades técnicas, mas também evidencia a capacidade de enfrentar e resolver problemas complexos no âmbito dos sistemas digitais e microprocessadores.
2 ATIVIDADE PRÁTICA 1
A realização da primeira atividade prática no simulador Logisim consistiu em uma série de etapas essenciais para a implementação bem-sucedida de um circuito projetado para registrar a produção de uma fábrica usando 8 teclas. A seguir, são descritos os passos seguidos durante essa atividade:
· Abertura do Software Simulador Logisim:
Primeiramente, foi iniciado o software Logisim, que foi selecionado como a plataforma para a simulação dos circuitos digitais.
· Inserção de Teclas e Rótulos:
Para representar as 8 teclas relacionadas à produção, foram adicionadas teclas no simulador, alinhadas e rotuladas de forma adequada para indicar o valor correspondente a cada uma.
Figura 1 – Inserção de Teclas e Rótulos.
Fonte: O Autor.
· Inserção do Codificador de Prioridade:
O Codificador de Prioridade foi integrado ao circuito, desempenhando a função de exibir na saída o valor da entrada com a maior prioridade quando várias entradas são recebidas. As outras 7 teclas foram conectadas a esse codificador.
· Inserção da Entrada de Enable:
Foi adicionada uma entrada de Enable ao codificador de prioridade para ativar seu funcionamento.
Figura 2 – Inserção da Entrada.
Fonte: O Autor.
· Inserção da Saída:
Foi adicionada uma saída para mostrar o valor binário correspondente à entrada ativada, variando de 0 a 7.
Figura 3 – Inserção da Saída.
Fonte: O Autor.
· Simulação do Codificador de Prioridade:
A simulação do codificador de prioridade foi realizada preenchendo uma tabela com as entradas e saídas. Observou-se que a saída refletia o valor binário mais alto entre as entradas habilitadas. Conforme tabela abaixo:
Tabela 1 – Simulação Codificador.
	Enable
	Tecla Acionada
	Saída
	0
	Tecla de 1 a 8 Acionada
	111
	1
	Nenhuma Tecla Acionada
	xxx
	1
	1
	000
	1
	2
	001
	1
	3
	010
	1
	4
	011
	1
	5
	100
	1
	6
	101
	1
	7
	110
Fonte: O Autor.
· Inserção do Decodificador:
O decodificador foi integrado ao circuito, configurando o número de bits na entrada e realizando as conexões necessárias.
Figura 4 – Inserção do Decodificador.
Fonte: O Autor.
· Inserção das Saídas do Decodificador:
As saídas do decodificador foram incorporadas ao circuito.
Figura 5 – Saídas do Decodificador.
Fonte: O Autor.
· Testes de Possibilidades:
Foram conduzidos testes extensivos em todas as possibilidades do circuito, registrando as saídas ativadas para diferentes combinações de teclas. Conforme tabela abaixo:
Tabela 2 – Simulação Decodificador.
	Enable
	Tecla Acionada
	Saída
	0
	Tecla de 1 a 8 Acionada
	8
	1
	Nenhuma Tecla Acionada
	xxx
	1
	1
	1
	1
	2
	2
	1
	3
	3
	1
	4
	4
	1
	5
	5
	1
	6
	6
	1
	7
	7
	1
	8
	8
Fonte: O Autor.
· Resumo da Lógica de Funcionamento:
O circuito é composto por um codificador de prioridade seguido por um decodificador. O codificador de prioridade identifica a tecla com a maior prioridade que está ativada e gera uma saída binária correspondente. Em seguida, o decodificador recebe essa saída binária e a converte de volta para a representação decimal, indicando qual tecla foi acionada. A operação do circuito pode ser resumida da seguinte maneira:
Codificador de Prioridade: O circuito possui 8 entradas, cada uma correspondendo a uma tecla numerada de 1 a 8. O codificador de prioridade determina qual tecla possui a maior prioridade entre as ativadas. A saída do codificador fornece a representação binária do número da tecla com a maior prioridade.
Decodificador: O decodificador recebe a saída binária do codificador e a converte de volta para a forma decimal, revelando qual tecla foi ativada.
Exemplos de Comportamento:
Combinação 1:
Enable = 1 (Habilitado)
Tecla Acionada = 3
Saída do Codificador = 010 (correspondente a 3 em binário)
Saída do Decodificador = 3
Resultado: A tecla 3 está acionada, e a saída correta é 3.
Combinação 2:
Enable = 1 (Habilitado)
Tecla Acionada = 1
Saída do Codificador = 000 (correspondente a 1 em binário)
Saída do Decodificador = 1 (decimal)
Resultado: A tecla 1 está acionada, e a saída correta é 1.
Combinação 3:
Enable = 1 (Habilitado)
Tecla Acionada = 7
Saída do Codificador = 110 (correspondente a 6 em binário)
Saída do Decodificador = 7
Resultado: A tecla 7 está acionada, e a saída correta é 7.
2 ATIVIDADE PRÁTICA 2
A segunda atividade prática consistiu na utilização do software Logisim para o design e simulação de circuitos lógicos mais avançados, com ênfase na implementação de um meio somador binário e um contador assíncrono de 4 bits. Abaixo estão descritos os passos executados durante essa atividade:
1) Implementação do Meio Somador:
· Inserção de Componentes:
Inicialmente, foi necessário adicionar portas lógicas ao ambiente de simulação, incluindo portas NAND e OR, bem como duas portas inversoras. As entradas A e B foram inseridas, e as portas foram devidamente posicionadas.
Figura 6 – Portas.
Fonte: O Autor.
· Conexões e Testes:
Foram realizadas as conexões entre os componentes, considerando a lógica do meio somador. Testes foram efetuados, alternando os valores das entradas A e B para observar as saídas da porta NAND e OR.
Figura 7 – Conexões.
Fonte: O Autor.
Os resultados foram registrados em uma tabela verdade, a seguir:
Tabela 3 – Tabela Verdade da Porta NAND.
	A
	B
	S
	0
	0
	1
	01
	1
	1
	0
	1
	1
	1
	0
Fonte: O Autor.
Tabela 4 – Tabela Verdade da Porta OR Negativa.
	A
	B
	S
	0
	0
	1
	0
	1
	1
	1
	0
	1
	1
	1
	0
Fonte: O Autor.
· Projeto do Circuito Meio Somador:
Utilizando as portas lógicas disponíveis no Logisim, foi projetado o circuito lógico para um meio somador binário.
Figura 8 – Meio Somador.
Fonte: O Autor.
· Simulação e Verificação:
O circuito desenvolvido foi simulado no Logisim para confirmar se ele realizava corretamente as operações esperadas, de acordo com a tabela verdade do meio somador. As entradas foram variadas e as saídas analisadas para assegurar a precisão do circuito, conforme mostrado nas tabelas a seguir:
Tabela 5 – Tabela Verdade Meio Somador.
	Entradas
	Saídas
	A
	B
	S
	Co
	0
	0
	0
	0
	0
	1
	1
	0
	1
	0
	1
	0
	1
	1
	0
	1
Fonte: O Autor.
2) Projeto do Contador Assíncrono de 4 Bits:
· Entendimento dos Contadores Assíncronos:
No conceito de contadores assíncronos, onde o primeiro flip-flop recebe um sinal de clock externo, e cada flip-flop subsequente recebe o clock através da saída do anterior.
· Projeto do Contador de 4 Bits Assíncrono:
Com base no conhecimento adquirido sobre contadores assíncronos, foi projetado um contador de 4 bits. Flip-flops foram encadeados, e as conexões foram estabelecidas conforme as características desse tipo de contador.
Figura 9 – Contador de 4 Bits Assíncrono.
Fonte: O Autor.
3) Projeto do Contador de Década BCD:
· Entendimento dos Contadores de Década BCD:
No conceito de contadores de década BCD, que contam de 0 (0000) até 9 (1001). Esses contadores podem ser projetados para ter uma sequência truncada.
· Projeto do Contador de Década BCD:
Foi projetado um contador de década BCD, considerando a sequência de 0 a 9. Flip-flops foram utilizados para representar cada dígito, e as conexões foram estabelecidas de acordo com a lógica BCD.
Figura 10 – Contador de Década.
Fonte: O Autor.
3 ATIVIDADE PRÁTICA 3
Etapa 1
Na primeira fase da Atividade 3, foram criados programas para o Arduino Uno utilizando a plataforma Arduino IDE, com a finalidade de executar operações específicas. A seguir, estão descritos os detalhes dos procedimentos realizados em cada parte da atividade:
Parte 1: Programa de Eco para Arduino Uno
· Desenvolvimento do Programa:
Foi desenvolvido um programa para implementar a funcionalidade de eco, que consiste em repetir qualquer caractere recebido pela porta serial. O código abrange a leitura de caracteres da porta serial e a retransmissão desses caracteres de volta para a mesma. O código a seguir foi criado e utilizado:
void setup() {
 Serial.begin(9600); // Inicializa a comunicação serial com taxa de 9600 bps
}
void loop() {
 if (Serial.available() > 0) { // Verifica se há dados disponíveis na porta serial
 char receivedChar = Serial.read(); // Lê o caractere recebido
 Serial.print("Você digitou: "); // Envia uma mensagem indicando o caractere recebido
 Serial.println(receivedChar); // Envia o caractere recebido de volta pela porta serial
 }
}
· Envio e Teste:
O programa foi carregado no Arduino Uno usando a Arduino IDE. Após o upload, o Arduino foi conectado ao computador e a comunicação serial foi estabelecida. Foram realizados testes enviando caracteres pela porta serial, e o Arduino respondeu repetindo os caracteres recebidos.
Parte 2: Programa de Piscar LEDs em Sequência para Arduino Uno
· Desenvolvimento do Programa:
Foi desenvolvido um programa que simula um registrador de deslocamento com 5 LEDs. Cada LED acende sequencialmente por 200 ms, de forma cíclica. O código incluiu a configuração dos pinos dos LEDs, a lógica de acendimento sequencial e o uso de delay para controlar o tempo de cada LED aceso. O seguinte código foi desenvolvido e utilizado:
const int numLEDs = 5; // Número de LEDs
const int pinLEDs[] = {8, 9, 10, 11, 12}; // Pinos dos LEDs
const int tempoAceso = 200; // Tempo em milissegundos que cada LED ficará aceso
void setup() {
 for (int i = 0; i = 3) { // Verifica se há pelo menos 3 bytes disponíveis na serial
 Serial.readBytes(comandoSerial, 3); // Lê os 3 bytes do comando
 comandoSerial[3] = '\0'; // Adiciona o caractere nulo ao final para formar uma string
 int luminosidade = atoi(comandoSerial); // Converte a string para um valor inteiro
 // Limita a luminosidade entre 0 e 255
 luminosidade = constrain(luminosidade, 0, 255);
 analogWrite(pinoLED, luminosidade); // Define a luminosidade do LED
 }
}
· Montagem e Teste:
Um LED foi conectado ao pino 10 do Arduino e a comunicação serial foi configurada. Após carregar o programa no Arduino, foram realizados testes enviando comandos válidos (três dígitos entre 000 e 255) pela porta serial para regular a luminosidade do LED. Um resistor de 220 Ω foi colocado em série com o LED para controlar a corrente elétrica.
Etapa 2
Na segunda fase da Atividade 3, foi desenvolvido um projeto no Tinkercad para criar um monitor de umidade do solo usando o Arduino. A seguir, estão descritos os detalhes dos procedimentos realizados durante essa etapa:
Parte 1: Monitor de Umidade do Solo com Arduino
· Componentes para o Projeto:
Para a construção deste projeto, foram necessários os seguintes componentes:
- 1 Arduino;
- 1 Protoboard;
- 5 LEDs (Vermelho, Amarelo, Laranja, Azul e Verde);
- 5 resistores de 220 Ohms;
- Módulo sensor de umidade dosolo.
· Conexões Realizadas:
As seguintes conexões foram feitas no Tinkercad:
Conectou-se as saídas 9, 10, 11, 12 e 13 do Arduino aos ânodos dos LEDs;
Criou-se a conexão do cátodo dos LEDs para os resistores de 220 Ohms;
Conectou-se o outro terminal dos resistores ao GND (negativo) do Arduino;
Fez-se as conexões de forma organizada e limpa;
Conectou-se o pino VCC do sensor de umidade do solo à porta A0;
Conectou-se o pino GND do sensor de umidade do solo ao GND do Arduino;
Conectou-se o pino SIG do sensor de umidade à porta A1.
]
· Algoritmo em Linguagem C:
Ao iniciar o desenvolvimento do código, foram definidas as seguintes variáveis:
Variável "umidade" para armazenar o valor do sinal de umidade, inicializada com 0;
Variáveis "led_vermelho", "led_amarelo", "led_laranja", "led_azul" e "led_verde" para controlar os LEDs conectados aos pinos 13, 12, 11, 10 e 9, respectivamente;
Variáveis "pin_vcc" e "pin_sensor" para controle do sensor de umidade.
Configuração no Setup():
No bloco void setup(), foram realizadas as seguintes definições:
Definição das variáveis "led_" como saída;
Definição da variável "pin_vcc" como saída;
Definição da variável "pin_sensor" como entrada;
Inicialização da comunicação serial com Serial.begin(9600).
· Loop de Execução:
No bloco void loop(), as seguintes ações foram programadas:
Aplicação de tensão no pino VCC do sensor de umidade;
Leitura da variável "umidade" usando analogRead(pin_sensor);
Impressão do valor da variável "umidade" no monitor serial;
Desligamento de todos os LEDs;
Verificação para acender cada LED com base nas regras fornecidas.
Conforme o seguinte código:
const int led_vermelho = 13;
const int led_amarelo = 12;
const int led_laranja = 11;
const int led_azul = 10;
const int led_verde = 9;
const int pin_vcc = A0;
const int pin_sensor = A1;
int umidade = 0;
void setup() {
 pinMode(led_vermelho, OUTPUT);
 pinMode(led_amarelo, OUTPUT);
 pinMode(led_laranja, OUTPUT);
 pinMode(led_azul, OUTPUT);
 pinMode(led_verde, OUTPUT);
 pinMode(pin_vcc, OUTPUT);
 pinMode(pin_sensor, INPUT);
 Serial.begin(9600);
}
void loop() {
 digitalWrite(pin_vcc, HIGH);
 umidade = analogRead(pin_sensor);
 Serial.println(umidade);
 digitalWrite(led_vermelho, LOW);
 digitalWrite(led_amarelo, LOW);
 digitalWrite(led_laranja, LOW);
 digitalWrite(led_azul, LOW);
 digitalWrite(led_verde, LOW);
 if (umidade 
#include 
#include 
#define DHTPIN 2 // Pino de dados do sensor DHT11
#define DHTTYPE DHT11 // Tipo do sensor DHT
RTC_DS1302 rtc;
DHT dht(DHTPIN, DHTTYPE);
void setup() {
 Serial.begin(9600);
 if (!rtc.begin()) {
 Serial.println("Não foi possível encontrar o módulo RTC!");
 while (1);
 }
 if (!rtc.isrunning()) {
 Serial.println("Configurando a hora!");
 rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
 }
 dht.begin();
}
void loop() {
 DateTime now = rtc.now();
 float temperature = dht.readTemperature();
 float humidity = dht.readHumidity();
 Serial.print("Data e Hora: ");
 Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(" ");
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.println(now.second(), DEC);
 Serial.print("Temperatura: ");
 Serial.print(temperature);
 Serial.print(" °C, Umidade: ");
 Serial.print(humidity);
 Serial.println(" %");
 delay(60000); // Aguarda 1 minuto antes da próxima leitura
}
2. Programa para Simulação de Estação Meteorológica com Armazenamento na EEPROM:
Foi elaborado um programa que simula uma estação meteorológica, medindo a umidade e a temperatura a cada minuto. O módulo DS1302 foi utilizado para fornecer a data e a hora com precisão. Os dados de data, hora, temperatura e umidade foram armazenados na EEPROM do Arduino. Evitou-se o uso da função delay para garantir a precisão da amostragem. Implementou-se uma lógica para evitar o estouro da EEPROM, considerando suas limitações (1024 posições de 1 byte cada). Ao receber o caractere "L" pela porta serial, o microcontrolador retornou todos os dados armazenados, possibilitando a leitura e, se desejado, a exclusão ou substituição dos dados. O seguinte código foi desenvolvido e utilizado:
#include 
#include 
#include 
#include 
#define DHTPIN 2 // Pino de dados do sensor DHT11
#define DHTTYPE DHT11 // Tipo do sensor DHT
RTC_DS1302 rtc;
DHT dht(DHTPIN, DHTTYPE);
void setup() {
 Serial.begin(9600);
 if (!rtc.begin()) {
 Serial.println("Não foi possível encontrar o módulo RTC!");
 while (1);
 }
 if (!rtc.isrunning()) {
 Serial.println("Configurando a hora!");
 rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
 }
 dht.begin();
}
void loop() {
 DateTime now = rtc.now();
 float temperature = dht.readTemperature();
 float humidity = dht.readHumidity();
 Serial.print("Data e Hora: ");
 Serial.print(now.year(), DEC);
 Serial.print('/');
 Serial.print(now.month(), DEC);
 Serial.print('/');
 Serial.print(now.day(), DEC);
 Serial.print(" ");
 Serial.print(now.hour(), DEC);
 Serial.print(':');
 Serial.print(now.minute(), DEC);
 Serial.print(':');
 Serial.println(now.second(), DEC);
 Serial.print("Temperatura: ");
 Serial.print(temperature);
 Serial.print(" °C, Umidade: ");
 Serial.print(humidity);
 Serial.println(" %");
 // Armazena dados na EEPROM
 int address = 0;
 EEPROM.write(address++, now.day());
 EEPROM.write(address++, now.month());
 EEPROM.write(address++, now.year() % 100);
 EEPROM.write(address++, now.hour());
 EEPROM.write(address++, now.minute());
 EEPROM.put(address, temperature);
 address += sizeof(float);
 EEPROM.put(address, humidity);
 address += sizeof(float);
 delay(60000); // Aguarda 1 minuto antes da próxima leitura
}
void readAndPrintStoredData() {
 int address = 0;
 while (address");
 Serial.print(hour);
 Serial.print(':');
 Serial.print(minute);
 Serial.println();
 Serial.print("Temperatura: ");
 Serial.print(temperature);
 Serial.print(" °C, Umidade: ");
 Serial.print(humidity);
 Serial.println(" %");
 }
}
void serialEvent() {
 while (Serial.available()) {
 char command = Serial.read();
 if (command == 'L') {
 Serial.println("Recuperando dados armazenados:");
 readAndPrintStoredData();
 // Os dados podem ser apagados após serem lidos
 // Descomente a linha abaixo se desejar apagar os dados após a leitura
 // EEPROM.write(0, 0);
 }
 }
}
5 ATIVIDADE PRÁTICA 5
Etapa 1
Na Etapa 1 da Atividade 5, foram criados dois programas para o Arduino Uno, cada um com uma função específica envolvendo o sensor ultrassônico e o LED RGB. A seguir, estão descritos os detalhes dos procedimentos realizados nesta etapa:
1. Programa para Indicação de Distância por Meio de um LED RGB:
Foi desenvolvido um programa que emprega um LED RGB para sinalizar a distância detectada pelo sensor ultrassônico. O LED RGB foi ligado aos pinos 9, 10 e 11 do Arduino, que suportam saídas PWM para controlar a intensidade da luz. Para limitar a corrente, um resistor foi inserido em série com cada cor do LED.
Foi estabelecido que, quando a distância do objeto for superior a 50 cm, o LED deverá exibir a cor verde plena. Conforme a distância diminui, a cor do LED mudará gradualmente para o amarelo até alcançar 25 cm, momento em que o LED será totalmente amarelo. Quando a distância for menor que 25 cm, o LED começará a exibir um tom avermelhado, tornando-se completamente vermelho quando a distância for inferior a 5 cm.
O código foi transferido para o Arduino e testado para assegurar que a indicação da distância através do LED RGB funcionasse corretamente. O código abaixo foi elaborado e empregado nos testes:
const int trigPin = 2; // Pino de controle do trigger do sensor ultrassônico
const int echoPin = 3; // Pino de controle do echo do sensor ultrassônico
const int redPin = 9; // Pino PWM para a cor vermelha do LED RGB
const int greenPin = 10; // Pino PWM para a cor verde do LED RGB
const int bluePin = 11; // Pino PWM para a cor azul do LED RGB
const int maxDistance = 50; // Distância máxima para a cor verde (em cm)
const int minDistance = 5; // Distância mínima para a cor vermelha (em cm)
const int yellowDistance = 25; // Distância para a transição de verde para amarelo (em cm)
void setup() {
 Serial.begin(9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);
}
void loop() {
 long duration;
 int distance;
 // Gera um pulso no pino de trigger
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Lê a duração do pulso no pino de echo
 duration = pulseIn(echoPin, HIGH);
 // Converte a duração para distância
 distance = duration * 0.034 / 2;
 // Imprime a distância no monitor serial
 Serial.print("Distancia: ");
 Serial.println(distance);
 // Atualiza a cor do LED com base na distância medida
 updateLEDColor(distance);
 delay(500); // Aguarda 500 milissegundos antes da próxima leitura
}
void updateLEDColor(int distance) {
 if (distance > maxDistance) {
 setColor(0, 255, 0); // Cor verde
 } else if (distance yellowDistance) {
 // Interpolação linear para obter a intensidade da cor amarela
 int greenIntensity = map(distance, yellowDistance, maxDistance, 255, 0);
 setColor(255, greenIntensity, 0); // Cor amarela
 } else if (distance = minDistance) {
 // Interpolação linear para obter a intensidade da cor vermelha
 int redIntensity = map(distance, minDistance, yellowDistance, 0, 255);
 setColor(redIntensity, 255, 0); // Cor vermelha
 } else {
 setColor(255, 0, 0); // Cor vermelha (distância abaixo do mínimo)
 }
}
void setColor(int red, int green, int blue) {
 analogWrite(redPin, red);
 analogWrite(greenPin, green);
 analogWrite(bluePin, blue);
}
2. Programa para Leitura de Distância e Piscar de LED Proporcional à Distância:
Foi desenvolvido um programa que lê a distância detectada pelo sensor ultrassônico e transmite essa informação pela porta serial a cada segundo, com as medidas sendo registradas em centímetros. O LED conectado ao pino 13 do Arduino foi configurado para piscar a uma velocidade que varia conforme a distância medida. Para gerenciar as duas bases de tempo necessárias no programa—uma para a amostragem e transmissão da distância via serial e outra para o controle do LED—foi utilizada uma interrupção do timer.
Foi estabelecido que, quando a distância medida for igual ou superior a 50 cm, o LED deve alternar seu estado a cada 1 segundo. À medida que a distância diminui, o intervalo de tempo deve variar proporcionalmente. O código foi carregado no Arduino e testado para garantir que a leitura da distância e o padrão de piscar do LED corresponderiam corretamente à distância medida. O código abaixo foi criado e utilizado para esses testes:
const int trigPin = 2; // Pino de controle do trigger do sensor ultrassônico
const int echoPin = 3; // Pino de controle do echo do sensor ultrassônico
const int ledPin = 13; // Pino para o LED no Arduino
volatile unsigned long pulseWidth;
volatile unsigned long startTime;
volatile boolean echoReceived = false;
void setup() {
 Serial.begin(9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(ledPin, OUTPUT);
 // Configuração da interrupção do timer
 cli(); // Desabilita interrupções durante a configuração
 TCCR1A = 0;
 TCCR1B = 0;
 TCNT1 = 0;
 OCR1A = 15624; // Valor para 1 segundo com prescaler de 256
 TCCR1B |= (1ao Arduino conforme necessário. O LED RGB foi conectado aos pinos 9, 10 e 11 do Arduino, que possuem saídas PWM para controle da intensidade da luz. O sinal do sensor de distância foi ligado a um pino livre no Arduino, evitando os pinos 0, 1 e 13, que já estavam ocupados pelo LED.
· Criação do Programa Arduino:
Foi desenvolvido um programa para o Arduino Uno que utilizava o LED RGB para indicar a distância detectada pelo sensor ultrassônico. A lógica de controle das cores do LED foi definida com base nas medições do sensor:
Quando um objeto estava a mais de 50 cm, a cor do LED era totalmente verde.
Com a redução da distância até 25 cm, a cor do LED tornava-se amarela.
A partir de 25 cm, o LED ia se tornando vermelho com a aproximação do objeto, e ficava totalmente vermelho quando a distância era inferior a 5 cm.
Foram adicionadas ao código as instruções necessárias para ler e interpretar os dados do sensor ultrassônico. O código a seguir foi criado e utilizado:
const int trigPin = 2; // Pino de controle do trigger do sensor ultrassônico
const int echoPin = 3; // Pino de controle do echo do sensor ultrassônico
const int redPin = 9; // Pino do LED RGB para a cor vermelha
const int greenPin = 10; // Pino do LED RGB para a cor verde
const int bluePin = 11; // Pino do LED RGB para a cor azul
void setup() {
 Serial.begin(9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
 pinMode(bluePin, OUTPUT);
}
void loop() {
 long duration;
 // Gera um pulso no pino de trigger
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Aguarda o início do pulso de echo
 while (digitalRead(echoPin) == LOW);
 // Inicia o tempo no início do pulso de echo
 long startTime = micros();
 // Aguarda o fim do pulso de echo
 while (digitalRead(echoPin) == HIGH);
 // Calcula a duração do pulso de echo
 long travelTime = micros() - startTime;
 // Calcula a distância com base no tempo de viagem do ultrassom
 // Considerando velocidade do som de 343 metros por segundo (34300 cm/s)
 duration = travelTime / 2;
 Serial.println(duration);
 // Atualiza a cor do LED RGB com base na distância medida
 updateLEDColor(duration);
 // Aguarda um curto intervalo antes da próxima leitura
 delay(100);
}
void updateLEDColor(long distance) {
 // Define os valores limites de distância para cada cor
 int greenDistance = 50;
 int yellowDistance = 25;
 int redDistance = 5;
 // Atualiza as cores do LED RGB com base na distância
 if (distance > greenDistance) {
 analogWrite(redPin, 0);
 analogWrite(greenPin, 255);
 analogWrite(bluePin, 0);
 } else if (distance > yellowDistance) {
 analogWrite(redPin, 255);
 analogWrite(greenPin, 255);
 analogWrite(bluePin, 0);
 } else if (distance > redDistance) {
 analogWrite(redPin, 255);
 analogWrite(greenPin, 165);
 analogWrite(bluePin, 0);
 } else {
 analogWrite(redPin, 255);
 analogWrite(greenPin, 0);
 analogWrite(bluePin, 0);
 }
}
· Simulação no Tinkercad:
A simulação foi feita no Tinkercad, ajustando a distância detectada pelo sensor ultrassônico ao clicar sobre ele. Um resistor de 220 Ohms foi colocado em série com cada cor do LED para limitar a corrente que passava por ele.
Foi realizada uma pesquisa sobre como configurar corretamente o sensor de distância ultrassônico no Tinkercad, ajustando as configurações necessárias para assegurar uma simulação precisa.
O resultado final foi uma simulação de circuito que mostrava visualmente a distância detectada pelo sensor ultrassônico através das cores do LED RGB, de acordo com as especificações definidas no programa do Arduino. Esse experimento ofereceu a oportunidade de praticar a integração de sensores e atuadores, além de simular circuitos complexos no ambiente virtual do Tinkercad.
CONCLUSÃO
Durante a elaboração deste portfólio, cada atividade foi meticulosamente planejada e realizada, oferecendo uma experiência profunda nos princípios e práticas fundamentais de Sistemas Digitais e Microprocessadores. O foco de cada etapa foi aprimorar habilidades específicas, que variaram desde a utilização de ferramentas de simulação até o desenvolvimento de firmware para microcontroladores, com a plataforma Arduino.
Na Atividade 1, utilizou-se o Logisim para implementar um codificador de prioridade, um componente essencial em circuitos digitais. Isso permitiu uma compreensão detalhada das suas entradas e saídas, proporcionando uma visão mais profunda sobre sua aplicação prática em projetos mais complexos.
Na Atividade 2, o objetivo foi aprofundar o conhecimento no Logisim, incentivando o projeto e a simulação de circuitos lógicos simples. A atividade também incluiu o desenvolvimento de circuitos contadores síncronos e assíncronos, ampliando a compreensão das capacidades dessa ferramenta.
As Atividades 3, 4 e 5 focaram no desenvolvimento de firmware para microcontroladores utilizando a plataforma Arduino. O trabalho começou com a criação de programas básicos, como eco e controle de LEDs, e avançou para projetos mais complexos, como um relógio em tempo real, uma estação meteorológica e um monitor de umidade do solo. Essas atividades tiveram o objetivo de oferecer uma compreensão completa do desenvolvimento de sistemas de controle diversos, aproveitando todas as funcionalidades oferecidas pelos microcontroladores.
Em resumo, este portfólio ofereceu uma jornada completa e progressiva no campo dos Sistemas Digitais e Microprocessadores. Cada atividade contribuiu para uma formação sólida, proporcionando não apenas conhecimentos teóricos, mas também habilidades práticas fundamentais para enfrentar desafios na eletrônica digital e em sistemas embarcados. A expertise adquirida ao longo dessas atividades certamente impactará a capacidade de desenvolver e implementar soluções inovadoras em futuros contextos.
REFERÊNCIAS BIBLIOGRÁFICAS
Arduino. Libraries. Disponível em: https://www.arduino.cc/en/Reference/Libraries. 
GitHub. Arduino Temperature Control Library. Disponível em: https://github.com/milesburton/Arduino-Temperature-Control-Library. 
IDOETA, I. V.; CAPUANO, F. G. Elementos de Eletrônica Digital. [S.l.]: Editora 
Erica, 1984.
IDOETA, I. V.; CAPUANO, F. G. Elementos de Eletrônica Digital. [S.l.]: Editora Erica, 1984.
image3.png
image5.png
image9.png
image10.png
image7.png
image4.png
image8.png
image6.png
image11.png
image2.png
image1.png