Portfolio - Sistemas Digitais e Microprocessadores

Prévia do material em texto

SISTEMA DE ENSINO 100% OLINE 
ENGENHARIA ELÉTRICA 
NOME DO ALUNO 
 
 
SISTEMAS DIGITAIS E MICROPROCESSADORES 
AULA PRÁTICA 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
NOME DO ALUNO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SISTEMAS DIGITAIS E MICROPROCESSADORES 
AULA PRÁTICA 
 
 
Atividade Prática Individual da disciplina de Sistemas 
Digitais e Microprocessadores realizada no Curso de 
Engenharia Elétrica, valendo como requisito parcial para 
a obtenção de nota para compor a média semestral. 
 
Tutor à Distância: nome do tutor 
 
CIDADE 
2025 
 
 
SUMÁRIO 
 
 
1 INTRODUÇÃO................................................................................................. 4 
2 DESENVOLVIMENTO...................................................................................... 6 
2.1 ATIVIDADE PRÁTICA 1 ............................................................................... 6 
2.2 ATIVIDADE PRÁTICA 2 ............................................................................. 13 
2.3 ATIVIDADE PRÁTICA 3 ............................................................................. 17 
2.4 ATIVIDADE PRÁTICA 4 ............................................................................. 25 
2.5 ATIVIDADE PRÁTICA 5 ............................................................................. 31 
3 CONCLUSÃO ................................................................................................ 41 
4 REFERÊNCIAS BIBLIOGRÁFICAS................................................................. 42 
 
 
4 
 
1 INTRODUÇÃO 
A realização de uma atividade prática dentro do contexto de uma disciplina 
acadêmica tem como objetivo principal sedimentar o conhecimento que foi aprendido 
durante as aulas. É uma maneira do aluno colocar em prática o que foi visto na teoria, 
vivenciando os conceitos, fundamentos e demais aspectos pertinentes à aplicação da 
disciplina em sua área de atuação. 
Durante o estudo desta disciplina de Sistemas Digitais e Microprocessadores, 
foi possível verificar muito conteúdo interessante, que no desenvolvimento dessas 
atividades, experimentamos uma abordagem prática e mão na massa, o que ajudou 
a consolidar vários conceitos teóricos aprendidos em sala de aula. Este portfólio não 
só mostra o desenvolvimento das habilidades técnicas, mas também o caminho de 
como resolver problemas complexos dentro do universo dos sistemas digitais e 
microprocessadores. As atividades desenvolvidas englobam desde a implementação 
de circuitos básicos até a programação avançada de microcontroladores Arduino. 
Na Aula Prática 1, foi projetado e implementado um circuito com a finalidade 
de registrar a produção de uma fábrica utilizando 8 teclas, cada uma representando 
uma quantidade específica de itens produzidos. Por meio do simulador Logisim, foi 
explorado conceitos como entradas e saídas, codificadores de prioridade e 
decodificadores, com o intuito de simular o funcionamento do circuito digital e verificar 
sua utilização na realização desta atividade e de atividades correlatas. 
A Aula Prática 2 ampliou o escopo ao focar no design, simulação e construção 
de circuitos lógicos mais sofisticados. Nesse contexto, empregou-se a ferramenta 
Logisim para desenvolver um contador binário de 4 bits e um contador BCD de 
década, fortalecendo as competências na manipulação de circuitos digitais. 
Já a Aula Prática 3 proporcionou a imersão no universo dos 
microcontroladores, com ênfase no Arduino. Durante esta etapa, foi possível 
compreender o funcionamento básico do microcontrolador e foram programados 
algoritmos simples, dando início à exploração de sistemas de controle. 
Na Aula Prática 4, o aprendizado foi aprofundado ao abordar a programação 
de algoritmos voltados para a criação de um relógio em tempo real e de uma estação 
meteorológica equipada com sensores de temperatura e umidade, consolidando ainda 
mais os conhecimentos adquiridos. 
5 
 
