Você está na página 1de 53

Sistemas da Informação

Atividade Prática Supervisionada

Jogo Java – Guittar Lixo

HenriqueR.A
Jessica G.P R.A D818GD6
Jennifer R.A N3708G3
Mariana Ito Rusig R.A D802984
Marina Alves Antunes R.A N350HC6
Marcio Maltauro Mariano R.A N372079
Wesley de Oliveira Feitosa R.A N3767A5
Silvestre Rithieri da S. Brito R.A N373962
Guilherme novack V. da Silva R.A N3516F6
Renan Santana de Oliveira R.A N358394

Professor (es) Orientador(es):


[ Rafael]
[Viviane]
[]
São Paulo/ SP
2018
CARRINHO ECOLÓGICO MOVIDO A CONTROLE REMOTO

Trabalho de Atividades Práticas


Supervisionadas APS de Curso
de Sistemas da Informação.

São Paulo/ SP
2018
OBJETIVO DO TRABALHO

O objetivo deste trabalho é desenvolver um carrinho elétrico que seja


controlado via conexão bluetooth por um aplicativo celular ou por um veículo de
controle remoto.

Usando a plataforma de open source Arduino, programamos na linguagem C#


um código de lógica simples que envia para a placa “Arduino nano v3 atmega”
conectada ao carrinho as determinadas coordenadas, sendo elas os requisitos
mínimos de direção: Direita, esquerda, frente e trás.

O carrinho tem como fundamento o uso de materiais recicláveis que colaboram


para o Desenvolvimento Sustentável, as peças escolhidas para a sua
composição foram de baixo custo e confiáveis para o resultado esperado, além
disso elas têm o propósito de não gerar danos ao meio ambiente.

Portanto além do desenvolvimento e execução de nossas habilidades


aprendidas no curso de Sistemas de Informação, nosso carrinho tem o objetivo
de representar no contexto de sustentabilidade que a tecnologia pode
colaborar com o combate ao desperdício e a criação de produtos mais
duráveis.
Sumário

Introdução....................................................................................0 5
1-(colocar aqui)........... .................................................................. 00
2-(colocar aqui)............................................. ................................00
3-(colocar aqui)............................................................................. 00
4-(colocar aqui)........................ ….…………………….…….……..……..00
5-(colocar aqui)......... ....................................................................00
6-(colocar aqui)............................................................................. 00
7-(colocar aqui).................... .................... ..................................... 00
8-(colocar aqui)........ ..................................................................... 00
9-(colocar aqui)........................................... .................................. 00
10-(colocar aqui).... .......................................................................00
12-(colocar aqui)........................................................................... 00
13-(colocar aqui).................................. ......................................... 00
13-(colocar aqui).... ...................................................................... .00
14-(colocar aqui).......................................................................... .00
15-(colocar aqui)........................................................................ ...00
INTRODUÇÃO

O diferencial do projeto é ser feito manualmente utilizando materiais simples,


baratos, fáceis de encontrar que podem ser até reaproveitados, como varetas
de aço de guarda-chuva ou raios de bicicleta, espiral de encadernamento de
apostilas, tubinhos de pirulito, tubo de caneta, garrafa pet, EVA de papelaria,
motor de engrenagem de drive de DVD antigo entre outros.

Durante o estudo aprendemos como fazer o sistema de direção do veiculo de


forma bem simples, usando apenas varetas de aço e tubinhos de pirulito,
sistema de tração usando um drive de DVD antigo, sistema de suspensão
traseiro e dianteiro usando espiral de encardenamento, além de rodas perfeitas
usando EVA de papelaria, que também poderia ser usada em outros projetos
do mesmo porte. Tudo isso gastando muito pouco e sem utilizar ferramentas
pesadas como furadeiras, serra elétrica, que nem sempre temos em casa.
Tudo foi feito manualmente, utilizando ferramentas comuns como alicates,
chaves de fenda, estilete, ferro de solda, serrinha de aço e cola quente.

Na parte eletrônica utilizamos um controle de vídeo game para controlar o


veiculo a uma distancia de até 300 metros com o módulo NRF24L01 em sua
versão mais simples e barata, podendo controlara direção, frente, ré e
velocidade do veiculo, além de acender e apagar os faróis, setas e iluminação,
podendo acionar a buzina e sirene, totalizando 11 canais de comunicação
entre controle remoto e o veiculo.

Palavras-chave: Materiais recicláveis, desenvolvimento sustentável, Carrinho,


Bluetooth, Arduino.
1. Fundamentação teórica:
A sustenabilidade é uma das causas de debates em relação aos riscos da
decomposição do meio ambiente, além de atender as necessidades do presente
sem comprometer as gerações futuras. A palavra sustentável vem da palavra
sustentar, que deriva do latim, sustentare (FERREIRA, 1986), suportar, conservar,
manter, dotar de víveres, impedir a ruína e etc...

Com isso, prolongar a produtividade do uso dos recursos naturais, e como podemos
reagir em relação a natureza. Pois sabemos que mesmo com a definição, o desafio
é mundial, no momento em que estamos vivenciando no mundo esta em
desequilíbrio. Assim sendo composta por 3 variáveis (Abbade., 2012) e que se
relacionam: economica, ambiental e social.

O projeto está qualificado dentro dos 3 tipos de sustentabilidade, pois na parte


social, relaciona o convívio do cidadão com as outras pessoas, engloba o ser
humano e a forma que escolhe o seu modo de lazer.
Em ambiental, está relacionado a forma que o ser humano escolhe para o cuidado e
desenvolvimento dos seus projetos em relação ao meio ambiente e seu entorno,
fazendo com que escolham produtos recicláveis e de alto nível de reaproveitamento.
E o econômico está relacionado, pelo fato do nosso projeto não ter um alto custo de
consumo em seu desenvolvimento e muito menos em seu aproveitamento. Visto que
utilizamos materiais recicláveis e de baixo valor, não foram utilizados produtos que
possam a vir prejudicar o meio ambiente.

Porém, o foco é em relação a Sustentabilidade ecológica – limitação de recursos


ambientais, do consumo de combustíveis fósseis, que são esgotáveis, redução de
gerar resíduos e de poluição e reciclagem. Devido à escassez dos recursos
naturais, que muito tem se discutido, se esgotando e causando um grande
desequilíbrio ambiental. Realizando projetos para reduzir os impactos ambientais, é
possível ter uma grande economia interna, como de água e de luz.

O site das Nações Unidas Brasil (ONUBR, 2018), tem muitos projetos para
formulação de objetivos de Desenvolvimentos sustentáveis, uma delas a
sustentabilidade global, que não foi achado programas para produtos recicláveis. A
prefeitura de São Paulo possui – Ecourbis – a concessionária responsável pela
coleta, transporte e destinação adequada de resíduos domiciliares, materiais
recicláveis e resíduos dos serviços de saúde. Do qual deveríamos reeducar a nossa
visão referente aos produtos que não separamos no dia-a-dia e deveria ser
concentização para todos. Desde o desenvolvimento de novos projetos pequenos e
os maiores. Contudo, vemos que atualmente não temos uma educação do nosso
presente em relação a escassez dos recursos naturais, a separação de produtos
orgânicos e não recicláveis de sacos cinzas e os recicláveis para os sacos verdes. E
seria o caso dos condomínios que tem – coleta seletiva – que foram previamente
separados por indivíduos, empresa ou instituição, implantação é obrigação dos
municípios fazerem com que todos façam a sua parte.

