Robô sem fio controlado por joystick

Em um dos projetos anteriores “Robô sem fio controlado por gestos manuais”, foi discutido como os controles remotos com interruptores ou botões usados ​​para controlar robôs sem fio têm uma desvantagem no controle do robô devido ao fator de tempo de resposta do ser humano que o manipula. Como solução para o problema, foi sugerido o uso de interfaces avançadas entre humanos e computadores, como reconhecimento de gestos, rastreamento de movimentos oculares e ondas cerebrais. Dos quais, gestos manuais foram utilizados no projeto anterior para controlar o robô. Neste tutorial será projetado um robô sem fio que será controlado pelo joystick. Um joystick não é um novo dispositivo de entrada, mas fornece melhor controle sobre o assunto. É mais fácil de usar e manusear por um operador humano.

Um joystick não difere muito do controle remoto desenvolvido no projeto anterior. Um joystick funciona de forma semelhante a um sensor acelerômetro. Assim como um sensor acelerômetro emite a mudança nas dimensões do eixo X, eixo Y e eixo Z da orientação do sensor no espaço, da mesma forma, um joystick envia a mudança nas dimensões do eixo X, eixo Y e eixo Z de a orientação do bastão montado nele. Somente alterações nos eixos X e Y são necessárias para mover o robô em uma superfície. Neste projeto, o robô pode se mover para frente, para trás, para a esquerda ou para a direita com base na inclinação do módulo joystick. O módulo joystick faz interface com o microcontrolador AVR Atmega 32.

Há um módulo RF de 434 MHz conectado ao circuito AVR para conectar o circuito remoto ao circuito de controle do robô sem fio. No circuito do robô, simplesmente, um circuito receptor de RF faz interface com o IC do driver do motor. O robô é construído sobre duas rodas e um corpo de rodízio. Existem dois motores DC com engrenagens acoplados às rodas e acoplados ao IC do driver do motor L293D para mover o robô.

Um LCD é conectado ao circuito remoto do robô para monitorar a mudança nos valores do eixo durante o teste do circuito de controle. O robô deve ser calibrado para uma sensibilidade adequada ao movimento do joystick. O módulo LCD interligado no circuito remoto pisca algumas mensagens iniciais na partida e então começa a exibir a mudança nos valores dos eixos X e Y junto com o comando de controle correspondente a eles.

O circuito de controle do robô sem fio não possui nenhum controlador. O robô é controlado diretamente pelos dados digitais transmitidos pela interface RF. O circuito remoto tem AVR Atmega 32 como microcontrolador sentado. O código que consegue interpretar os sinais do joystick e passar os dados digitais apropriados para o robô sem fio é executado no controlador AVR. O código AVR é ​​escrito e compilado usando o estúdio AVR.

O circuito remoto é construído reunindo os seguintes blocos de construção –

O circuito de controle do controle remoto sem fio é construído através da montagem dos seguintes blocos de construção –

Existem dois circuitos que compõem o projeto – um é o circuito remoto baseado no microcontrolador AVR e o outro é o circuito receptor montado no robô. O circuito remoto tem o AVR Atmega 32 como microcontrolador sentado. O módulo LCD, o módulo de joystick ADXL335, o codificador IC e o transmissor de RF fazem interface com o controlador AVR no circuito remoto. As conexões do circuito remoto são as seguintes –

Fonte de alimentação – O circuito remoto requer uma fonte de 5V para funcionar. O microcontrolador AVR Atmega 32, transmissor RF, codificador IC, LCD de caracteres e módulo Joystick funcionam em 5V DC. Para fornecer energia ao circuito remoto, é usada uma bateria NIMH de 12V. a energia da bateria é regulada para 5 Vcc usando o IC regulador de tensão 7805. O pino 1 do IC regulador de tensão está conectado ao ânodo da bateria e o pino 2 está conectado ao terra. A saída de tensão regulada é extraída do pino 3 do IC. Um LED junto com um resistor pull-up de 10K Ω também é conectado entre o terra comum e o pino de saída para obter uma dica visual da continuidade da alimentação.

AVR Atmega 32 – Este é um microcontrolador baseado em AVR RISC de 8 bits. Ele vem em um pacote de 40 pinos e possui 2 KB de RAM, 32 KB de memória flash, 1 KB EEPROM, 32 pinos de entrada e saída de uso geral (GPIO), 8 canais ADC de 10 bits, um SPI, um UART e uma interface TWI no chip. O controlador possui três temporizadores embutidos, dos quais 2 são temporizadores de 8 bits e um é um temporizador de 16 bits. O controlador opera até uma frequência de clock de 16 MHz. Ao executar instruções poderosas em um único ciclo de clock, o Atmega 32 atinge taxas de transferência próximas de 1 MIPS por MHz, permitindo que os projetistas do sistema otimizem o consumo de energia em relação à velocidade de processamento. O controlador está disponível em pacote Dual Inline (DIP) de 40 pinos. Confira o diagrama de pinos e a configuração dos pinos deste controlador AVR aqui.