Por fim, a Aula Prática 5 investigou aplicações específicas de 
microcontroladores Arduino, como a implementação de um sensor ultrassônico 
combinado com LED RGB e um sensor ultrassônico com timer. 
As atividades descritas neste portfólio nos trazem uma abordagem prática e 
interativa que conecta teoria e prática, demonstrando não apenas o avanço das 
habilidades técnicas, mas também a capacidade de solucionar desafios complexos no 
campo dos sistemas digitais e microprocessadores. 
 
 
 
6 
 
2 DESENVOLVIMENTO 
2.1 ATIVIDADE PRÁTICA 1 
A atividade prática 1 traz a proposta de implementação de um circuito que 
registre a produção de uma fábrica através de 8 teclas, sendo pressionada a 
quantidade produzida (de 1 a 8) a cada produção, demonstrando na saída o número 
de itens produzidos na sequência decimal. 
Para a realização desta atividade, foi utilizado o software simulador Logisim. A 
seguir, os passos seguidos durante a atividade: 
Inicialmente, abriu-se o software simulador Logisim, que foi a plataforma 
escolhida para a simulação dos circuitos digitais a serem construídos na atividade e 
foi feita uma verificação de seu ambiente de trabalho para conhecimento das 
ferramentas e familiarização com os botões. 
Em seguida, para representar as 8 teclas correspondentes à produção, foram 
inseridas teclas alinhadas e rotuladas adequadamente para indicar qual número cada 
tecla representava, conforme Figura 1. 
Figura 1. Inserção de Teclas e Rótulos 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
7 
 
Na continuação foi adicionado um Codificador de Prioridade ao circuito, um 
componente que, ao receber várias entradas, exibe na saída o valor da entrada mais 
alta e feita a conexão das teclas ao codificador, conforme Figura 2. 
Figura 2. Inserção do Codificador de Prioridade e conexão das teclas a ele 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
Uma entrada de Enable foi incorporada ao codificador de prioridade para 
habilitar seu funcionamento, conforme Figura 3. 
Figura 3. Inserção da entrada Enable 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
8 
 
Para exibir o valor binário correspondente à entrada habilitada de 0 a 7, foi 
inserida uma saída, conforme Figura 4. 
Figura 4. Inserção da Saída 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
 
Em seguida, foi realizada a simulação do codificador de prioridade 
preenchendo uma tabela com entradas e saídas. Na simulação, observou-se que a 
saída representava o valor binário mais alto da entrada habilitada. Vide Tabela 1. 
Tabela 1. Resultados da simulação do codificador de prioridade 
Enable Tecla Acionada Saída 
0 Tecla de 1 a 8 acionada xxx 
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 
1 8 111 
Fonte: O autor 
 
 
 
 
9 
 
Após a simulação do codificador de prioridade, foi inserido um decodificador no 
circuito. Foi configurado o número de bits corretamente na entrada e em seguida feita 
as conexões necessárias, conforme Figura 5. 
Figura 5. Inserção do decodificador 
 
Fonte: O autor 
 
Em seguida, foram incorporadas as saídas do decodificador ao circuito, 
conforme Figura 6. 
Figura 6. Saídas incorporadas ao decodificador 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
 
 
 
10 
 
Após o circuito pronto, testes foram realizados para verificar todas as 
possibilidades do circuito, registrando quais saídas eram acionadas em diferentes 
combinações de teclas, conforme Tabela abaixo: 
Tabela 2. Simulação do decodificador. 
Enable Tecla Acionada Saída do Decodificador 
0 Tecla de 1 a 8 acionada xxxxxxxx 
1 Nenhuma tecla acionada xxxxxxxx 
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 
 
 
Assim, após os testes, verificamos que o codificador de prioridade tem a função 
de identificar a tecla de maior prioridade que está sendo acionada (ligada) e gerar uma 
saída bináriacorrespondente. O decodificador, por sua vez, recebe essa saída binária 
e a converte de volta para a representação decimal, indicando qual tecla foi acionada. 
A lógica de funcionamento pode ser resumida basicamente desta forma. 
 