E mostrado que muitos dos lugares não dispõem de serviços de coleta de lixo e de
reciclagem, assim a população fica com baixo nível de educação ambiental e não
toma a concientização aos descarte dos produtos, comentado (Gumes, 2005):

A concepção de conscientização, no entanto, é melhor


trabalhada se for tomada como uma propriedade de atitudes
concomitantes entre saber e agir. O conhecimento pode ser
adquirido através da educação como transmissão, mas a
conscientização seria algo mais complexo que requer a
interação entre as várias realidades humanas e o ambiente.

1.1 O carro elétrico no contexto do Desenvolvimento Sustentável


Um dos primeiros passos foi fazer um levantamento do que poderíamos utilizar , o
projeto foi pensado em objetos de fáceis acessos do nosso dia-a-dia, desde o que
não usamos e o que poderiam ser recicládos e reutilizados para este projeto. Além
de aprendermos o consumo consciente e o descarte de suas partes que não foram
utilizados. E foi pesquisando como construir com essa base, e o modelo de kart
kross foi o mais próximo que chegamos para a construção do nosso carrinho.

Fonte: Kart 2016( Figura1)


E em relação aos outros projetos que foram pesquisados, não identificamos: listas
de materiais,se foram inseridos em algum projeto sustentável e um plano de
montagem de suas partes.

Fonte: Souza2013 (Figura 2)

A figura 2 mostra que o carro foi feito em madeira MDF, e rodas de carro de
brinquedo. De uma forma bem simples com poucos recursos.

Já a figura 3, um caminhão de brinquedo, que foi um feito mais avantajado para


fazer ele funcionar, e que não foram encontrados objetos reutilizados na produção
do projeto.

Fonte: SMIDT, 2013 (Figura 3)

O nosso projeto, pensamos em um diferencial construindo desde o Chassi até a


transformação de um carro, temos a utilização de pilhas, e vimos que muitos delas
são descartadas de forma incorreta, (temas, 2011) podem estourar e além de soltar
o líquido tóxico no interior delas. Muitas delas podem passar por algum tipo de
tratamento que possam não ser nocivos ao meio ambiente. Vale salientar que as
pilhas como as alcalinas não contém metais pesados na sua composição. As pilhas
comuns, as recarregáveis, devem ser devolvidas aos fabricantes, pois possuem:
cádmio, chumbo e mercúrio.

Além do cobre, que foi utilizado neste projeto, e sim, ele é 100% reciclado e
reutilizado e não tem problema do cobre reciclado (Glösser, 2013). O caso das
varetas de guarda-chuva, muitas vezes são jogadas em sarjetas, fora da lixeira
reciclável. O caso de tubos de pirulito e tubo de caneta, muitas vezes não damos a
importância do seu descarte.

O caso dos papéis, pensamos na utilização de fazer uma roda diferente, que fosse
usado algo do nosso dia e realizar o formato de uma roda. Pensamos em fazer a
base de uma tampa e realizar camadas para virar uma roda, com o papel EVA. No
entanto, ela é uma mistura de borracha-não tóxica, e como ele é usado para
artesãos e lembranças, pensamos nele como uma roda forte para o carrinho.

Contudo, alguns dos materiais mais utilizados neste projeto, foram os plásticos,
onde estudos apontam que maior parte do seu descarte não é reaproveitado e
jogados ao mar, comentado (Rose, 2018):

No entanto, é nos oceanos que o plástico exerce seu


maior impacto ambiental. Em 2010, quando se realizou
o até agora mais completo estudo sobre o assunto, já
se estimava que aproximadamente oito milhões de
toneladas de plástico vão parar nos oceanos
anualmente. A maior parte deste volume de detritos não
é jogada lá diretamente, mas carregada através dos
rios. 90% de todo este plástico, apontam estudos, são
jogados nos mares por dez rios: rio Yangtze (China); rio
Indo (Paquistão); rio Amarelo (China); rio Hai (China);
rio Nilo (Egito); rio Ganges (Índia); rio das Pérolas
(China); rio Anum (Gana), rio Níger (Nigéria) e rio
Mekong (Vietnã). Provavelmente, se fluísse em direção
ao oceano Atlântico o rio Tietê também seria incluído
nesta lista.

O ponto forte do nosso trabalho foi verificiar a importância da sustentbilidade no


contexto do projeto, além da relação ao mundo e modificações e ações que
podemos fazer desde o atual quadro dos recursos dos objetos recicláveis.
E para o projeto inserido no curso de Sistemas da Informação, trabalhando com
Arduino e programar um objeto com programação, foi considerado o que
poderíamos ser o diferencial dentre todos outros projetos. Desde o conhecimento
dentro do Desenvolvimento Sustentável, cada objeto ser construído a estrutura e por
fim, a finalização programada no Arduíno e a importância do nosso meio Ambiente e
gerações futuras.
2 Estrutura do Programa
2.1 Arduino Uno

O Arduino é uma plataforma de open source, (ArduinoREV3) no entanto, o


Arduino uno possui: 14 pinos de entrada e saída digital, um conector de
energia, entrada USB, botão de reset, conector de energia, conector ICSP(
In Circuit Serial Programming) 1 e qualquer um podem programar e usar em
algum projeto 2.

Microcontrolador ATmega328P

Tensão operacional 5V

Tensão de entrada 7-12V


(recomendado)

Tensão de entrada 6-20 V


(limite)

Pinos de entrada 6
analógica

Pinos Digital I / O 14 (dos quais 6 fornecem


saída PW M)

Tabela1: Dados tec. Arduíno

O Arduino, receptor e como o transmissor serão utilizados, além de ser barato e


menor, a desvantagem de usar o Pro Mine, é que ele não possui porta USB.

Primeiramente, para programar o carrinho, é preciso Arduino e IDE – Integrated


Development Enviroment), o programa pode ser baixado gratuitamente:

https://www.arduino.cc

1alguns dispositivos lógicos programáveis e microcontroladores serem programados e instalados em um sistema,


em vez de exigir que o chip já programado antes de ser instalado em algum sistema

2 Figura6
Fonte: Download IDE (Figura 5)

Depois das opções clicadas, aparece a opção de doação, mesmo muitos downloads
feitos, basta clicar para realizar o download:

1Fonte: Download IDE(Figura 6)

O procedimento agora são as ligações entre os dois Arduinos:

Figura 7: Pontos de ligação para Arduino Mini

Os pinos do Arduino são usados para alimentaçãoe programação, e ligados na ordem


como na figura 7 e abaixo:
DTR/GRN - port Reset
BLK - n/a
GND - Ao GND
Vcc - 5v
RX - Pino 0
TX - pino 1

