Veículo Terrestre Não Tripulado (UGV) ou Spycar

June 13, 2024 Roberto Magalhães

Sobre este projeto

eu desenvolvi Veículo Terrestre Não Tripulado (UGV) – a veículo de 4 rodas controlado por rádio, que possuem 6 movimentos diferentes. Nesta plataforma de 4 rodas podemos montar uma câmera sem fio e usando o feedback de vídeo em um PC, podemos dirigir o veículo de um local distante. Podemos controlar o dispositivo através de uma GUI atraente rodando no PC.

Projetei a parte de hardware da forma mais simples possível. ATMEGA328 na placa Arduino pro-mini é usado para controlar o veículo. A codificação é feita no Arduino IDE e o PROCESSING é usado para desenvolver uma GUI.

Pode ser usado para trabalho de espionagem e daí o nome ESPIÃO.

Características

Rádio-controlado

Movimento em 6 direções

Placa Arduino pro-mini é usada

Controle de um PC usando GUI

Poderoso o suficiente para transportar câmera sem fio, microfone, etc.

HARDWARE

Diagrama de bloco:

Motores e ponte H

Motores

É usado um motor comum de 5V DC. Neste veículo específico, os motores são montados na traseira e cada um deles aciona uma das rodas dianteiras por meio de uma transmissão separada. Este sistema ajuda a virar o veículo para a esquerda ou direita usando a ponte H. Forneci alimentação separada de 9 V para os motores.

Ponte H

Quatro relés de 5 V e alguns outros componentes são usados para realizar uma ponte H. Um número máximo de 3 relés são necessários para serem acionados a qualquer momento.

Diagrama do circuito da ponte H:

Os quatro relés são acionados usando IC de acionamento de relé comum, ULN2004.

Diagrama do circuito de acionamento do relé:

Fonte de energia

Fonte de energia

Usei mais de uma bateria de 9V conectada em paralelo. Também podemos usar bateria separada para o motor, se necessário.

Diagrama do circuito da fonte de alimentação

Placa Arduino

Placa Arduino

A placa Arduino pro-mini é usada para controlar o circuito. A placa possui controlador ATMEGA328 junto com os componentes necessários.

Usei os pinos 5, 6, 7 e 8, que são pinos de E/S digital para controlar a ponte H. O pino número 13 está conectado internamente na placa a um LED que utilizamos como indicador de recepção de dados. O pino RX1 é usado para receber os dados seriais do receptor RF.

Diagrama de circuito da placa Arduino

Receptor RF

Receptor RF

Usei um par de módulos RF, no qual o módulo receptor é o RWS 434. Ele funciona em 430 MHz e fornece saída TTL no pino 2. Ele pode ser facilmente interligado com o Arduino.

Diagrama do circuito do receptor

Conversor USB para TTL

Eu usei o conversor FTDI usb para ttl que vem do sparkfun. O mesmo também é usado para carregar o programa na placa Arduino.

Transmissor RF

Transmissor RF

Usei o módulo transmissor TWS434. Funciona em 430MHz e permite transmitir dados seriais recebidos no pino 2 a uma distância máxima de 30 metros. Funciona em dados seriais TTL a uma taxa de transmissão máxima de 1200bps.

Diagrama do circuito do transmissor

Componentes

Lista de componentes e especificações

Bateria ——————————————- 9V, 1 nos.

Regulador IC —————————————- 7805, 1 nos.

Capacitor ——————————————- 1000mfd, eletrólito, 2 nos.

Diodo ———————————————— 1N4007, 4 nos.

Resistor ——————————————— 1KE, 0,25W, 1 nos.

LED ———————————————— 3mm, Vermelho, 1 nos.

Relé ———————————————- 5V, tipo cubo de açúcar, 4 nos.

Motor ——————————————— 5V, motor DC, 2 nos.

Transmissor ——————————————– Módulo transmissor RF, ASK, TWS 434, 1 nos.

Receptor ——————————————— Módulo receptor RF, ASK, RWS 434, 1 nos.

Conversor USB para TTL ——————————- Placa de interrupção USB FTDI, Sparkfun, 1 nos.

Placa Arduino —————————————- Arduino pro-mini, 5V, 1 nos.