Alguns exemplos do comportamento do circuito: 
Combinação 1: 
Tecla Acionada = 3 
Enable = 1 (Habilitado) 
Saída do Codificador = 010 (correspondente a 2 em binário, pois a sequência 
no decodificador inicia-se no 0 e finaliza do 7, correspondendo as teclas de 1 a 8) 
Saída do Decodificador = 3 
Resultado: Quando a tecla 3 for acionada e o codificador de prioridade detectar 
que ela é a de maior prioridade, converte em binário e envia para o decodificador que 
recebe o sinal em binário e converte para decimal, acionando assim a saída 3. Vide 
Figura 7. 
11 
 
Figura 7. Resultado da combinação 1 
 
 
 
 
 
 
 
Fonte: O autor 
 
Combinação 2: 
Tecla Acionada = 1 
Enable = 1 (Habilitado) 
Saída do Codificador = 000 (correspondente a 0 em binário) 
Saída do Decodificador = 1 (decimal) 
Resultado: Quando a tecla 1 for acionada e ela for a de maior prioridade, a 
saída 1 do decodificador será a correta. Vide Figura 8. 
Figura 8. Resultado da combinação 2 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
 
12 
 
Combinação 3: 
Tecla Acionada = 7 
Enable = 1 (Habilitado) 
Saída do Codificador = 110 (correspondente a 6 em binário) 
Saída do Decodificador = 7 
Resultado: Quando a tecla 7 for acionada e ela for a de maior prioridade, a 
saída 7 do decodificador será a correta. Vide Figura 9. 
Figura 9. Resultado da combinação 3 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
13 
 
2.2 ATIVIDADE PRÁTICA 2 
A segunda atividade prática trouxe a proposta de projetar e simular circuitos 
lógicos mais complexos, com destaque para a implementação de um meio somador 
binário, um contador assíncrono de 4 bits e um Contador de Década BCD. 
Para a realização desta atividade, foi utilizado novamente o software Logisim. 
A seguir, os passos realizados durante a atividade: 
Inicialmente, foi construído um circuito com a porta NAND e verificar sua 
equivalência com a porta OR Negativa. Para tanto, foi necessário adicionar as portas 
lógicas NAND e OR, bem como duas portas inversoras. Foram inseridas também as 
entradas A e B, as portas foram devidamente posicionadas e as foram realizadas as 
conexões, conforme Figura 10. Em seguida, vários testes foram efetuados alternando-
se os valores das entradas A e B e verificada com se comportara a saída. 
Figura 10. Circuito com portas inseridas e conexões efetuadas 
 
Fonte: O autor 
 
Importante ressaltar que uma maneira de verificar a equivalência entre dois 
circuitos lógicos é verificar se suas tabelas verdades são iguais. Vide Tabelas 3 e 4. 
Tabela 3. Tabela verdade da porta NAND 
A B S 
0 0 1 
0 1 1 
1 0 1 
1 1 0 
Fonte: O autor 
14 
 
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 
 
 Assim, foi possível verificar que os dois circuitos acima são equivalentes. 
 
2.2.1 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, conforme Figura 11. Na simulação no Logisim, 
as entradas foram alternadas e as saídas foram analisadas para garantir a precisão 
do circuito, conforme Tabela 5. 
Figura 11. Meio somador 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
Tabela 5. Tabela verdade para o meio somador 
Entradas Saídas 
A B S C 
0 0 0 0 
0 1 1 0 
1 0 1 0 
1 1 0 1 
Fonte: O autor 
 
 
15 
 