Feito isso, colocado o cabo USB para conectar ao Arduino Uno, clicando em
Ferramentas, placa: Arduino Pro or Mini”. A configuração que carregamos o código
de exemplo Blink, pois ele faz com que a porta digital do Arduino realize o teste em
intervalos. O intuito do trabalho é programar para que o carro ande: para frente, vire
a direita, vire para esquerda e ande de ré.

2.2 Mecanização

O módulo NRF24L01, (Arduino,2015) é um módulo ótimo e perfeito para realizar a


comunicação entre dois ou mais dispositivos. Devido ao baixo consumo de energia e
a rápida comunicação, pode até 10 m em ambiente fechado, 50m ambiente aberto.
No caso da alimentação vai de 1,9 até 3.6v, trabalhando com pinos de sinal de 5v.

Figure 8: Fonte(Arduino,2015)

As suas características3:
• Tensão: 3 -3,6V (3,3V);
• Frequência: 2.4Ghz ;
• Velocidade: 2Mbps;
• Potência max de saída: +20dBm;
• Modo de emissão (pico): 115mA ;
• Modo de receção (pico): 45mA;
• Power-down mode atual: 4.2 uA
.Nesse projeto ele será utilizado como transmissão e receptor para realizar a
programação com o Arduino e o controle remoto (Playstation).

2.3 Materiais do carro

A utilização eletrônica do projeto, foram:

 Módulo NRF24L01
 Micro Servo (9g SG90 TP)
 Regulador de tenção (3,3v)
 1 Drive (DVD
 Resistor( 47, 100 e 1000 Ohm)

3 Disponível em: <https://www.electrofun.pt/comunicacao/modulo-rf-radiofrequencia-nrf24l01> .


Acessado em 17/10/2018
 CI Ponte H ( L298)
 Led (5 milimetros – 2 no total)
 Bateria ( 3 pilhas – 18650/ 2200mAh/3,7v)
 Capacitor eletrolítico (1000uF sup a 5v)
 Regulador de tenção (5v)
 Capacitor eletrolítico (47uF sup 12v)
 Led ( 3 milimetros – 7 no total)
Para uma melhor explicação de cada componente, como foi esquematizado o
projeto para o carro o seguinte circuito – Frequencia, Atuante e Alimentação:

Figura 8: Circuito Arduino

As baterias passam as energias altas de 12v, então usamos reguladores de tensão


para ajustar a voltagem das pilhas. No caso do arduino, temos o Servo e a Ponte H(
que foi utilizado para o Buzzer), que ficasse em menor voltagem, e alimentação com
a Bobina, para a filtragem de energia. Para o NRF24L01, foi utilizado o regulador
externo, podendo utilizar outro capacitador, dependendo do fabricante.
O Servomotor foi utilizado para realizar atuação robótica do carro(Servo2017), e
utilizados em projetos como o Arduino. Assim, enviado um sinal e verfica a posição
do eixo que se encontra, e foi o que buscávamos para a realização deste projeto.
Fonte: Servo2017(Figura 8)

2.4 Controle Remoto

Para os materiais que utilizamos no controle:


 Arduino Pro Mini
 Controle de videogame (PS2)
 Regulador de tensão
 Resistor ( 100 ohm)
 1 bateria (2200mAh/3,7v / 18650)
 Fios para soldar
 Buzzer (Passivo)

Pensamos em reduzir gastos e adaptações diferente de outros projetos, como na


figura abaixo demonstra(Using,2016):
Figura 9: Circuito arduino e controle PS2

Fonte: Using (2016)4

As adaptações foram bem diferentes, pois utilizando o NRF24L01 a bateria e outros


conjuntos para realizar o funcionamento do carrinho e retirando algumas partes do
controle.
Para a bateria utilizada de 7-12v, utilizamos a 18650, pois a sua voltagem é de 3,7v.
Para o Módulo NRF24, é necessário o capacitor e o regulador de tensão para
estabilizar o seu uso. A imagem demonstra o circuito do controle com Arduino e o
módulo NRF24L01:

Figura 9: Circuito Controle Arduino

Foi feito a ligação do arduino ao NRF24 e feito para o receptor, a transmissão foi
ligado pela bateria de 3,7volts. O fio da alimentação do Arduino para o pino VCC. O

4 Disponível em: <http://www.techmonkeybusiness.com/using-a-playstation-2-controller-with-your-


arduino-project.html>. Acesso em 15 out 2018.
eixo Y foi usado para a aceleração(JoyStick - A), controlado com a mão, o lado
esquerdo para realizar a ré e a frente para o carrinho. Já o eixo X(JoyStick – B), o
lado direito, com a função de controlar o lado direito e esquerdo da direção do
carrinho. E as bibliotecas para programação do Módulo NRF24L01 no site:
https://github.com/maniacbug/RF24
E para o controle: https://github.com/madsci1016/Arduino-PS2X

Figura 10: Comandos do controle


3. Estrutura do Carro

A construção do veículo, desde a estrutura e final, foram:

 Tubo de pirulito
 Capa plástica de DVD
 Espiral de encardenação
 Linha de croche
 Folha EVA -2cm
 Vareta de guarda-chuva
 Fio de cobre
 Garrafa de limpeza
 Lixa

Para a parte eletrônica do carrinho:

 1 Arduino mini 5v
 1 Drive de DVD
 1 Módulo NRF24L01
 1 Regular de tenção
 Resistor
 1 Micro Servo 9g
 1 Capacitador eletrolítico 47 uF sp/12v
 Bateria de notebook
 1 capacitador eletrolítico 1000uF sp/5v
 1 CI ponte H
 Fios para soldar
 2 Leds 5 milimetros
 7 Leds 3 milimetros
 4. Estrutura do carro
O projeto é parecido com o Kart Cross, desde amortecedores, arames e foi mudado
algumas partes:

Figura 11

Fonte: Kart Cross(2006)5

Foi pensado em pegar todos os materiais recicláveis para construir o carro, desde o
chassi com suporte forte para sustentar os objetos: Módulo NF24L01, Arduino Pro
mini. Assim, utilizamos as varetas de guarda-chuva e medimos o servo que ficasse
encaixado ao suporte, a direção e a asa traseira para ser colocado as pilhas.

Figura 12: Capa de Dvd - Chassi

5Disponível em: http://www.4x4brasil.com.br/forum/gaiola-baja-e-buggy/16900-kart-cross-com-motor-


da-cb400.html
Figura 13: Arames para o Carrinho

A espiral foi escolhido para amortecer, tanto o lado traseiro e a parte da frente.

Figura 14: Espiral de caderno

As rodas foi montados com papel EVA, mais estabilidade para rodar e ser um
diferencial.

Figura 15: Rodas de papel EVA

E a finalização da construção foi:

Figura 16: Carrinho quase finalizado


4. Relatório com as linhas de código
4.1 Transmissão

// Importando Bibliotecas

#include <SPI.h> // Biblioteca para comunicação SPI entre o módulo NRF24 e o


Arduino.

#include <RF24.h> // Biblioteca com as funções de controle do módulo NRF24.

#define JOYSTICK_X A0 // Declarando constante joystick_x como sendo porta


analogica A0 do Arduino

#define JOYSTICK_y A1 // Declarando constante joystick_y como sendo porta


analogica A1 do Arduino

const uint64_t pipe = 0xE8E8F0F0E1LL; //Configurando endereço de comunicação


entre os MÓDULOS. "LL" no final do endereço define a constante como sendo do
tipo "LongLong".

RF24 radio(9, 10); //Instanciando uma classe RF24 e informando que os pinos CE e
CSN do Módulo NRF24L01 estão ligados aos pinos digitais 9 e 10 do Arduino

struct Meujoystick { //Criando uma estrutura de dados que contem as variaveis do


tipo byte para cada função do controle remoto, no codigo do receptor foi criada uma
estrutura exatamente igual a esta para receber os dados.

byte Motor;

byte Re;

byte Direcao;

byte Buzzer;

byte Farol;

byte Seta_Direita;
byte Seta_Esquerda;

byte PiscaAlerta;

byte Luzes;

byte Sirene;

byte Iluminacao;

};

Meujoystick joystick; //declarando uma variavel do tipo Meujoystick (Estrutura que


contrem todas as variaveis que serão transmitidas para o receptor)

