RELATÓRIO

VEÍCULO AUTÔNOMO MICROCONTROLADO (SEGUE-FAIXA)

Abel Felipe de Oliveira – R.A.: 110564

César Hideki Alves Tanaka – R.A.: 14000730
Luciano Donizetti da Silva – R.A.: 136163
Paulo Sérgio de Souza Júnior – R.A.: 14000919
Rafael Wellington de Moraes – R.A.: 14001632
Orientador: Washington Luiz dos Santos Junior
 INTRODUÇÃO

Atualmente vivemos transformações constantes na área da eletrônica, tanto em

novidades como robôs, braços mecânicos. E também constantes atualizações
dos eletrônicos, desta forma foi proposto em sala de aula um desafio para o
grupo e para os demais colegas de sala de aula, o desafio consiste em projetar
um protótipo de carrinho que segue uma faixa, assim o tornando-o autônomo em
partes, pois o protótipo tem o objetivo de seguir uma faixa, assim não o torna
totalmente autônomo devido o mesmo depender de uma faixa para seguir e sem
a faixa o carrinho não andaria.
O protótipo engloba três tecnologias distintas para poder obter o correto
funcionamento do carrinho sendo Eletrônica, Mecânica e Informática.

1. ELETRÔNICA

O sistema eletrônico do veículo autônomo possui sensores de entrada, que

informam ao sistema qual a direção do movimento a ser imprimido, um
controlador, que processa esses sinais, e atuadores de saída que realizam o
movimento em si. O fluxograma de funcionamento é exibido pela figura 1 a
seguir.

Figura 1 – Fluxograma Sistema Eletrônico

Os sensores de entrada tratam-se de sensores ópticos IR (Infra-vermelho) que
identificarão a existência da faixa preta e sua posição com relação ao veículo.
Essa informação de posição é então processada pelo microcontrolador, o qual
enviará para os motores do veículo via módulo Ponte H a direção e intensidade
que cada motor deverá girar para manter o veículo centralizado com relação à
faixa.
Na identificação da posição da faixa, existem três possibilidades, conforme figura
2. Na Situação 1, a faixa já está centralizada com relação ao veículo. Nessa
ocasião, o microcontrolador comandará ambos os motores para frente com
mesma intensidade. Na Situação 2, a faixa está à esquerda do veículo. Nessa
ocasião, ambos os motores são comandados para frente, mas o motor direito
com velocidade maior do que o esquerdo de forma a corrigir a posição do veículo.
Analogamente, na Situação 3 a faixa está à direita do veículo e o motor esquerdo
é comandado com velocidade maior do que o direito.

Figura 2 – Funcionamento Sensores IR

Para controlar os motores, é necessário um dispositivo de controle de potência

e direção, visto que a potência de saída do microcontrolador não é suficiente
para os motores dessa potência. A solução encontrada foi a utilização de uma
Ponte H. O esquema elétrico de uma Ponte H é exibido pela figura 3.
 Figura 3 – Funcionamento Sensores IR
Fonte: https://pt.wikipedia.org

Nas subseções a seguir serão apresentados os componentes utilizados para a

construção do sistema eletrônico do veículo.

1.1. Sensor IR
Para detectar a posição da faixa preta, é utilizado o módulo Tracking Sensor do
fabricante Sunfounder, exibido pela figura 4 a seguir:

Figura 4 – Sensor IR
Fonte: Sunfounder

O esquema elétrico desse módulo é exibido pela figura 5. Nela, pode-se observar
que esse módulo utiliza o CI comparador LM393 para retornar pelo pino Signal
se o sensor óptico TCRT5000 está sob uma superfície reflexiva.
 Figura 5 – Esquema elétrico Sensor IR
Fonte: Sunfounder

Na figura 6 verifica-se que quando o sensor TCRT5000 se encontra sobre uma

superfície reflexiva, o feixe infra-vermelho que sai do foto-diodo é recebido pelo
foto-transistor, fechando o contato entre seu coletor e emissor. Nesse
momento, pelo pino “Signal” do módulo é enviado um nível de tensão analógico
que é então conduzido até o Arduino UNO.

Figura 5 – Sensor TCRT5000

Fonte: http://francois-ouellet.ca

momento, pelo pino “Signal” do módulo é enviado um nível de tensão analógico

