UNIVERSIDADE TECNOLÓGICA FEDERAL DO

PARANÁ CAMPUS CURITIBA/CENTRO

PROJETO FINAL - SISTEMA AUXILIAR DE RÉ

CURITIBA
2021
UNIVERSIDADE TECNOLÓGICA FEDERAL DO
PARANÁ CAMPUS CURITIBA/CENTRO

PROJETO FINAL - SISTEMA AUXILIAR DE RÉ

Relatório referente à disciplina de

Sistemas Microcontrolados A, prof.
Ronnier Rohrich, 2º semestre 2021,
UTFPR - campus Curitiba/sede Centro,
realizado pelos alunos Ana Beloti,
Gustavo Spaki e Rene Lopes.

CURITIBA
2021

2
SUMÁRIO

INTRODUÇÃO 4

MATERIAIS 4

DESENVOLVIMENTO 7
Fluxograma 7
Desenvolvimento do código 10
Comunicação 10
Sensores 10
Teclado 10
Display LCD 11
Montagem do circuito e simulação 11

RESULTADOS E DISCUSSÕES 11

CONCLUSÕES 12

REFERÊNCIAS 13

ANEXOS 14
Anexo A - Código Arduino 1 15
Anexo B - Código Arduino 2 17
Anexo C - Fluxograma 23
Anexo D - Simulação 24

3
1.INTRODUÇÃO

Entregue como Projeto final na disciplina de Sistemas Microcontrolados A,

neste trabalho será desenvolvido um sistema microcontrolado envolvendo conceitos
apresentados durante as aulas ministradas na disciplina, colocando em prática o
conhecimento adquirido, como por exemplo a comunicação serial de um
microcontrolador, sensores e representações gráficas por meio de display.

Como o projeto final também busca trabalhar a interdisciplinaridade com outras

áreas da engenharia mecatrônica, que é de fundamental importância no
aprendizado, o tema escolhido abrange a área automobilística, mais
especificamente no desenvolvimento de um sistema microcontrolado para
sensoriamento de distância durante a marcha ré de um veículo.

2.MATERIAIS

No sistema desenvolvido, foram utilizadas duas placas Arduino UNO, com o

intuito de abordar os conhecimentos referente a comunicação serial dos
microcontroladores envolvidos, cada uma com funções distintas, mas trabalhando
em conjunto para o resultado final do sistema.

A primeira placa Arduino será responsável por identificar quando o veículo

está com a marcha ré engrenada e ativar o sistema projetado, ela também deve
realizar a leitura do sensor Ultrassônico e do sensor de luminosidade.

Na segunda placa, estão presentes um teclado matricial 4x4, um display LCD

de 16x2 e os Leds e Buzzer. Por meio do teclado o usuário pode selecionar os
intervalos de distância pré definidos para acionamento dos sinais sonoros e
luminosos (Buzzer e Leds) enquanto as informações como distância atual e demais
configurações serão exibidas no display LCD. Os Leds e o buzzer formam um
conjunto de segurança redundante de aviso, ao total foram utilizados 3 Leds (Verde,
Vermelho e Amarelo) representando os intervalos de distância que o sensor
ultrassônico detectar.

A seguir serão apresentadas imagens dos componentes utilizados.

4
 Placa Arduino UNO

Sensor Ultrassônico e luminosidade

5
 Leds e Buzzer

Teclado 4x4

Display LCD 16x2

6
 3.DESENVOLVIMENTO

Para o bom entendimento de qualquer sistema que está sendo projetado, é

muito importante representarmos graficamente as etapas do processo para evitar
problemas ou dúvidas futuras durante a implementação. Por esse motivo foi
desenvolvido um fluxograma que representa todos os passos e tomadas de
decisões que podem ser realizadas no sistema projetado.

3.1.Fluxograma

7
 Para melhor entendimento do fluxograma, vale lembrar que cada bloco tem
um formato correspondente ao tipo de ação que ele representa, e as setas indicam
a direção das ações, por exemplo:

Blocos de início ou fim do sistema:

Esses blocos têm como objetivo representar os limites de ativação e

desativação do sistema, nesse caso em específico, o início do sistema é
representado pelo ato de ligar o veículo, enquanto o fim seria como desligar.

Blocos para tomada de decisão:

Bloco que representa a tomada de decisão no sistema com base em uma