int VServo = 0;

int Acelera = 0;

int VDirecao = 0;

int VAcelera = 0;

int VRe = 0;

int auxAcelera = 0;

int VLuzes = 0;

int VSirene = 0;

int VIluminacao = 0;

// Declarando variaveis do tipo booleana e iniciando com o valor logico false (serão
usadas como auxilio para saber o valor anterios das variaveis que controlam os
botões)

boolean AuxVFarol = false;

boolean AuxVSetaD = false;

boolean AuxVSetaE = false;


boolean AuxVPiscaA = false;

boolean AuxVLuzes = false;

boolean AuxVSirene = false;

boolean AuxVIluminacao = false;

void setup()

Serial.begin(9600); //configurando a comunicação via porta serial à uma


velocidade de 9600bps(baud).

delay(1000);// aguardando um tempo em milissegundos.

Serial.println("Codigo TRANSMISSOR Nrf24L01"); // Imprimindo na tela via serial


o texto entre aspas

radio.begin(); //Inicialidando o MÓDULO RF24l01 para comunicação.

radio.setAutoAck(false); // Desativando pacotes ACK (Pacote de


Reconhecimento de Mensagem)

radio.setDataRate(RF24_250KBPS); // Configurando Módulo para operar em uma


taxa de 250kbps (Menor taxa de dados possível para um maior alcance do rádio)

radio.setPALevel(RF24_PA_MAX); // Configurando Módulo para transmitir em


potencia máxima

radio.powerUp(); // Ativando Módulo, caso entre em estado de baixo


consumo.

// Inicializando variaveis da struct Meujoystick com o valor 0

joystick.Motor = 0;

joystick.Re = 0;

joystick.Direcao = 0;
joystick.Buzzer = 0;

joystick.Farol = 0;

joystick.Seta_Direita = 0;

joystick.Seta_Esquerda = 0;

joystick.PiscaAlerta = 0;

joystick.Luzes = 0;

joystick.Sirene = 0;

joystick.Iluminacao = 0;

// declarando o modo de operação dos pinos digitais 0 a 7 do Arduino onde foram


ligados os pushboton do controle

pinMode(0, INPUT_PULLUP); // Define que o pino digital 0 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO TRIANGULO

pinMode(1, INPUT_PULLUP); // Define que o pino digital 1 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO X

pinMode(2, INPUT_PULLUP); // Define que o pino digital 2 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO QUADRADO

pinMode(3, INPUT_PULLUP); // Define que o pino digital 3 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO CIRCULO

pinMode(4, INPUT_PULLUP); // Define que o pino digital 4 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO SETA PARA CIMA

pinMode(5, INPUT_PULLUP); // Define que o pino digital 5 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO SETA PARA BAIXO

pinMode(6, INPUT_PULLUP); // Define que o pino digital 6 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO SETA PARA ESQUERDA

pinMode(7, INPUT_PULLUP); // Define que o pino digital 7 do arduino será uma


entrada com resistor pull up interno ativado. BOTÃO SETA PARA DIREITA
pinMode(8, OUTPUT); // Define que o pino digital 8 do arduino será uma saida
de sinal para acionar o Buzzer

Sirene(); // Chamando função Sirene que faz o buzzer emitir um som de sirene
(semelhante a ambulância) * Como esta fora do loop so ocorerá quando o Arduino
for ligado - usada para saber que esta tudo certo com o Arduino

void loop()

radio.stopListening(); // Interrompendo mecanismos de recpção "escuta" do Módulo

TX(); // Chamando a função TX responsavel pela transmissão dos dados

int Tensao_Bateria = readVcc(); // Chamando a função responsavel por fazer a


leitura da Tensão que chega ao arduino.