2.2.2 Projeto Contador Assíncrono de 4 bits 
Os contadores são circuitos lógicos projetados encadeando flip-flops, eles 
podem ser classificados como assíncronos ou síncronos, de acordo com a forma que 
recebem os pulsos do clock. 
Nos contadores assíncronos, 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. Nos 
contadores síncronos, o mesmo sinal de clock é fornecido para todos os flip-flops de 
forma que eles recebem o clock simultaneamente. 
Com base no conhecimento adquirido sobre contadores assíncronos, foi 
projetado um contador de 4 bits. Os flip-flops foram encadeados, e as conexões foram 
estabelecidas conforme as características desse tipo de contador. Vide Figura 12. 
Figura 12. Contador assíncrono de 4 bits 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
2.2.3 Projeto Contador de Década BCD 
 
O contador de década também funciona de modo assíncrono. Esse tipo de 
circuito efetua a contagem em números binários de 0 a 9, ou seja, de 0000 a 1001. 
Assim, para um contador contar somente até 9, quando chegar no 1010, que é o 
número 10 em decimal, joga-se um nível 0 na entrada CLEAR do flip-flop. Desse 
modo, para realizar esse procedimento, liga-se as saídas Q3 e Q1 em uma porta 
NAND de duas entradas, conforme mostrada na Figura 13. 
16 
 
Figura 13. Contador de década 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Fonte: O autor 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
17 
 
2.3 ATIVIDADE PRÁTICA 3 
 Esta atividade se divide em 2 atividades propostas. 
 
2.3.1 Atividade Proposta 1 
Na primeira atividade proposta da Atividade 3, foram desenvolvidos 4 
programas para Arduino Uno, utilizando a plataforma Arduino IDE, com o objetivo de 
realizar operações específicas. A seguir, breves descrições sobre o escopo, os 
códigos desenvolvidos e como se deu a estruturação e validação: 
Programa 1: Programa para Arduino Uno semelhante a um eco 
• Escopo do Programa: 
Foi criado um programa que implementa a funcionalidade de eco, ou seja, 
repete qualquer caractere recebido pela porta serial. O código incluiu a leitura de 
caracteres da porta serial e a retransmissão desses caracteres de volta para a porta. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 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 
 } 
} 
 
18 
 
• Validação: 
O programa foi enviado para o Arduino Uno através da Arduino IDE. Após o 
upload do programa, o Arduino foi conectado ao computador, e a comunicação serial 
foi estabelecida. Testes foram realizados enviando caracteres pela porta serial, e o 
Arduino respondeu repetindo os caracteres recebidos. Programa testado com 
sucesso! 
 
Programa 2: Programa de Piscar LEDs em Sequência para Arduino Uno 
• Escopo 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. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 
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; ilimitar a corrente. O programa foi enviado para o Arduino, e 
os LEDs foram observados piscando de forma sequencial conforme a lógica 
implementada. Assim, o teste foi realizado com sucesso! 
 
Programa 3: Controle de luminosidade de um LED com potenciômetro 
• Escopo do Programa: 
Foi desenvolvido um programa que controla a luminosidade de um LED 
conectado ao pino 10 do Arduino por meio de um potenciômetro. O código incluiu a 
leitura da posição do potenciômetro no pino A0 e o ajuste da luminosidade do LED 
proporcionalmente à posição do potenciômetro. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
const int pinoPotenciometro = A0; // Pino analógico onde o potenciômetro 
está conectado 
const int pinoLED = 10; // Pino digital onde o LED está conectado 
 
void setup() { 
 pinMode(pinoLED, OUTPUT); // Configura o pino do LED como saída 
} 
 
void loop() { 
 int valorPotenciometro = analogRead(pinoPotenciometro); // Lê o valor do 
potenciômetro (0 a 1023) 
 int luminosidade = map(valorPotenciometro, 0, 1023, 0, 255); // Mapeia o 
valor para a faixa de brilho do LED 
 
 analogWrite(pinoLED, luminosidade); // Define a luminosidade do LED 
} 
 
20 
 
• Validação: 
Um LED foi conectado ao pino 10 do Arduino, e um potenciômetro foi conectado 
ao pino A0, com suas extremidades ligadas em 5V e GND. Um resistor de 220 Ω foi 
utilizado em série com o LED. Em seguida, o programa foi enviado para o Arduino, e 
o teste foi realizado ajustando o potenciômetro para observar as variações na 
luminosidade do LED. Teste realizado com sucesso! 
 