variável ou acontecimento. Nesse caso verifica se a ré está ligada (RÉ == ON) e
define a próxima ação do sistema com base na resposta.

Blocos de ação:

8
 Esse bloco é responsável por representar as ações realizadas pelo sistema,
por exemplo o acionamento de um LED ou a escolha de alguma função.

Blocos de Impressão no Display:

Bloco que representa todo e qualquer dado que será apresentado para o
usuário de forma visual por meio do Display LCD. Nesse exemplo mostrando a
opção de distância que o usuário escolheu utilizar.

Dessa forma podemos traduzir o funcionamento do sistema de maneira bem

simplificada.

Quando o veículo está desligado, o sistema permanece inativo. Porém a partir

do momento em que o carro é ligado o sistema começa a rodar iniciando a Tela
Inicial e mostrando as configurações atuais do sistema no display LCD e realizando
a primeira tomada de decisões. Caso a ré não esteja engrenada, o usuário pode
realizar alterações na configuração do sistema livremente, com o ciclo de verificação
e exibição no display se repetindo continuamente.

A partir do momento que a marcha ré é engrenada, o usuário não pode

realizar alterações nas configurações até desengrenar a marcha. Agora o sistema
passa a realizar a leitura dos sensores e aplicar as alterações nos LEDs e Buzzer,
conforme a configuração pré definida pelo usuário, a distância e luminosidade lidas
pelos sensores. Sempre que o sistema finaliza um ciclo de leitura dos sensores e
alteração nos leds e buzzer, uma nova verificação é realizada para identificar se a
marcha ré permanece engrenada, repetindo assim toda a varredura do sistema, até
que o carro seja desligado.

9
3.2.Desenvolvimento do código

Como vamos utilizar a placa arduino, podemos trabalhar com uma linguagem
de programação de alto nível, já que a IDE Arduino utiliza a linguagem C++ com
pequenas alterações.

Podemos dividir o código em estruturas que trabalham separadamente com

objetivos distintos, mas que colaboram para o resultado final buscado no sistema.
Essas estruturas podem ser definidas como as seguintes:

3.2.1.Comunicação

Essa parte do código é responsável por fazer a comunicação serial entre as

duas placas Arduino. O protocolo serial assíncrono UART utiliza dois fios (RX -
Receptor e TX - Transmissor) para realizar uma comunicação full duplex
ponto-a-ponto permitindo que ambos os Arduinos possam enviar e receber dados ao
mesmo tempo. Para que a comunicação ocorra corretamente o baud rate (taxa de
transmissão) de ambos os dispositivos deve ser o mesmo.

Neste projeto, a comunicação foi unilateral, ou seja, o primeiro

microcontrolador capta os sinais dos sensores e envia para o segundo arduino fazer
o tratamento dos dados coletados.

3.2.2.Sensores

Código responsável por realizar a leitura dos dados fornecidos pelos sensores
de luminosidade e distância, converte para as unidades desejadas e salva nas
variáveis que armazenam essas informações.

3.2.3.Teclado

Por meio do teclado o usuário escolhe qual faixa de distâncias será utilizada
para acionamento de cada estágio, dessa forma o código deve ser responsável por
ler o valor inserido pelo usuário e armazenar em uma variável.

10
 3.2.4.Display LCD

Responsável por exibir os dados de forma visual para o usuário, posicionando

corretamente e mudando as informações em cada etapa do processo.

3.3.Montagem do circuito e simulação

Para o desenvolvimento do projeto utilizamos uma plataforma online de

simulação para circuitos chamada TinkerCAD, nela podemos criar e simular os mais
diferentes circuitos, utilizando uma vasta gama de componentes disponíveis,
incluindo Arduino.

Após realizar a montagem do sistema chegamos ao esquemático

representado a seguir:

4.RESULTADOS E DISCUSSÕES

No decorrer do desenvolvimento deste projeto, algumas dificuldades foram

notadas, como por exemplo a configuração da comunicação entre os dois
microcontroladores, também a dificuldade em lidar com a plataforma TinkerCAD, por

11
 este ser o primeiro contato, não ter tantos trabalhos desenvolvidos nela e também
por ser um ambiente totalmente virtual, no qual, não raro, à bugs que
desconhecemos e portanto, não temos controle sobre.