que é então conduzido
1.2. Microcontrolador
Segundo McRoberts (2011), um Arduino é um micro controlador de placa única
e um conjunto de software para programa-lo. O hardware consiste em um projeto
simples de hardware livre para o controlador, com um processador Atmel AVR e
suporte embutido de entrada/saída. O software consiste de uma linguagem de
programação padrão e do bootloader que roda na placa.
O Arduino é uma plataforma de computação física ou embarcada, ou seja, um
sistema que pode interagir com seu ambiente por meio de um hardware e
software. Pode ser utilizado para desenvolver objetos interativos independentes,
ou pode ser conectado a um computador, a uma rede, ou até mesmo à Internet
para recuperar e enviar dados do Arduino e atuar sobre eles.
Para programar o Arduino, utiliza-se o IDE do Arduino, um software livre no qual
se escreve o código na linguagem de programação padrão, a qual tem origem
em Wiring e é essencialmente C/C++.
O hardware e o software do Arduino são ambos de fonte aberta, o que significa
que o código, os esquemas, o projeto, etc. podem ser utilizados livremente por
qualquer pessoa e com qualquer propósito.
Dentre os modelos existentes desta placa, está o Arduino UNO. Conforme o site
oficial Arduino, o Arduino UNO é uma placa baseada no microcontrolador
ATmega328P que possui 14 pinos de entrada/saída digitais (dos quais apenas
6 podem ser utilizados como saídas PWM), 6 entradas analógicas, cristal de
quartzo de 16MHz, uma conexão USB, um jack de alimentação, um leitor ICSP
e um botão de reset. A figura 6 exibe este modelo de placa dividido em blocos:

Figura 6 – Arduino UNO dividido em blocos