Parte 4: Controle de luminosidade de um LED por comunicação serial 
• Escopo do Programa: 
Foi desenvolvido um programa que controla a luminosidade de um LED no pino 
10 do Arduino por meio da comunicação serial. O programa espera receber comandos 
em ASCII, representando valores de brilho entre 000 e 255. A luminosidade do LED é 
ajustada de acordo com os valores recebidos. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
const int pinoLED = 10; // Pino digital onde o LED está conectado 
char comandoSerial[4]; // Array para armazenar o comando recebido via serial 
 
void setup() { 
 Serial.begin(9600); // Inicializa a comunicação serial 
 pinMode(pinoLED, OUTPUT); // Configura o pino do LED como saída 
} 
 
void loop() { 
 if (Serial.available() >= 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 
 } 
} 
 
21 
 
• Validação: 
Um LED foi conectado ao pino 10 do Arduino, e a comunicação serial foi 
estabelecida. O programa foi enviado para o Arduino e testes foram realizados 
enviando comandos válidos (três caracteres entre 000 e 255) pela porta serial para 
ajustar a luminosidade do LED. O resistor de 220 Ω foi utilizado em série com o LED 
para limitar a corrente. Assim, teste realizado com sucesso! 
 
2.3.2 Atividade Proposta 2 
Na segunda atividade proposta da Atividade 3, foi realizado o desenvolvimento 
de um projeto no Tinkercad para criar um monitor de umidade do solo com o Arduino. 
Essa atividade foi bastante conveniente para a aplicação dos conhecimentos 
adquiridos na utilização do Arduíno e suas saídas digitais e analógicas, o que abre um 
mundo de possibilidades. 
A seguir, breves descrições sobre o escopo, os códigos desenvolvidos e como 
se deu a estruturação e validação: 
 
Projeto completo de 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 (1 Vermelho, 1 Amarelo, 1 Laranja, 1 Azul e 1 Verde); 
- 5 resistores de 220 Ohms; e, 
- Módulo sensor de umidade do solo. 
 
 
 
22 
 
• Conexões a serem realizadas: 
As seguintes conexões foram feitas no Tinkercad: 
- Foi conectada as saídas 9, 10, 11, 12 e 13 do Arduino aos ânodos dos LEDs; 
- Foi criada a conexão do cátodo dos LEDs para os resistores de 220 Ohms; 
- Foi conectado o outro terminal dos resistores ao GND (negativo) do Arduino; 
- Foram criadas as conexões de forma organizada e limpa; 
- Foi conectado o pino VCC do sensor de umidade do solo à porta A0; 
- Foi conectado o pino GND do sensor de umidade do solo ao GND do Arduino; 
e por fim, 
- Foi conectado 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 valor 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, 
com a finalidade de acender cada LED à medida que o valor da variável umidade for 
alterado; e, 
- Variáveis pin_vcc com a porta A0 e pin_sensor com a porta A1, para controle 
do sensor de umidade. 
Para configuração do Setup, no bloco void setup(), foram realizadas as 
seguintes definições: 
- Definição das variáveis led_x como saída; 
- Definição da variável pin_vcc como saída; 
- Definição da variável pin_sensor como entrada; e, 
- Inicialização da comunicação serial com Serial.begin(9600). 
 
23 
 
• 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: se menor 
que 200 acenderá o LED vermelho; se menor que 400 acenderá o LED amarelo; se 
menor que 600 acenderá o LED laranja; se menor que 800 acenderá o LED azul; e se 
for diferente destes valores, acenderá o LED verde. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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); 
} 
 