if(Tensao_Bateria < 3100){ // Aciona o buzzer se atensão estiver menor que 3,1
volts para indicar que a bateria esta fraca

tone(8,900,400);

void TX() // função criada para transmissão dos dados para o receptor

// Serial.println("Iniciando TRANSMICAO Nrf24L01"); // Imprimindo na tela via serial


o texto entre aspas

radio.openWritingPipe(pipe); // abrindo o meio de comunicação entre transmissor


e recptor com o mesmo endeço definido no ínicio do programa

VServo = analogRead(JOYSTICK_X); // Variavel VServo recebendo os valores


analogicos do potenciometro Eixo X do JoyStick da Direita (Controle de direção)
Acelera = analogRead(JOYSTICK_y); // Variavel Acelera recebendo os valores
analogicos do potenciometro Eixo Y do JoyStick da Esquerda (Controle de
Aceleração)

VDirecao = map (VServo, 0, 1023, 140, 40); // Convertendo valores analogicos


recebidos do Joystick entre 0 e 1023 para entre 40 e 140 para controle da Direção

joystick.Direcao = VDirecao; // Transferindo valores de direção já tratados para ser


enviados ao receptor

VAcelera = map (Acelera, 0, 1023, 0, 510); // Convertendo valores analogicos


recebidos do Joystick entre 0 e 1023 para entre 0 e 510 para controle da Aceleração

// Controlando Aceleração e sentido de rotação do motor de acordo com a


movimentação do eixo Y do JoyStick da Esquerda.

if (VAcelera < 230) {

VRe = 1;

auxAcelera = 255 - VAcelera;

if (auxAcelera > 245) {

auxAcelera = 255;

else if (VAcelera > 275) {

VRe = 0;

auxAcelera = VAcelera - 255;

if (auxAcelera > 245) {

auxAcelera = 255;

}
else {

auxAcelera = 0;

joystick.Re = VRe; // Transferindo indicador Ré ou Frente para ser enviado


ao receptor

joystick.Motor = auxAcelera; // Transferindo valores de aceleração já tratados para


ser enviados ao receptor

//botoes

// Farol

int VFarol = digitalRead(0); //Verifica se o botão "X" do joystick ligado a porta digital
0 do arduino foi pressionado

if (VFarol == LOW){

if(AuxVFarol == false){

AuxVFarol = true;

joystick.Farol = joystick.Farol + 1;

if(joystick.Farol > 1){

joystick.Farol = 0;

else{

AuxVFarol = false;

//Iluminação
int VIluminacao = digitalRead(5); //Verifica se o botão Seta para Baixo do joystick
ligado a porta digital 5 do arduino foi pressionado

if (VIluminacao == LOW){

if(AuxVIluminacao == false){

AuxVIluminacao = true;

joystick.Iluminacao = joystick.Iluminacao + 1;

if(joystick.Iluminacao > 1){

joystick.Iluminacao = 0;

else{

AuxVIluminacao = false;

//-> Direita

int VSetaD = digitalRead(3); // Verifica se o botão Circulo do joystick ligado a porta


digital 3 do arduino foi pressionado

if (VSetaD == LOW){

if(AuxVSetaD == false){

AuxVSetaD = true;

joystick.Seta_Direita = joystick.Seta_Direita + 1;

joystick.Seta_Esquerda = 0; // Se seta direita acende 1, seta esquerda a paga 0

if(joystick.Seta_Direita > 1){


joystick.Seta_Direita = 0;

else {

AuxVSetaD = false;

//Seta Esquerda

int VSetaE = digitalRead(2); // Verifica se o botão Quadrado do joystick ligado a


porta digital 2 do arduino foi pressionado

if (VSetaE == LOW){

if(AuxVSetaE == false){

AuxVSetaE = true;

joystick.Seta_Esquerda = joystick.Seta_Esquerda + 1;

joystick.Seta_Direita = 0; // Se seta esquerda acende 1, seta direita a paga 0

if(joystick.Seta_Esquerda > 1){

joystick.Seta_Esquerda = 0;

else{

AuxVSetaE = false;

}
//Pisca pisca

int VPiscaA = digitalRead(4); // Verifica se o botão Seta para Cima do joystick


ligado a porta digital 4 do arduino foi pressionado

if (VPiscaA == LOW){

if(AuxVPiscaA == false){

AuxVPiscaA = true;

joystick.PiscaAlerta = joystick.PiscaAlerta + 1;

joystick.Seta_Esquerda = 0; // Se seta PiscaAlerta acende 1, seta esquerda


apaga 0

joystick.Seta_Direita = 0; // Se seta PiscaAlerta acende 1, seta direita apaga 0

if(joystick.PiscaAlerta > 1){

joystick.PiscaAlerta = 0;

else{

AuxVPiscaA = false;

//Luzes ****

VLuzes = digitalRead(6); // Verifica se o botão Seta para Esquerda do joystick


ligado a porta digital 6 do arduino foi pressionado

if (VLuzes == LOW){

if(AuxVLuzes == false){

AuxVLuzes = true;
joystick.Luzes = joystick.Luzes + 1;

if(joystick.Luzes > 1){

joystick.Luzes = 0;

else{

AuxVLuzes = false;

//Buzina

VSirene = digitalRead(7); // Verifica se o botão Seta para Direita do joystick ligado a


porta digital 7 do arduino foi pressionado

if (VSirene == LOW){

if(AuxVSirene == false){

AuxVSirene = true;

joystick.Sirene = joystick.Sirene + 1;

if(joystick.Sirene > 1){

joystick.Sirene = 0;

else{

AuxVSirene = false;
}

//Buzzer

int VBuzzer = digitalRead(1); // Verifica se o botão Triangulo do joystick, ligado a


porta digital 1 do arduino foi pressionado

joystick.Buzzer = VBuzzer;

// Abaixo uma sequencia de linhas de código para imprimir na tela o valor da


variaveis que serão enviadas para o veículo, você pode retirar as barras // para
imprimir o valor da variavel que você tenha alguma dúvida

//Serial.print(" Motor: ");

//Serial.println(joystick.Motor); // Escreve na tela via serial o valor recebido. Pode


ser usado para debug

// Serial.print(" Re: ");

// Serial.println(joystick.Re); // Escreve na tela via serial o valor recebido. Pode


ser usado para debug

//Serial.print(" Direcao: ");

//Serial.println(joystick.Direcao); // Escreve na tela via serial o valor recebido.


Pode ser usado para debug

//Serial.print(" Buzzer: ");

//Serial.println(joystick.Buzzer); // Escreve na tela via serial o valor recebido.


Pode ser usado para debug

//Serial.print(" Farol: ");

//Serial.println(joystick.Farol); // Escreve na tela via serial o valor recebido.


Pode ser usado para debug

//Serial.print("Seta_Direita: ");
//Serial.println(joystick.Seta_Direita); // Escreve na tela via serial o valor
recebido. Pode ser usado para debug

//Serial.print("Seta_Esquerda: ");

//Serial.println(joystick.Seta_Esquerda); // Escreve na tela via serial o valor


recebido. Pode ser usado para debug

//Serial.print(" PiscaAlerta: ");

//Serial.println(joystick.PiscaAlerta); // Escreve na tela via serial o valor recebido.


Pode ser usado para debug

//Serial.print(" Luzes: ");

//Serial.println(joystick.Luzes); // Escreve na tela via serial o valor recebido. Pode


ser usado para debug

//Serial.print(" Sirene: ");

//Serial.println(joystick.Sirene); // Escreve na tela via serial o valor recebido.


Pode ser usado para debug

// Transmitindo variaveis, este comando foi repetido 30 vezes para corrigir erros
que possam ocorer na transmição desta forma consigui-se um maior alcance com
maior confiabilidade (esta repetição é necessária pois o ACK foi desativado)

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );


radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

radio.write( &joystick, sizeof(joystick) );

}
// Função responsavel por fazer a leitura da Tensão que chega ao arduino.

int readVcc()

// Ler referência interna 1.1V

// Ajusta a referência ao Vcc e a medição de referência interna para 1.1V

#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) ||


defined(__AVR_ATmega2560__)

ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);

#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) ||


defined(__AVR_ATtiny84__)

ADMUX = _BV(MUX5) | _BV(MUX0);

#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) ||


defined(__AVR_ATtiny85__)

ADMUX = _BV(MUX3) | _BV(MUX2);

#else

ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);

#endif

delay(2); // Aguarde

ADCSRA |= _BV(ADSC); // Inicia a conversão

while (bit_is_set(ADCSRA,ADSC)); // Medindo

uint8_t low = ADCL; // Vai ler ADCL primeiro - Então trava ADCH

uint8_t high = ADCH; // Desbloqueia

int result = (high<<8) | low;

result = 1125300L / result; // Calcular Vcc em milivolts; 1125300 = 1.1*1023*1000


return result; // Vcc em milivolts

void Sirene(){ // Função Sirene faz com que o buzzer emita um som de sirene
(semelhante a ambulância)

int frequencia = 0;

for(frequencia = 150;frequencia < 1800;frequencia +=1){

tone(8,frequencia,10);

delay(1);

for(frequencia = 1800 ;frequencia > 100;frequencia -=1){

tone(8,frequencia,10);

delay(1);

for(int temp = 0;temp < 15;temp ++){

for(frequencia = 150;frequencia < 1800;frequencia +=40){

tone(8,frequencia,10);

delay(1);

for(frequencia = 1800 ;frequencia > 150;frequencia -=40){

tone(8,frequencia,10);

delay(1);

}
}

// FIM

5.2 Recepção
// Importando Bibliotecas
#include <SPI.h> // Biblioteca para comunicação SPI entre o módulo NRF24 e
o Arduino.
#include <RF24.h> // Biblioteca com as funções de controle do módulo NRF24.
#include <Servo.h> // Biblioteca com as funções de controle do Servo Motor.

uint32_t amostra_tempo; // Declarando variável Global para armazenar o tempo


da função millis

Servo myservo; // Criando um objeto do tipo Servo para controle do Servo Motor

const uint64_t pipe = 0xE8E8F0F0E1LL; //Configurando endereço de


comunicação entre os MÓDULOS. "LL" no final do endereço define a constante
como sendo do tipo "LongLong".

RF24 radio(9, 10); //Instanciando uma classe RF24 e informando que os pinos
CE e CSN do Módulo NRF24L01 estão ligados aos pinos digitais 9 e 10 do
Arduino

struct Meujoystick { //Criando uma estrutura de dados que contem as variaveis


do tipo byte para cada função do controle remoto, no codigo do transmissor foi
criada uma estrutura exatamente igual a esta para transmitir os dados.
byte Motor;
byte Re;
byte Direcao;
byte Buzzer;
byte Farol;
byte Seta_Direita;
byte Seta_Esquerda;
byte PiscaAlerta;
byte Luzes;
byte Sirene;
byte Iluminacao;
};

Meujoystick joystick; //declarando uma variavel do tipo Meujoystick (Estrutura


que contrem todas as variaveis transmitidas pelo controle remoto )

// Declarando variaveis e niciando variaveis com valor 0, estas variáveis


receberão os valores enviados pelo controle remto.
byte VMotor = 0; // Variavel que aciona o motor, seu valor vai de 0 a 255
de acordo com a posição do joystick de aceleração
byte VRe = 0; // Variavel que controla a Ré do veículo atravez da
ponte H, seu valor é 0 ou 1, Ré ou Frente
byte VDirecao = 0; // Variavel que controla o servo motor da direção, seu
valor ficar entre 40 e 140
byte VBuzzer = 0; // Variavel que controla o buzzer, buzina do veículo,
seu valor é 0 ou 1
byte VFarol = 0; // Variavel que controla os Leds do farol, seu valor e 0
ou 1
byte VSeta_Direita = 0; // Variavel que controla os Leds da seta direita, seu
valor e 0 ou 1
byte VSeta_Esquerda = 0; // Variavel que controla os Leds da seta esquerda,
seu valor e 0 ou 1
byte VPiscaAlerta = 0; // Variavel que controla os Leds das setas direita e
esquerda ao mesmo tempo, seu valor e 0 ou 1
byte VLuzes = 0; // Variavel que controla todos os Leds piscando-os
auternadamente, seu valor e 0 ou 1
byte VSirene = 0; //Variavel que controla o buzzer, emitindo som de
sirene, seu valor é 0 ou 1
int VIluminacao = 0; // Variavel que controla os Leds de iluminação do
veículo, seu valor e 0 ou 1
//int Temp = 0;

void setup()
{
Serial.begin(9600); //configurando a comunicação via porta serial à uma
velocidade de 9600bps(baud).

delay(1000); //aguardando um tempo em milissegundos.

Serial.println("Codigo RECEPTOR Nrf24L01"); //Imprimindo na tela via serial o


texto entre aspas

pinMode(2, OUTPUT); // configurando o pino Digital 2 do Arduino como saida


de dados, ele irá acender os Leds dos Faróis
pinMode(3, OUTPUT); // configurando o pino Digital 3 do Arduino como saida
de dados, ele irá controlar o Servo Motor
pinMode(4, OUTPUT); // configurando o pino Digital 4 do Arduino como saida
de dados, ele irá controlar o Buzzer
pinMode(5, OUTPUT); // configurando o pino Digital 5 do Arduino como saida
de dados, ele irá controlar uma das entrada da Ponte H
pinMode(6, OUTPUT); // configurando o pino Digital 6 do Arduino como saida
de dados, ele irá controlar a outra entrada da Ponte H
pinMode(7, OUTPUT); // configurando o pino Digital 7 do Arduino como saida
de dados, ele irá controlar os Leds da seta direita
pinMode(8, OUTPUT); // configurando o pino Digital 8 do Arduino como saida
de dados, ele irá controlar os Leds da seta esquerda
pinMode(A0, OUTPUT); // configurando o pino Analogico A0 do Arduino como
saida de dados, nele deve ser ligado os leds responsaveis pela iluminação do
veículo (as portas analógicas também podem ser utilizada para acesnder leds) )

radio.begin(); //Inicialidando o MÓDULO RF24l01 para comunicação.


radio.setAutoAck(false); // Desativando pacotes ACK (Pacote de
Reconhecimento de Mensagem)
radio.setDataRate(RF24_250KBPS); // Configurando Módulo para operar em
uma taxa de 250kbps (Menor taxa de dados possível para um maior alcance do
rádio)
radio.setPALevel(RF24_PA_MAX); // Configurando Módulo para transmitir em
potencia máxima (a titulo de conhecimento, pois aqui o radio esta configurado
apenas como receptor)
radio.powerUp(); // Ativando Módulo, caso entre em estado de baixo
consumo.
radio.startListening(); //Inicializando o MÓDULO para 'escutar' as
requisições enviadas pelo transmissor.

Sirene_Lenta(); // Chamando função Sirene_Lenta que faz o buzzer emitir um


som de sirene (semelhante a ambulância) * Como esta fora do loop so ocorerá
quando o Arduino for ligado - usada para saber que esta tudo certo com o
Arduino
for (int t = 0; t < 15; t ++) {
Sirene_Rapida(); // Chamando função Sirene_Rapida que faz com que o
buzzer emita um som de sirene (semelhante a carro de polícia) A função dentro
de um "for" para que repita 15 fezes este som
}
digitalWrite(2, HIGH); // as linas abaixo fazem com que os leds dos faróis
e iluminação pisquem ao ligar o Arduino
digitalWrite(A0, HIGH);
delay(300);
digitalWrite(2, LOW);
digitalWrite(A0, LOW);
delay(300);
digitalWrite(2, HIGH);
digitalWrite(A0, HIGH);
delay(300);
digitalWrite(2, LOW);
digitalWrite(A0, LOW);
}

void loop()
{
radio.startListening(); // Reforçando a inicialização de 'escuta'
myservo.attach(3); // Atribou servo ao pino digital 03 do arduino
RX(); // Chamando a função RX responsavel pela recpção dos dados

void RX() // função criada para recepção dos dados enviados pelo transmissor
{
Serial.println(" Iniciando Recepcao Nrf24L01"); // Imprimindo na tela via serial o
texto entre aspas
radio.openReadingPipe(1, pipe); // abrindo o meio de comunicação entre
transmissor e recptor com o mesmo endeço definido no ínicio do programa

if ( radio.available() ) //verificando se há dados enviados pelo tranmissor.


{

boolean sinal = false;


while (!sinal) // Enquanto a variavel sinal for diferente de falso significa que os
dados estão sendo recebidos corretamente
{

sinal = radio.read( &joystick, sizeof(joystick) ); // Recebendo dados enviado


pelo transmissor
VMotor = joystick.Motor; // As variaveis declaradas acima estão
recebendo os dados enviado pelo tranmissor e que vieram encapsulados na
struct Meujoystick
VRe = joystick.Re;
VDirecao = joystick.Direcao;
VBuzzer = joystick.Buzzer;
VFarol = joystick.Farol;
VSeta_Direita = joystick.Seta_Direita;
VSeta_Esquerda = joystick.Seta_Esquerda;
VPiscaAlerta = joystick.PiscaAlerta;
VLuzes = joystick.Luzes;
VSirene = joystick.Sirene;
VIluminacao = joystick.Iluminacao;

// Frente, Ré e Aceleração, controla a ponte H invertendo suas duas entradas


de acordo com o valor da variável VRe
if (VRe == 1) {
analogWrite(5, VMotor);
analogWrite(6, LOW);
}
else {
analogWrite(5, LOW);
analogWrite(6, VMotor);
}

// Direção, controla a posição que o braço de servo motor vai ficar de acordo
com os valores da variavel VDireção
myservo.write(VDirecao);

// Buzina, aciona o buzzer produzindo som de acordo com o valor da variavel


VBuzzer
if (VBuzzer != 1) {
tone(4, 600);
} else {
noTone(4);
}
// Farol, acende e apagar os leds dos faróis de acordo com o valor da variavel
VFarol
if (VFarol == 1) {
digitalWrite(2, HIGH);
}
else {
digitalWrite(2, LOW);
}

// Iluminação, acende e apagar os leds de iluminação do veículo de acordo


com o valor da variavel VIluminacao
if (VIluminacao == 1) {
digitalWrite(A0, HIGH);
}
else {
digitalWrite(A0, LOW);
}

// Seta Direita, faz os leds da seta direita piscarem ou não, de acordo com o
valor da variavel VSeta_Direita
digitalWrite(7, LOW);
if (VSeta_Direita == 1) {
if (millis() - amostra_tempo > 400) { // função millis no if faz acontagem de
tempo que a seta deve ficar acesa
digitalWrite(7, HIGH);
}
if (millis() - amostra_tempo > 750) { // função millis no if faz acontagem de
tempo que a seta deve ficar apagada
digitalWrite(7, LOW);
amostra_tempo = millis();
}
}

// Seta Esquerda, faz os leds da seta esquerda piscarem ou não, de acordo


com o valor da variavel VSeta_Esquerda
digitalWrite(8, LOW);
if (VSeta_Esquerda == 1) {
if (millis() - amostra_tempo > 400) { // função millis no if faz acontagem de
tempo que a seta deve ficar acesa
digitalWrite(8, HIGH);
}
if (millis() - amostra_tempo > 750) { // função millis no if faz acontagem de
tempo que a seta deve ficar apagada
digitalWrite(8, LOW);
amostra_tempo = millis();
}
}

// Pisca Alerta, faz os leds das setas direita e esquerda piscarem juntos ou
não, de acordo com o valor da variavel VPiscaAlerta
if (VPiscaAlerta == 1) { // Pisca Alerta

if (millis() - amostra_tempo > 400) { // função millis no if faz acontagem de


tempo que as setas devem ficar acesas
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
}
if (millis() - amostra_tempo > 750) { // função millis no if faz acontagem de
tempo que as setas devem ficar apagadas
digitalWrite(7, LOW);
digitalWrite(8, LOW);
amostra_tempo = millis();
}
}

// Luzes, faz todos os leds do veículo piscarem ou não, de acordo com o valor
da variavel VLuzes
if (VLuzes == 1) {
Luzes () ;
}

// Sirene, aciona o buzzer produzindo som de sirena de acordo com o valor


da variavel VSirene
if (VSirene == 1) { // Sirene 2
Sirene_Rapida ();
}

// Abaixo seque um seria de prints que serviram para debug, você deve
descomentar (retirar as //) das duas linhas responsaveis por imprimir no monitor
serial o valor da variavel.
//Serial.print(" Motor: ");
//Serial.println(VMotor); // Escreve na tela via serial o valor recebido. Pode
ser usado para debug

//Serial.print(" Re: ");


//Serial.println(VRe); // Escreve na tela via serial o valor recebido. Pode ser
usado para debug

//Serial.print(" Direcao: ");


//Serial.println(VDirecao); // Escreve na tela via serial o valor recebido.
Pode ser usado para debug

//Serial.print(" Buzzer: ");


//Serial.println(VBuzzer); // Escreve na tela via serial o valor recebido.
Pode ser usado para debug

//Serial.print(" Farol: ");


//Serial.println(VFarol); // Escreve na tela via serial o valor recebido. Pode
ser usado para debug

//Serial.print("Seta_Direita: ");
//Serial.println(VSeta_Direita); // Escreve na tela via serial o valor recebido.
Pode ser usado para debug
//Serial.print("Seta_Esquerda: ");
//Serial.println(VSeta_Esquerda); // Escreve na tela via serial o valor
recebido. Pode ser usado para debug

//Serial.print(" PiscaAlerta: ");


//Serial.println(VPiscaAlerta); // Escreve na tela via serial o valor recebido.
Pode ser usado para debug

//Serial.print(" Luzes: ");


//Serial.println(VLuzes); // Escreve na tela via serial o valor recebido. Pode
ser usado para debug

//Serial.print(" Sirene: ");


//Serial.println(VSirene); // Escreve na tela via serial o valor recebido. Pode
ser usado para debug

}
}
else // Se nao existir dados enviados pelo transmissor ou o receptor por algum
problema não conseguir recebelos
{
radio.stopListening(); // Interrompendo mecanismos de recpção "escuta" do
Módulo
Serial.println("Sem Sinal do Radio: Verifique se o transmissor esta ligado"); //
Imprimindo na tela via serial o texto entre aspas

if (millis() - amostra_tempo > 2000) { // Se passarem mais de 3 segundos sem


conexão com o transmissor os motores são desligados automaticamente para
evitar que o veículo ande sem controle
tone(4, 300, 100);
digitalWrite(5, LOW);
digitalWrite(6, LOW);
amostra_tempo = millis();
}
}
}

void Sirene_Lenta() { // Função Sirene_Lenta que faz com que o buzzer emita
um som de sirene (semelhante a ambulância)
int frequencia = 0;

digitalWrite(7, LOW);
digitalWrite(8, LOW);

for (frequencia = 100; frequencia < 2000; frequencia += 1) {


tone(4, frequencia, 10);
//delay(1);
}
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);

for (frequencia = 2000 ; frequencia > 100; frequencia -= 1) {


tone(4, frequencia, 10);
//delay(1);
}
digitalWrite(7, LOW);
digitalWrite(8, LOW);
}
void Sirene_Rapida() { //Função Sirene_Rapida que faz com que o buzzer
emita um som de sirene (semelhante a um carro de polícia)
int frequencia = 0;

digitalWrite(7, HIGH);
digitalWrite(8, HIGH);

for (frequencia = 150; frequencia < 1800; frequencia += 40) {


tone(4, frequencia, 10);
delay(1);
}
digitalWrite(7, LOW);
digitalWrite(8, LOW);

for (frequencia = 1800 ; frequencia > 150; frequencia -= 40) {


tone(4, frequencia, 10);
delay(1);
}
}

void Luzes() { // A função Luzes faz todas as luzes do veículo piscarem


auternadamente
if (millis() - amostra_tempo > 200) {
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(A0, LOW);
digitalWrite(2, LOW);
}
if (millis() - amostra_tempo > 400) {
digitalWrite(7, LOW);
digitalWrite(8, LOW);
digitalWrite(A0, HIGH);
digitalWrite(2, HIGH);
}
if (millis() - amostra_tempo > 600) {
digitalWrite(7, HIGH);
digitalWrite(8, HIGH);
digitalWrite(A0, LOW);
digitalWrite(2, LOW);
amostra_tempo = millis();
}
}
//FIM

BIBLIOGRAFIA:

Abbade., G. d. (2012). A Gestão de Projetos Sustentáveis: O caso América Latina


Logística. 5(15).
CMMAD – Comissão Mundial sobre Meio Ambiente e Desenvolvimento. Nosso futuro
comum. 2a ed. Tradução de Our common future. 1a ed. 1988. Rio de Janeiro : Editora
da Fundação Getúlio Vargas, 1991.
Ferreira, A.B.H ( Coord.). Novo dicionário da lígua portuguesa. 2ed. Rio de
Janeiro: Nova Fronteira, 1986. (FERREIRA, 1986)

SOUZA, DAQUES, TEDESCO,AKIRA, Wilque, Ana, Gilberto, Walter. Carrinho


controlado por Celular Android 2013. 29f. Trabalho de conclusão do curso técnico
em Telecomunicações – Centro Paula Souza, 2013.

SMIDT, André Crepaldi Geiger. Implementação de uma Plataforma Robótica


controlada remotamente utilizando o Arduino – Junho 2013. 82f. Trabalho de
conclusão do curso – Universidade de São Paulo, São Carlos 2013.

SITES:

Arduino e Cia – Faça você mesmo – Comunicação wireless com Arduino e módulo
NRF24L01 – < https://www.arduinoecia.com.br/2015/02/comunicacao-wireless-
arduino-nrf24l01.html> – 19 fev 2015 – Acesso 15 out 2018
Arduino Uno REV3 – Arduino Uno – Overview / Tech Specs –
<https://store.arduino.cc/arduino-uno-rev3> – Acesso 15 out 2018

Buggy – Faça você mesmo – Enciclopédia de tecnologias e Métodos –


http://patlah.ru/etm/etm-24/baggi/baggi-1/baggi.htm – 1993 – 1997 - Acesso 10 out
2018
Download the Arduino IDE – Arduino 1.8.7 –
<https://www.arduino.cc/en/Main/Software> – Acesso 15 out 2018

ERNESTO ROSE – Ricardo – Plástico: a grande ameaça dos oceanos – 2018 –


http://www.administradores.com.br/artigos/cotidiano/plastico-a-grande-ameaca-dos-
oceanos/111089/ – 03/10/2018

Glösser. (2013). Procobre.org. (Cooper Alliance) Fonte: Procobre:


https://www.procobre.org/pt/noticias/cobre-contribuindo-para-um-mundo-mais-
sustentavel/
Gomes, R. (25 de 09 de 2017). Rede Brasil Atual. (RBA) Fonte: Rede Brasil Atual:
https://www.redebrasilatual.com.br/politica/2017/09/apos-dois-anos-brasil-
nao-realizou-qualquer-acao-para-alcancar-objetivos-da-onu
Kart Cross com Motor da CB400 - 22 abril 2006 - <
http://www.4x4brasil.com.br/forum/gaiola-baja-e-buggy/16900-kart-cross-com-motor-
da-cb400.html> . Acessado 15/10/2018

Kart Cross Força Livre – 3d Catarinense – 2016 –


<http://3dcatarinense.blogspot.com/2016/07/kart-cross-forca-livre.html> –
01/10/2018
O que é um servo motor? - Controlando um Servo motor com Arduino – 14 maio
2017 – <https://portal.vidadesilicio.com.br/o-que-e-servomotor/> Acessado 1 de
Outubro.
ONUBR. (8 de 1 de 2018). OnuBr. (ONUBR) Fonte: Nações Unidas no Brasil:
https://nacoesunidas.org/brasil-avancou-em-2017-formulacao-politicas-
objetivos-globais/
Projeto kart Cross, Gaiola, buggy. Shopja. Disponível em: <
http://shopja.com.br/enventa-projeto-kart-cross-gaiola-buggy-frete-
gratis_SPB704665265>. Acesso em: 25 set. 2018.

Rose, R. E. (2018). Plástico: a grande ameaça dos oceanos. 23 de junho.


temas, O. (7 de 10 de 2011). Idec. Fonte: Idec - Instituto de defesa e consumidor:
https://idec.org.br/consultas/dicas-e-direitos/entenda-por-que-pilhas-e-
baterias-nao-podem-ser-descartadas-nos-lixos-comuns

Glösser. (2013). Procobre.org. (Cooper Alliance) Fonte: Procobre:


https://www.procobre.org/pt/noticias/cobre-contribuindo-para-um-mundo-mais-
sustentavel/
Gomes, R. (25 de 09 de 2017). Rede Brasil Atual. (RBA) Fonte: Rede Brasil Atual:
https://www.redebrasilatual.com.br/politica/2017/09/apos-dois-anos-brasil-
nao-realizou-qualquer-acao-para-alcancar-objetivos-da-onu
ONUBR. (8 de 1 de 2018). OnuBr. (ONUBR) Fonte: Nações Unidas no Brasil:
https://nacoesunidas.org/brasil-avancou-em-2017-formulacao-politicas-
objetivos-globais/
Rose, R. E. (2018). Plástico: a grande ameaça dos oceanos. 23 de junho.
temas, O. (7 de 10 de 2011). Idec. Fonte: Idec - Instituto de defesa e consumidor:
https://idec.org.br/consultas/dicas-e-direitos/entenda-por-que-pilhas-e-
baterias-nao-podem-ser-descartadas-nos-lixos-comuns
Using a Playstation 2 Controller with your Arduino Project – 16 maio 2016
<http://www.techmonkeybusiness.com/using-a-playstation-2-controller-with-your-
arduino-project.html> Acessado 15 out 2018.
(Gomes, 2017)Formulário de Avaliação
(2018)

Carro elétrico
Professores Avaliadores

Integrantes
R.A Nome do Aluno Turma

1
2
3
4
5
6
7
8
9
10

Critérios de Avaliação
Normas de construção (1,0) Observações:
Criatividade, Inovação e (1,0)
Acabamento
Zigue-zague (2,0)
Ré (2,0)
Total da avaliação (6,0)