Botão clicado e imagens

Botão clicado Personagem transmitido

Avançar —————————– '8'

Para trás ————————— '2'

Avançar para a esquerda ———————— '7'

Avançar para a direita ———————- '9'

Para trás à esquerda ———————- '1'

Para trás à direita ——————– '3'

As imagens a seguir devem ser salvas na mesma pasta do projeto junto com o código.

principal.jpg

avançar.jpg

para trás.jpg

avançar para a esquerda.jpg

avançar para a direita.jpg

para trás à esquerda.jpg

para trás à direita.jpg

Na maioria das vezes é necessário um pequeno ajuste no código. Como não temos a opção de selecionar o número da porta do dispositivo, precisamos editar o número da porta no código.

println(Serial.list ); exibir uma lista de portas seriais presentes

Por exemplo:

Se com21 for a porta do meu dispositivo, que posso encontrar no gerenciador de dispositivos. Agora eu uso (2) na seguinte linha do código

String portName = Serial.list (2);

Imagens do projeto

As imagens do projeto

Vídeo

Código-fonte do projeto

###


Código Arduino
O código continuamente verifica a recepção de qualquer um dos bytes de dados predefinidos.  Se um for encontrado, as alterações correspondentes serão feitas 
os valores lógicos dos pinos de saída.
#define Odata 13
#defineOfront8
#define Oleft 7
#define Certo 6
#define Oback 5
 
int inByte = 0;                                         //byte serial de entrada
 
configuração nula 
{
      pinMode(Odata, SAÍDA);   
      pinMode(Ofront, SAÍDA);   
      pinMode(Oleft, SAÍDA);   
      pinMode(Oright, OUTPUT);   
      pinMode(Oback, SAÍDA);   
      
      digitalWrite(Ofront, ALTO);
      digitalWrite(Oleft, HIGH);
      digitalWrite (Certo, ALTO);                    
      digitalWrite(Oback, ALTO);  
      digitalWrite(Odata, LOW);                  //Para indicar recepção de dados      
      
      Serial.begin(1200);                        //inicia a porta serial em 9600 bps:   
}
 
loop vazio 
{
      if (Serial.available  > 0) // se obtivermos um byte válido
      {
              inByte = Serial.read ;            //obtém o byte recebido:
              digitalWrite(Odata, ALTO);     //Para indicar recepção de dados
              atraso(10);
              
              se (inByte == '8')
              {
                    //------- avançar---------//
                    digitalWrite(Ofront, LOW);  
                    digitalWrite(Oleft, LOW);
                    digitalWrite (O certo, BAIXO);
                    digitalWrite(Oback, ALTO);            
                    atraso(1000);               
              }
              senão se (inByte == '2')
              {
                    //------- para trás---------//
                    digitalWrite(Ofront, ALTO);  
                    digitalWrite(Oleft, LOW);
                    digitalWrite (O certo, BAIXO);
                    digitalWrite(Oback, BAIXO);            
                    atraso(1000);
              }
              senão se (inByte == '7')   
              {
                    //-----avançar para a esquerda--------//
                    digitalWrite(Ofront, LOW);  
                    digitalWrite(Oleft, HIGH);
                    digitalWrite (O certo, BAIXO);
                    digitalWrite(Oback, ALTO);            
                    atraso(1000);           
              }
              senão se (inByte == '9')   
              {
                    //-----avançar para a direita------//
                    digitalWrite(Ofront, LOW);  
                    digitalWrite(Oleft, LOW);
                    digitalWrite (Certo, ALTO);
                    digitalWrite(Oback, ALTO);            
                    atraso(1000);           
              }    
              senão se (inByte == '1')   
              {
                    //-----para trás para a esquerda--------//
                    digitalWrite(Ofront, ALTO);  
                    digitalWrite(Oleft, HIGH);
                    digitalWrite (O certo, BAIXO);
                    digitalWrite(Oback, BAIXO);            
                    atraso(1000);           
              }
              senão se (inByte == '3')   
              {
                    //-----para trás para a direita------//
                    digitalWrite(Ofront, ALTO);  
                    digitalWrite(Oleft, LOW);
                    digitalWrite (Certo, ALTO);
                    digitalWrite(Oback, BAIXO);            
                    atraso(1000);           
              }outro;
      }
      outro
      {   
                    //-----Nenhum movimento-----//
                    digitalWrite(Ofront, ALTO);
                    digitalWrite(Oleft, HIGH);
                    digitalWrite (Certo, ALTO);                    
                    digitalWrite(Oback, ALTO);   
      }        
}
 