24 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
• Execução e Validação: 
Após seguir todas as etapas, a simulação foi executada para verificar a 
operação do projeto. O circuito foi projetado para acender os LEDs na sequência 
vermelho, amarelo, laranja, azul e verde, dependendo dos valores controlados pela 
barra de simulação do sensor de umidade. O circuito foi configurado como um loop 
infinito, mantendo a luz acesa conforme os valores recebidos na variável "umidade". 
Dessa forma, o teste foi realizado com sucesso! 
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); 
 } 
 
 
26 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 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 
} 
 
 
27 
 
Programa 2: Programa para Simulação de Estação Meteorológica com 
Armazenamento na EEPROM 
Desenvolveu-se um programa que simula uma estação meteorológica, 
realizando medidas de umidade e temperatura a cada 1 minuto. Utilizou-se o módulo 
DS1302 para obter a data e 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. 
Segue o código abaixo desenvolvido para implementação da solução 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#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); 
 } 
 
 
28 
 
 
 
 
 
 
 
 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(" %"); 
 
 
 
29 
 
 // 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 (addresspara 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) 
 
 
 
 
32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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); 
 
 
33 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 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); 
} 
 
34 
 
Programa 2: Programa para Leitura de Distância e Piscar de LED 
Proporcional à Distância 
Criou-se um programa que realiza a leitura da distância medida pelo sensor 
ultrassônico e a envia via porta serial a cada 1 segundo. A leitura da distância foi feita 
em centímetros. O LED conectado ao pino 13 do Arduino foi programado para piscar 
com uma velocidade proporcional à distância medida. Utilizou-se uma interrupção do 
timer para gerenciar as duas bases de tempo no programa: uma para amostragem e 
envio da distância via serial e outra para o LED. 
Definiu-se que, quando a distância medida for de 50 cm ou mais, o LED deverá 
mudar seu estado a cada 1 segundo. Com a redução da distância, esse período deve 
mudar proporcionalmente. O programa foi enviado para o Arduino e testado para 
verificar a correta leitura da distância e o piscar do LED de acordo com a distância 
medida. 
Segue o código abaixo desenvolvido para implementação da solução: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 
 
 
 
35 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 TCCR1A = 0; 
 TCCR1B = 0; 
 TCNT1 = 0; 
 OCR1A = 15624; // Valor para 1 segundo com prescaler de 256 
 TCCR1B |= (1de 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); 
 
39 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 // 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); 
 
 
40 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
• Simulação no Tinkercad: 
Após a construção do código, foi realizada a simulação no Tinkercad, ajustando 
a distância medida pelo sensor ultrassônico clicando sobre ele. 
Foi colocado um resistor de 220 Ohms em série com cada cor do LED para 
limitar a corrente que passava por ele. 
Foram feitas algumas pesquisas sobre como fazer o sensor de distância 
ultrassônico funcionar corretamente no Tinkercad, ajustando as configurações 
necessárias para garantir a simulação adequada. 
Assim, o resultado final foi um circuito simulado que indicava visualmente a 
distância medida pelo sensor ultrassônico por meio das cores do LED RGB, seguindo 
as especificações estabelecidas no programa Arduino. Esse experimento 
proporcionou a prática da integração de sensores e atuadores, bem como a simulação 
de circuitos complexos no ambiente virtual do Tinkercad. 
 
 } else { 
 analogWrite(redPin, 255); 
 analogWrite(greenPin, 0); 
 analogWrite(bluePin, 0); 
 } 
} 
 
 
 
41 
 