Fonte: Albertassi (2017)
Os blocos apresentados na figura 6 podem ser definidos da seguinte forma:
• Conversor Serial – UBS: Interface através da qual se faz o carregamento
dos programas escritos no IDE. Também pode ser utilizado para alimentar a
placa com 5V.
• Cristal: Responsável por gerar a frequência de clock da placa.
• Fonte de alimentação: Converte a tensão inserida em 5V para alimentar
o microcontrolador.
• Terminais de alimentação: Possui pinos que servem para fornecer
tensões de 3,3V e 5V para um circuito externo e possui um pino (Vin) onde pode-
se alimentar a placa com 5 a 12V.
• Entradas analógicas: Pinos onde se pode conectar entradas analógicas.
• Entradas e Saídas digitais: Pinos onde se pode conectar dispositivos de
entrada ou saída a serem definidos na programação.
• CPU Atmel: Microcontrolador ATmega328P.
As características básicas da placa são:
• Tensão de operação: 5V.
• Tensão de alimentação recomendada: 7 a 12V. Apesar de sua tensão de
operação ser 5V, deve-se alimentá-lo com um nível maior de tensão pois a
tensão fornecida passa por um circuito regulador de tensão que a reduz para o
nível de operação.
• Limite de tensão de entrada: 6 a 20V.
• Pinos digitais: 14, sendo 6 deles pinos com saída analógica PWM.
• Entradas analógicas: 6 pinos.
• Corrente contínua por pino de entrada e saída: 40mA.
• Corrente para o pino de 3,3V: 50mA.
• Quantidade de memória FLASH: 32kB, onde 0,5kB são utilizados para o
bootloader.
• Quantidade de memória SRAM: 2kB.
• Quantidade de memória EEPROM: 1kB.
• Velocidade de clock (cristal): 16MHz.
Neste modelo, a memória FLASH é utilizada para armazenar o sketch (programa
do Arduino) e bootloader (firmware para interface USB), a memória SRAM é
onde são criadas e modificadas as variáveis ao longo da execução do sketch e
a memória EEPROM é utilizada para armazenar informações não voláteis.
O micro controlador utilizado no Arduino UNO é o ATmega328P, o qual segundo
seu datasheet fornecido pela fabricante ATMEL, é um micro controlador CMOS
de 8 bits de baixa potência de arquitetura AVR, baseada nas arquiteturas RISC
e HAWARD. Executando instruções em um único ciclo de clock, o ATmega328P
atinge taxas de transferência próximas de 1MIPS (Milhões de instruções por
segundo) por MHz.
Segundo Monteiro (2012), RISC é a abreviatura de “Reduced Instruction Set
Computer”, computador com conjunto reduzido de instruções, e é a identificação
de um tipo de arquitetura de UCP que se contrapõe à arquitetura denominada
CISC – Complex Instruction Set Computer, ou computador com conjunto
complexo de instruções.
As principais características das arquiteturas RISC são menor quantidade de
instruções e tamanho fixo, execução otimizada de chamada de funções, menor
quantidade de modos de endereçamento e a existência modo de execução com
pipelining.
Os microcontroladores AVR da fabricante ATMEL são desenvolvidos sob a
tecnologia RISC e arquitetura HAWARD que separa a memória de dados da
memória de programa. Desta forma um microcontrolador AVR tem um
barramento para dados e outro para programa. Esta separação de barramentos
permite uma maior velocidade no tratamento dos dados e do programa.
As principais características deste microcontrolador são:
• 131 Instruções.
• 32 X 8 Registradores de uso geral.
• Até 20MIPS de taxa de transferência à 20MHz.
• 32kB de memória FLASH.
• 2kB de memória SRAM.
• 1kB de memória EEPROM.
• 10000 ciclos de escrita/leitura na memória FLASH e 100000 ciclos na
memória EEPROM.
• 2 contadores de 8 bits independentes.
• 1 contador de 16 bits.
• 6 canais de PWM.
• Opera com tensão de 1,8 a 5,5V.
• Pode operar na faixa de 0 a 4MHz (se a alimentação for de 1,8 a 5,5V), 0
a 10MHz (se a alimentação for de 2,7 a 5,5V) ou 0 a 20MHz (se a alimentação
for de 4,5 a 5,5V).
• Consome 0,2mA no modo ativo, 0,1µA no modo Power-down e 0,75µA
no modo de economia de energia.
1.3. Módulo Ponte H
Ponte H é um circuito eletrônico usado para determinar um sentido de corrente
e valor de tensão no controle de um motor DC. Seu funcionamento dá-se pelo
chaveamento de componentes eletrônicos usualmente utilizando do método de
PWM para determinar além da polaridade, o módulo da tensão em um dado
ponto de um circuito.
Uma das formas de se construir uma ponte H é através do circuito integrado
L293D fabricado pela Texas Instruments. Este C.I. tem como função prover
correntes bidirecionais de até 600mA, com tensões de 4,5V a 36V.
As características deste C.I. são as seguintes:
• Temperatura de Operação: 0°C a 70°C.
• Tensão de Alimentação (Vcc1): 4,5 a 7V.
• Tensão de Alimentação para motores (Vcc2): Vcc1 a 36V.
• Tensão de Entrada para nível baixo: -0,3 a 1,5V.
• Tensão de Entrada para nível alto: 2,3 a 7V.
• Tensão de Saída para nível baixo: 1,2 a 1,8V.
• Tensão de Saída para nível alto: Vcc2 – 1,8 a Vcc2 – 1,4.
• Corrente máxima de nível alto para pinos de controle: 100μA.
• Corrente máxima de nível alto para pinos de habilitação: 10μA.
A seguir, descreve-se a função de cada um dos pinos deste C.I., cuja pinagem
é exibida pela figura 7.
 Figura 7 – Pinagem L293D
Fonte: Texas Instruments

• 1A a 4A: Pinos de entrada do C.I. Definem a direção dos motores

conectados no pinos de saída.
• 1Y a 4Y: Pinos de saída do C.I. São conectados aos motores.
• 1,2EN: Pino de habilitação para os canas 1 e 2.
• 3,4EN: Pino de habilitação para os canais 3 e 4.
• GND: Pinos de aterramento do CI.
• Vcc1: Alimentação do CI (5V).
• Vcc2: Alimentação dos motores conectados ao C.I.
O fabricante Deek Robot produz um shield para Arduino baseado neste circuito
integrado com alimentação estabilizada para o circuito com o regulador de
tensão LM7805 e capacitores, bem como LEDs indicadores para indicar o
sentido da corrente para os motores. O circuito deste shield é exibido pela figura
8.
 Figura 8 – Shield L293D
Fonte: Deek Robot

1.4. Motores DC
Segundo Del Toro (1999), um motor de corrente contínua (DC) é um gerador de
corrente contínua com o fluxo de potência invertido. No motor de corrente
contínua, a energia elétrica é convertida em mecânica. A direção de rotação do
eixo de um motor DC é definida pelo sentido de aplicação da corrente elétrica
em seus terminais.
O modelo de motor DC utilizado neste projeto para movimentar a direção robô é
o DC DG01D-L do fabricante DAGU Robot, exibido pela figura 9.

Figura 9 – Motor DG01D-L

Fonte: DAGU Robot