No entanto, existem pontos positivos no uso da plataforma tinkercad, por

exemplo, questões como mal contato de fios e componentes, não precisar comprar
os componentes físicos para a realização do projeto, desse modo o custo foi quase
de zero (se levarmos em consideração o valor pago pela internet, caso contrário, o
projeto foi de graça).

De modo geral, essas dificuldades foram ultrapassadas e o resultado final foi

satisfatório, apesar de somente poder simular em ambiente virtual este sistema, não
colocá-lo à prova real, foi verificado que, ao diminuir o valor de entrada do sensor
ultrassônico, o sinal sonoro (buzzer) e visual (LED) responderam de acordo com o
estabelecido previamente. Isto implica, diretamente, que o código de comunicação
entre os microcontroladores foi executado com sucesso.

5.CONCLUSÕES

O sistema auxiliar de ré projetado teve um desempenho satisfatório dentro do

ambiente virtual, como dito anteriormente, não foi possível testar o sistema físico,
contudo espera-se que o resultado seja igualmente satisfatório.

Sobre a plataforma utilizada, conclui-se que é uma saída prática como um

recurso devido às atuais circunstâncias, porém, toda simulação tem um limite e não
consegue reproduzir todas as circunstâncias reais, portanto, se houver a
possibilidade, o ideal seria materializar o projeto simulado.

Em relação ao emprego das habilidades adquiridas no decorrer do curso,

principal objetivo da proposta deste projeto, é possível concluir que este objetivo foi
sim alcançado.

12
6.REFERÊNCIAS

Sensor de luz ambiente. Disponível

em:<https://www.filipeflop.com/universidade/kit-maker-arduino/projeto-10-sensor-de-l
uz-ambiente/>Acesso em 16 de maio de 2021.

Tinkercad. Disponível em:<> Acesso em: 17 de maio de 2021

13
ANEXOS

14
 Anexo A - Código Arduino 1
#define Pin_Ultra 7
#define buttonRe 12

long readUltrasonicDistance(int triggerPin, int echoPin);

bool re;
int cm;

void setup()
{
Serial.begin(9600);
pinMode(buttonRe, INPUT);

cm = 0;
Serial.println(cm);
}

void loop()
{

bool reNovo = digitalRead(buttonRe);

if (re!= reNovo)
{
re = reNovo;
}

lerUltrassom();

delay(50); // Wait for 50 millisecond(s)

}

//--------------------------------------

int lerUltrassom()
{
int cmNovo = (re*0.01723 * readUltrasonicDistance(Pin_Ultra, Pin_Ultra));

if (cmNovo < cm-1 || cmNovo > cm+1)

{
cm = cmNovo;
Serial.println(cm);
}
}

long readUltrasonicDistance(int triggerPin, int echoPin)

{
pinMode(triggerPin, OUTPUT); // Clear the trigger
digitalWrite(triggerPin, LOW);
delayMicroseconds(2);

15
 // Sets the trigger pin to HIGH state for 10 microseconds
digitalWrite(triggerPin, HIGH);
delayMicroseconds(10);
digitalWrite(triggerPin, LOW);
pinMode(echoPin, INPUT);
// Reads the echo pin, and returns the sound wave travel time in microseconds
return pulseIn(echoPin, HIGH);
}

16
 Anexo B - Código Arduino 2
#include <LiquidCrystal.h>
#include <Keypad.h>

//----------------PINOS----------------

#define LedVermelho 11 //Pino led Vermelho

#define LedAmarelo 12 //Pino led Amarelo
#define LedVerde 13 //Pino led Verde
#define Buzzer 10 //Pino do Buzzer

//----------------GLOBAIS----------------

String palavra = ""; // a String to hold incoming data

int max = 300;
int cm;

//----------------LCD----------------

LiquidCrystal lcd(6, 7, 5, 4, 3, 2);

//----------------TECLADO----------------

const byte ROWS = 4; //4 linhas

const byte COLS = 4; //4 colunas

char keys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = {A5, A4, 8, 9}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {A3, A2, A1, A0}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