Neste projeto são usados ​​17 pinos GPIO do controlador, dos quais 11 pinos são usados ​​para fazer a interface do LCD de caracteres, 2 pinos são usados ​​para fazer a interface do módulo joystick e 4 pinos são usados ​​para conectar os pinos de dados do codificador IC.

LCD 16X2: O display LCD 16X2 é usado para monitorar os valores do sensor. Ele faz interface com o microcontrolador AVR conectando seus pinos de dados à porta B do controlador. Os pinos de dados DB0 a DB7 do LCD de caracteres fazem interface com os pinos PB0 a PB7 do AVR Atmega 32, respectivamente. Os pinos RS, RW e E do LCD estão conectados aos pinos PD0, PD1 e PD2 do AVR, respectivamente. As conexões do circuito do LCD de caracteres com o controlador AVR estão resumidas na tabela a seguir –

Módulo joystick – Um módulo joystick personalizado é usado no projeto. O módulo possui cinco terminais para terra, VCC, saída analógica do eixo X, saída analógica do eixo Y e saída analógica do eixo Z. O VCC e o aterramento são conectados ao VCC e ao aterramento comuns, respectivamente. A saída analógica do eixo X e a saída analógica do eixo Y do módulo do sensor são utilizadas e interligadas ao pino 0 da porta A e ao pino 1 da porta A do controlador AVR, respectivamente.

Transmissor RF – O transmissor RF é usado para transmitir os sinais de controle para controle do motor. O módulo transmissor de RF é um pequeno subconjunto de PCB. O módulo RF, como o nome sugere, opera em Radiofrequência. A faixa de frequência correspondente de tais módulos varia entre 30 kHz e 300 GHz. Neste sistema de RF, os dados digitais são representados como variações na amplitude da onda portadora. Este tipo de modulação é conhecido como Amplitude Shift Keying (ASK). Este módulo RF opera na frequência de 433 MHz e usa a técnica de modulação ASK. A configuração dos pinos do módulo transmissor é a seguinte

Os dados serializados do codificador são recebidos no pino 2 do módulo e repassados ​​para a antena a partir do pino 4 do módulo.

HT12E IC – O HT12E IC converte os dados paralelos em dados seriais para passá-los ao transmissor de RF. O codificador IC HT12E pertence à série 212 de codificadores. É emparelhado com decodificadores da série 212 com o mesmo número de endereços e formato de dados. O HT12E é capaz de codificar 12 bits, dos quais 8 são bits de endereço e 4 são bits de dados. Assim, o sinal codificado é um dado paralelo serializado de 12 bits composto por dados de 4 bits a serem transferidos anexados ao byte de endereço.

Os pinos de dados D0, D1, D2 e ​​D3 do IC estão conectados aos pinos PC0, PC1, PC2 e PC3 do controlador AVR, respectivamente. Todos os pinos de endereço do IC do codificador são conectados ao terra, portanto, ele possui um byte de endereço 0x00. O pino 17 do IC está conectado ao pino 2 do transmissor RF. Assim, os dados serializados são passados ​​do pino 17 do IC para o pino de entrada de dados do transmissor RF.

O HT12E possui um pino de habilitação de transmissão que está ativo em nível baixo. Quando um sinal de disparo é recebido no pino TE, os endereços/dados programados são transmitidos juntamente com os bits do cabeçalho através de um meio de transmissão RF ou infravermelho. O HT12E inicia um ciclo de transmissão de 4 palavras após receber uma habilitação de transmissão. Este ciclo é repetido enquanto o TE for mantido baixo. Assim que TE retorna para nível alto, a saída do encoder completa seu ciclo final e então para.

O circuito de controle do robô consiste em um receptor de RF, um decodificador de RF IC e um driver de motor L293D IC. As conexões do circuito receptor são as seguintes –

Receptor RF – O receptor RF detecta o sinal de rádio que transporta os sinais de controle do motor. O módulo receptor RF possui 8 pinos e a seguinte configuração de pinos –

Decodificador HT12D – O sinal detectado pelo receptor RF é passado para o decodificador HT12D. Ele converte os dados seriais de volta em dados paralelos após separar dados e endereços. O HT12D pertence à série 212 de decodificadores e pode ser emparelhado com a série 212 de codificadores com o mesmo número de endereços e formato de dados. O HT12D é capaz de decodificar 12 bits, dos quais 8 são bits de endereço e 4 são bits de dados. Os dados de 4 bits são do tipo latch e quando passados ​​para os pinos de dados de saída permanecem inalterados até que novos dados sejam recebidos.