Esse motor possui as seguintes características:

• Tensão de alimentação: 3 a 9V.
• Corrente sem carga: 150mA (3V) a 200mA (6V).
• Corrente máxima: 250mA.
• Torque máximo: 800gf.cm.
• Velocidade sem carga: 90RPM (3V) a 200RPM (6V).
• Possui caixa de redução 1:48.
Por fim, o esquema elétrico final do circuito é o exibido pela figura 10.

Figura 10 – Esquema elétrico veículo autônomo

2. MECÂNICA
Mecanicamente, o veículo autônomo microcontrolado foi montado conforme a
figura 11.
 Figura 11 – Montagem Veículo Autônomo

De forma geral, os componentes de montagem podem ser classificados como:

 Base
 Motores
 Rodas
 Roda Livre
 Suporte dos Sensores
 Suportes dos Motores
 Sensores IR
 Baterias 9V
 Módulo Ponte H
 Arduino UNO
Esses componentes foram distribuídos conforme figura 12
 Figura 12 – Componentes veículo autônomo

Os motores, rodas e componentes eletrônicos são itens comerciais adquiridos.

As demais peças fabricadas para o conjunto são exibidas pelas figuras 13, 14 e
15 a seguir.

Figura 13 – Especificações Base

 Figura 14 – Especificações Suportes dos Motores

Figura 15 – Especificações Suportes dos Sensores

3. INFORMÁTICA

Conforme visto na seção 1, o microcontrolador Arduino pode ser programado

para atender às necessidades de projeto via a linguagem Wiring em seu software
IDE. No contexto do veículo autônomo desenvolvido, o Arduino será responsável
por processar os dados de medição analógica fornecido pelos sensores e
acionar os motores em direção e velocidade de acordo com as informações
processadas. A lógica do programa desenvolvido segue o fluxograma da figura
16.

Figura 16 – Diagrama em blocos da programação

O Código utilizado para esse sketch é exibido a seguir:

int Port_PonteH_in1 = 9; //Atribui IN1 ao pino 9
int Port_PonteH_in2 = 10; //Atribui IN2 ao pino 10
int Port_PonteH_in3 = 5; //Atribui IN3 ao pino 5
int Port_PonteH_in4 = 6; //Atribui IN4 ao pino 6
int SensorDireita = A0; //Atribui entrada do sensor da direita ao pino A0
int SensorEsquerda = A1; //Atribui entrada do sensor da esqueda ao pino A1
int ValorSensorDireita = 0; //Declara variável para salvar valor do sensor direito
int ValorSensorEsquerda = 0; //Declara variável para salvar valor do sensor esquerdo
unsigned long media_sensor_direita = 0; //Declara variável para média dos valores
medidos
unsigned long media_sensor_esquerda = 0; //Declara variável para média dos valores
medidos
int ref_sensor_direita = 0; //Declara variável de referência
int ref_sensor_esquerda = 0; //Declara variável de referência
int contador = 0; //Declara variável de contagem
void controle_motor(int a, int b, int c, int d); //Declara função de controle do motor
void movimentar(int code); //Declara função de controle do movimento do motor

void setup() {
pinMode(Port_PonteH_in1, OUTPUT); //Define que IN1 é uma saída
pinMode(Port_PonteH_in2, OUTPUT); //Define que IN2 é uma saída
pinMode(Port_PonteH_in3, OUTPUT); //Define que IN3 é uma saída
pinMode(Port_PonteH_in4, OUTPUT); //Define que IN4 é uma saída
pinMode(SensorDireita, INPUT); //Define que A0 é uma entrada
pinMode(SensorEsquerda, INPUT); //Define que A1 é uma entrada
}