//----------------SETUP----------------
void setup()
{
lcd.begin(16, 2);
Serial.begin(9600);

TelaInicial();

pinMode(LedVermelho, OUTPUT);

17
 pinMode(LedAmarelo, OUTPUT);
pinMode(LedVerde, OUTPUT);
pinMode(Buzzer, OUTPUT);

digitalWrite(LedVermelho, LOW);
digitalWrite(LedAmarelo, LOW);
digitalWrite(LedVerde, LOW);
digitalWrite(Buzzer, HIGH);
delay(200);
digitalWrite(Buzzer, LOW);

//cm = 1;
}

//-------- -------- -------- --------

//---------------- MAIN ----------------
//-------- -------- -------- --------
void loop()
{
delay(50);

while (Serial.available())
{
palavra = Serial.readStringUntil('\n');

Serial.print("Leitura: ");
Serial.println(palavra);

cm = palavra.toInt();
}

//palavra[palavra.length()-1]= NULL;
//Serial.println(palavra);

if(cm == 0)
{
TelaConfig();
char key = Click();

switch (key)
{
case '1':
max = 100;
break;

case '2':
max = 200;
break;

18
 case '3':
max = 300;
break;

case 'A':
//cancel
break;
}

}
else
{
TelaInicial();

lcd.setCursor(11, 0);

if (palavra.toInt()<100)
lcd.print(0);

lcd.print(cm);

if((cm >= 3)&& (cm <= (max/6)))

{
lcd.setCursor(6, 1);
lcd.print(") ");

digitalWrite(LedVermelho, HIGH);
digitalWrite(LedAmarelo, LOW);
digitalWrite(LedVerde, LOW);
digitalWrite(Buzzer, HIGH);

else if(cm <= max/3)

{
lcd.setCursor(6, 1);
lcd.print(")) ");

digitalWrite(LedVermelho, HIGH);
digitalWrite(LedAmarelo, LOW);
digitalWrite(LedVerde, LOW);

digitalWrite(Buzzer, HIGH);
delay(100);
digitalWrite(Buzzer, LOW);
delay(100);
}

else if (cm <= 2*max/3)

{

19
 lcd.setCursor(6, 1);
lcd.print("))) ");

digitalWrite(LedVermelho, LOW);
digitalWrite(LedAmarelo, HIGH);
digitalWrite(LedVerde, LOW);

digitalWrite(Buzzer, HIGH);
delay(300);
digitalWrite(Buzzer, LOW);
delay(300);
}

else if (cm <= max)

{
lcd.setCursor(6, 1);
lcd.print("))))");

digitalWrite(LedVermelho, LOW);
digitalWrite(LedAmarelo, LOW);
digitalWrite(LedVerde, HIGH);

digitalWrite(Buzzer, HIGH);
delay(500);
digitalWrite(Buzzer, LOW);
delay(500);
}

else
{
lcd.setCursor(6, 1);
lcd.print("XXXX");

digitalWrite(LedVermelho, LOW);
digitalWrite(LedAmarelo, LOW);
digitalWrite(LedVerde, LOW);
delay(500);

digitalWrite(Buzzer, HIGH);
digitalWrite(LedVermelho, HIGH);
digitalWrite(LedAmarelo, HIGH);
digitalWrite(LedVerde, HIGH);
delay(500);
digitalWrite(Buzzer, LOW);
delay(500);
}
}
}

//-------- -------- -------- --------

//--------------- FUNÇÕES --------------

20
//-------- -------- -------- --------

char Click ()
{
Serial.print("Entrou no clique");
char key = keypad.waitForKey();
if (key){
Serial.print("tecla pressionada: ");
Serial.println(key);
return key;
}
}

//-------- -------- -------- --------

//---------------- TELAS ---------------
//-------- -------- -------- --------

void TelaInicial(){
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Distincia: cm");
}

void TelaConfig(){
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("1:100cm 2:200cm");
lcd.setCursor(0, 1);
lcd.print("3:300cm D:CANCEL");
}

/*// Projeto 10 - Sensor de luz ambiente

int pinoLed = 13;

int pinoSensorLuz = A0;
int valorLuz = 0;

void setup()
{
pinMode(pinoLed,OUTPUT);
}

void loop()
{
valorLuz = analogRead(pinoSensorLuz);
if(valorLuz<750)
{
digitalWrite(pinoLed,HIGH);
}
else

21
 {
digitalWrite(pinoLed,LOW);
}
delay(10);
}*/

22
Anexo C - Fluxograma

23
Anexo D - Simulação

24