Os dados seriais recebidos pelo receptor RF são emitidos paralelamente a partir de seus pinos de dados como estão. Os pinos de dados do IC decodificador fazem interface com os pinos de entrada do IC do driver do motor L293D. Assim, a lógica digital nos pinos de dados do decodificador controla a rotação dos motores DC. Todos os pinos de endereço do IC decodificador são conectados ao terra para corresponder ao byte de endereço com 0x00 igual ao circuito transmissor.

L293D DC Motor Driver IC – O L293D é um circuito integrado (IC) de driver de motor de ponte H dupla. Os drivers do motor atuam como amplificadores de corrente, pois recebem um sinal de controle de baixa corrente e fornecem um sinal de corrente mais alta. Este sinal de corrente mais alto é usado para acionar os motores. Possui 16 pinos com a seguinte configuração de pinos:

O IC L293D controla os motores DC de acordo com as seguintes tabelas verdade:

Motores DC com engrenagens – Neste robô, motores DC com engrenagens de 12 V são acoplados às rodas. Os motores DC com engrenagens estão disponíveis com uma ampla faixa de RPM e Torque, o que permite que um robô se mova com base no sinal de controle que recebe do IC do driver do motor.

Fonte de alimentação – No circuito receptor, o IC do driver do motor precisa de 12 Vcc, enquanto o receptor RF e o IC decodificador precisam de 5 Vcc para sua operação. Uma bateria NIMH de 12 V é usada como fonte primária de energia no circuito. A alimentação da bateria é regulada para 5V e 12V usando CIs 7805 e 7812. O pino 1 de ambos os CIs reguladores de tensão está conectado ao ânodo da bateria e o pino 2 de ambos os CIs está conectado ao terra. As respectivas saídas de tensão são extraídas do pino 3 dos respectivos CIs reguladores de tensão. Um LED junto com um resistor pull-up de 10K Ω também é conectado entre o terra comum e o pino de saída para obter uma dica visual da continuidade da alimentação. Apesar de usar bateria de 12 V, o 7812 é usado para fornecer uma alimentação regulada e estável ao IC do driver do motor.

À medida que a bateria é conectada ao robô, o receptor RF é configurado para emparelhar com o transmissor RF e começa a receber os dados. No lado do transmissor, primeiro as mensagens iniciais piscam na tela LCD e o microcontrolador AVR começa a ler os dados do eixo X e do eixo Y do módulo joystick na forma de tensão analógica. A tensão é detectada pelos pinos de entrada analógica e convertida em uma leitura digitalizada usando canais ADC integrados. Os canais ADC têm 10 bits de comprimento, portanto, a leitura digitalizada da saída do eixo X e do eixo Y do módulo varia de 0 a 1023.

Os valores digitalizados são exibidos no módulo LCD junto com o comando de controle passado para os respectivos valores do eixo. A leitura é manipulada para determinar se o joystick está inclinado para frente, para trás, para a esquerda ou para a direita. Dependendo da inclinação do joystick, o controlador passa os bits de dados apropriados para o codificador RF para acionar motores CC para movimento para frente, para trás, para a esquerda ou para a direita do robô.

A mesma lógica digital é refletida nos pinos de dados do IC decodificador. O robô pode ser movido para frente, para trás, para a esquerda ou para a direita implementando a seguinte lógica de entrada nos pinos do driver do motor –

Para programar o microcontrolador Atmega 32, o AVR Studio 4 e o compilador GCC são as ferramentas de software necessárias. Para aprender como o AVR Studio 4 é usado, consulte o seguinte tutorial –

Trabalhando com AVR Studio

Primeiro de tudo, arquivos de cabeçalho separados são importados para a inicialização do módulo LCD, ADC e joystick. O lcd.h, adc.h e joystick.h estão incluídos para a programação LCD, ADC e módulo joystick, respectivamente.

#incluir

#include

#include

Para que os arquivos de cabeçalho funcionem, eles devem ser copiados para a seguinte pasta – C > WinAVR-20090313 > avr > include > avr e colar os arquivos de cabeçalho baixados na pasta.

Observe que no caminho WinAVR-20090313, 20090313 há um número anexado à pasta de instalação. Este número pode ser diferente numa instalação diferente do AVR Studio.

A seguir são definidas as portas que estão conectadas ao módulo LCD e Joystick. Eles são inicializados para os valores máximo e mínimo dos eixos xey na faixa onde o robô deve ser controlado.

A função principal fornece lógica para toda a operação do circuito remoto. Nesta função, os pinos são declarados como pinos de entrada ou saída da porta que já foi inicializada.

O loop while dentro da função main é um loop infinito, onde os dados do sensor são lidos e as condições são implementadas para fazer o robô funcionar. confira o código AVR completo.

###

//Program to 


#ifndef _ADC_H_


#define _ADC_H_ 1






#include