Código de processamento
Usei o PROCESSING para desenvolver uma GUI.  O código a seguir identifica em qual tecla o usuário pretendia clicar, com base na posição do ponteiro do mouse no momento do clique do mouse.  O código então envia o byte de dados correspondente para a porta USB a uma taxa de transmissão de 1200.
 
processamento de importação.serial.*;
 
Serial myPort;  
 
PImagem principal;
PImage forward;
PImagem para trás;
PImagem para a frente à esquerda;
PImage à direita;
PImagem reversa à esquerda;
PImagem invertida à direita;
 
 
int flagpress = 0;
 
configuração nula  
{
    tamanho(360, 204);                                        //Definindo o tamanho da janela
    
    //-------------- Carregando as imagens -------------------//
    main = loadImage("main.jpg");
    forward = loadImage("forward.jpg");
    para trás = loadImage("backward.jpg");
    forwardleft = loadImage("avançar para a esquerda.jpg");
    forwardright = loadImage("avançar direita.jpg");
    reverseleft = loadImage("para trás à esquerda.jpg");
    inverterright = loadImage("para trás à direita.jpg");
    //------------------------------------------------ ----//
    println(Serial.list );                               //Listando as portas seriais atuais
    //----------- Configurando os detalhes da porta --------------- //
    String portName = Serial.list (2);
    minhaPorta = new Serial(this, portName, 1200);
    //------------------------------------------------ ----//
    
}
 
sorteio nulo  
{
    imagem(principal, 0, 0);                                    // Exibe a imagem "main.jpg"
    
    if(mousePressed) // Verificando um clique do mouse
    {
          if( ( (141 < mouseX ) && (mouseX < 182) ) && ( (24 < mouseY ) && (mouseY < 41) ) )  
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem(avançar, 0, 0);                       // Exibe a imagem "forward.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('8');                      // Envia o caracter '8' para a porta USB
                  
              flagpress = 1;
              
          }
              
          if( ( (141 < mouseX ) && (mouseX < 182) ) && ( (117 < mouseY ) && (mouseY < 133) ) )  
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem(para trás, 0, 0);                      // Exibe a imagem "backward.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('2');                      // Envia o caracter '2' para a porta USB
                  
              flagpress = 1;
              
          }
          
          if( ( (74 < mouseX ) && (mouseX < 116) ) && ( (24 < mouseY ) && (mouseY < 41) ) )     
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem(avançar à esquerda, 0, 0);                    // Exibe a imagem "forwardleft.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('7');                       // Envia o caracter '7' para a porta USB
                  
              flagpress = 1;
              
          }
          
          if( ( (204 < mouseX ) && (mouseX < 246) ) && ( (24 < mouseY ) && (mouseY < 41) ) )     
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem(forwardright, 0, 0);                    // Exibe a imagem "forwardright.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('9');                        // Envia o caracter '9' para a porta USB
                  
              flagpress = 1;
              
          }
          
          if( ( (74 < mouseX ) && (mouseX < 116) ) && ( (117 < mouseY ) && (mouseY < 133) ) )    
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem (reverso à esquerda, 0, 0);                      // Exibe a imagem "reverseleft.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('1');                         // Envia o caracter '1' para a porta USB
                  
              flagpress = 1;
              
          }
          
          if( ( (204 < mouseX ) && (mouseX < 246) ) && ( (117 < mouseY ) && (mouseY < 133) ) )    
                          // Verificando as coordenadas do ponteiro do mouse
          {
              imagem (reverso à direita, 0, 0);                      // Exibe a imagem "reverseright.jpg"
              
              if(flagpress == 0)
                  minhaPort.write('3');                          // Envia o caracter '3' para a porta USB
                  
              flagpress = 1;
              
          }
    }
    outro
    {
        flagpress = 0;
    }
    
}
 
 
 
 
###