void loop() {
unsigned long media_inicial_direita = 0; //Declara variável de média inicial
sensor direito
unsigned long media_inicial_esquerda = 0; //Declara variável de média inicial
sensor esquerdo
for(int i=0; i<10; i++){ //Inicia laço de 10 repetições
media_inicial_direita = media_inicial_direita +
analogRead(SensorDireita); //Calcula média inicial sensor direito
media_inicial_esquerda = media_inicial_esquerda +
analogRead(SensorEsquerda); //Calcula média inicial sensor esquerdo
}

ref_sensor_direita = media_inicial_direita/10; //Salva valor de referência sensor

direito
ref_sensor_esquerda = media_inicial_esquerda/10; //Salva valor de referência
sensor esquerdo
 while(1){ //Cria laço de execução sem fim
ValorSensorDireita = analogRead(SensorDireita); //Salva leitura sensor
direito
ValorSensorEsquerda = analogRead(SensorEsquerda); //Salva leitura
sensor esquerdo

if(contagem < 1000){ //Cria laço de 1000 repetições

media_sensor_direita = media_sensor_direita +
ValorSensorDireita; //Calcula média sensor direito
media_sensor_esquerda = media_sensor_esquerda +
ValorSensorEsquerda; //Calcula média sensor esquerdo
contagem = contagem + 1; //Incrementa contagem
}
else{
contagem = 0; //Zera a contagem
ref_sensor_direita = media_sensor_direita/1000; //Atualiza valor
de referência sensor direito
ref_sensor_esquerda = media_sensor_esquerda/1000; //Atualiza
valor de referência sensor esquerdo
media_sensor_direita = 0; //Zera valor da média sensor direito
media_sensor_esquerda = 0; //Zera valor da média sensor
esquerdo
}

if(ValorSensorDireita > (ref_sensor_direita + 100)){ //Executa se sensor

direito identificou faixa
if(ValorSensorEsquerda > (ref_sensor_esquerda + 100)){
//Executa se sensor esquerdo identificou faixa
movimentar(1); //Veículo avança
}
else{ //Caso condição acima não foi satisfeita
 movimentar(4); //Curva para esquerda
}
}
else{ //Caso primeira condição não foi satisfeita
if(ValorSensorEsquerda > (ref_sensor_esquerda + 100)){
//Executa se sensor esquerdo identificou faixa
movimentar(3); //Curva para direita
}
else{ //Caso condição acima não foi satisfeita
movimentar(1); //Veículo avança
}

}
}
}

void movimentar(int code) { //Define função de movimento

switch(code) { //Codições do parâmetro code
case 1: //Frente
controle_motor(0,127,0,127); //Veículo avança
break;
case 2: //Trás
controle_motor(127,0,127,0); //Veículo recua
break;
case 3: //Direita
controle_motor(0,127,127,0); //Veículo faz curva para direita
break;
case 4: //Esquerda
 controle_motor(127,0,0,127); //Veículo faz curva para esquerda
break;
default: //Parado
controle_motor(0,0,0,0); //Veículo avança
break;
}
}

void controle_motor(int a, int b, int c, int d) { //Define função de controle do motor

analogWrite(Port_PonteH_in1, a); //Pino 9 Ativado - Motor direito para trás
analogWrite(Port_PonteH_in2, b); //Pino 10 Ativado - Motor direito para frente
analogWrite(Port_PonteH_in3, c); //Pino 5 Ativado - Motor esquerdo para trás
analogWrite(Port_PonteH_in4, d); //Pino 6 Ativado - Motor esquerdo para frente

CONCLUSÃO

Conclui-se através do exposto que com componentes de baixo custo é possível

conceber um veículo autônomo microcontrolado capaz de seguir uma faixa
acompanhando diversas curvas existentes no trajeto. Esse requisito é possível
cumprir através da utilização de alimentação PWM, a qual permite ajustar a
tensão de alimentação dos motores DC, e de sensores emissores de feixe
infravermelho, os quais podem emitir resposta proporcional à distância do
veículo da faixa que se deseja seguir.
 REFERÊNCIAS

Datasheet L293D, Disponível em: <http://www.deek-robot.com/>. Acesso em:

25/10/2018.

Datasheet DG01D-L, Disponível em: <http://www.dagurobot.com/>. Acesso em:

25/10/2018.

Datasheet ATmega328P, Disponível em: <http://www.atmel.com/>. Acesso em:

25/10/2018.

Datasheet Tracking Sensor, Disponível em: < https://www.sunfounder.com/

Acesso em: 25/10/2018.

Datasheet Sensor TCRT5000, Disponível em: < http://francois-ouellet.ca>

Acesso em: 25/10/2018.

Funcionamento Ponte H, < https://pt.wikipedia.org >. Acesso em 25/10/2018

Arduino, <http://www.arduino.cc>. Acesso em 25/10/2018

MCROBERTS, Michael. Arduino Básico. 1ª edição. São Paulo: Novatec

Editora, 2011.

ALBERTASSI, William S. Automação de Pequenos Projetos – Aula 6. ETEP

Faculdades, 2017.
DEL TORO, Vicent. Fundamentos de Máquinas Elétricas. 1ª edição. São Paulo:
LTC, 1999.