#include






void adc_init(void);






// This function is declared to read the digital value of the ADC conversion 




int read_adc_channel(unsigned char channel);








/*Function definations*/


void adc_init(void)


{                    


ADCSRA=(1<  ADMUX=(1<  _delay_ms(1);


temp=ADCL;


adc_value=ADCH;


adc_value=(adc_value<<8) temp;


    return adc_value;


}  




#endif



//**************************************************************//

//Microcontroller :ATmega32

//System Clock :1MHz 

//Project :joystick controlled wireless robot

//Software :AVR Studio 4 

//LCD Data Interfacing         :8-Bit  

//Date :July 2017

//**************************************************************//


//Includes io.h header file where all the Input/Output Registers 
and its Bits are defined for all AVR microcontrollers

#include 


//Defines a macro for the delay.h header file. 
F_CPU is the microcontroller frequency value for the delay.h header file. 
Default value of F_CPU in delay.h header file is 1000000(1MHz)

#define F_CPU 1000000


//Includes delay.h header file which defines two functions,
 _delay_ms (millisecond delay) and _delay_us (microsecond delay)

#include


//Defines a macro for the lcd.h header File. 
LCD_DATA_PORT is the microcontroller PORT Register to which the data pins of the LCD are connected. 
Default PORT Register for data pins in lcd.h header file is PORTA

#define LCD_DATA_PORT PORTB


//Defines a macro for the lcd.h header File. 
LCD_CONT_PORT is the microcontroller PORT Register to which the control pins of the LCD are connected. 
Default PORT Register for control pins in lcd.h header file is PORTB*

#define  LCD_CONT_PORT PORTD


//Defines a macro for the lcd.h header file. 
LCD_RS is the microcontroller Port pin to which the RS pin of the LCD is connected. 
Default Port pin for RS pin in lcd.h header file is PB0

#define  LCD_RS  PD0


//Defines a macro for the lcd.h header file. 
LCD_RW is the microcontroller Port pin to which the RW pin of the LCD is connected. 
Default Port pin for RW pin in lcd.h header file is PB1

#define  LCD_RW  PD1


//Defines a macro for the lcd.h header file. 
LCD_EN is the microcontroller Port pin to which the EN pin of the LCD is connected. 
Default Port pin for EN pin in lcd.h header file is PB2

#define  LCD_EN  PD2


//Includes lcd.h header file which defines different functions for all Alphanumeric LCD(8-Bit Interfacing Method)

#include 


//Includes adc.h header file which defines different functions for Analog to Digital Converter.

#include 


//Includes joystick.h header file which defines different functions for joystick

#include 


//Defines the lower threshold for the x-axis value of joystick

#define X_MIN 100


//Defines the upper threshold for the x-axis value of joystick

#define X_MAX 900


//Defines the lower threshold for the y-axis value of joystick

#define Y_MIN 100


//Defines the upper threshold for the y-axis value of joystick

#define Y_MAX 900


int main 

{

//All the 8 pins of PortB are declared output (data pins of LCD are connected)

DDRB=0xff;


//PD0, PD1 and PD2 pins of PortD are declared output (control pins of LCD are connected)

DDRD=0x07;


//PC0,PC1,PC2 and PC3 pins of PortC are declared output 
( i/p1,i/p2,i/p3,i/p4 pins of DC Motor Driver are connected )

DDRC=0x0f;


//Variable declarations

int x_axis,y_axis;


//ADC initialization

adc_init ;

   

//LCD initialization

lcd_init ;

  

//String display in 1st row of LCD

lcd_string_write("EngineersGarage");


//Cursor moves to 2nd row 1st column of LCD

lcd_command_write(0xc0);


//String display in 2nd row of LCD 

lcd_string_write("EG LAB");


//Display stays for 2 second

_delay_ms(500);

_delay_ms(500);

_delay_ms(500);

_delay_ms(500);


//Clear screen*/

lcd_command_write(0x01);


//String display in 1st row of LCD

lcd_string_write("Tilt your Hand:");


//Cursor moves to 2nd row 1st column of LCD

lcd_command_write(0xc0);


//Start of infinite loop

while(1)

{

//Reading x-axis value of joystick 

x_axis=read_joystick_x_value(0);


//Reading y-axis value of joystick  

y_axis=read_joystick_x_value(1);


//Cursor moves to 2nd row 1st column of LCD

lcd_command_write(0xc0);


//Checking the joystick movement to move the robot in different direction

if(x_axis>X_MAX)

{

//Robot will move forward direction

PORTC=0x0A;


//String display in 2nd row of LCD

lcd_string_write("Moving Forward ");

}

else if(x_axisY_MAX)

{

//Robot will move in right direction

PORTC=0x08;


//String display in 2nd row of LCD

lcd_string_write("Moving Right   ");

}

else if(y_axis