3 CONCLUSÃO 
Este portfólio apresenta uma sequência de atividades planejadas e 
estruturadas, composta por práticas que possibilitaram a integração com a teoria da 
disciplina de Sistemas Digitais e Microprocessadores. Essa abordagem prática e 
fundamentada, foi de grande valor para que se possa consolidar as habilidades 
técnicas e ampliar a compreensão dos conceitos essenciais que fazem parte dessa 
área, assim como também proporcionou o conhecimento e o uso de ferramentas de 
simulação, como o simulador Logisim e a plataforma Arduino, onde realizamos desde 
projetos mais simplórios, até o desenvolvimento de firmware para microcontroladores. 
Na Atividade 1, foram apresentados os princípios de funcionamento do 
codificador de prioridade utilizando o simulador Logisim, possibilitando uma 
compreensão aprofundada de suas entradas e saídas e de sua relevância em 
aplicações práticas. 
A Atividade 2 avançou no domínio do Logisim, promovendo a construção e 
simulação de circuitos lógicos, bem como a construção de contadores assíncronos, 
fortalecendo as habilidades de projeto e análise de circuitos digitais. 
As Atividades 3, 4 e 5 focaram na programação e no desenvolvimento de 
sistemas de controle variados utilizando a plataforma Arduino. Projetos como o relógio 
em tempo real, a estação meteorológica e o monitor de umidade do solo 
demonstraram o potencial criativo e técnico inerente ao uso de microcontroladores. 
Essas atividades consolidaram conhecimentos teóricos e práticos, evidenciando as 
capacidades de programação e integração de funcionalidades em sistemas 
embarcados. 
Em resumo, este portfólio evidencia um percurso progressivo e bem 
estruturado no campo dos Sistemas Digitais e Microprocessadores. Cada atividade 
contribuiu significativamente para o fortalecimento de uma base sólida de 
conhecimentos teóricos e práticos, essencial para enfrentar os desafios do universo 
da eletrônica digital e dos sistemas embarcados. A experiência adquirida ao longo 
dessas atividades nos proporcionou um avanço técnico e profissional, que certamente 
se traduzirá na capacidade de planejar e implementar soluções inovadoras em 
contextos futuros. 
 
42 
 
4 REFERÊNCIAS BIBLIOGRÁFICAS 
 
ERCEGOVAC, M.; LANG, T.; MORENO, J. H. Introdução aos Sistemas Digitais. 
Bookman, SP, 2000. 
HEXSEL, Roberto A. Sistemas Digitais e Microprocessadores. Universidade Federal 
do Paraná: Departamento de Informática. 2006. [S.I.]. Disponível em: 
. Acesso em 
17/04/2025. 
NERI, Hermes Gustavo Fernandes. Utilização da Plataforma Arduino para Controle 
de Experimentos Remotos de Física. Universidade Federal de Uberlândia: Instituito 
de Física. 2014. [S.I.]. Disponível em: 
. Acesso em 18/04/2025. 
PERIM, Victor; LOPES, Giancarlo M.G; MARTIN, Andrea A. Sistemas Digitais e 
Microprocessadores. Londrina: Editora e Distribuidora Educacional S.A, 2020. 
SILVER, Luan. Guia da Robótica: Sensor ultrassônico Arduino para acender LED – 
Saiba como fazer. 2020. [S.I.]. Disponível em: 
. Acesso em: 19/04/2025. 
SOUZA, Fábio. Domine a linguagem C: Tudo o que você precisa sabem em um 
único lugar. Portal Embarcados: 2023. [S.I.]. Disponível em: 
. Acesso em 18/04/2025. 
TOCCI, R. J.; WIDMER, N. S. Sistemas Digitais – Princípios e Aplicações. 7.ed. RJ: 
LTD, 2000. 
 
VIANA, Carol Correia. Blog da Robótica: Como medir distância com o sensor 
ultrassônico HC-SR04 e Arduino. 2022. [S.I.]. Disponível em: 
. Acesso em 20/04/2025. 
https://www.blogdarobotica.com/2022/06/30/como-medir-distancia-com-o-sensor-ultrassonico-hc-sr04-e-arduino/
https://www.blogdarobotica.com/2022/06/30/como-medir-distancia-com-o-sensor-ultrassonico-hc-sr04-e-arduino/
https://embarcados.com.br/linguagem-c-guia-completo/
https://www.blogdarobotica.com/2022/06/30/como-medir-distancia-com-o-sensor-ultrassonico-hc-sr04-e-arduino/
https://www.blogdarobotica.com/2022/06/30/como-medir-distancia-com-o-sensor-ultrassonico-hc-sr04-e-arduino/