Robô controlado por toque capacitivo usando módulo X-Bee

Carros robóticos são comumente usados ​​para operações externas. Eles são projetados para diferentes finalidades e aplicações. Esses veículos robóticos destinam-se a se mover sobre uma superfície e chegar a um local para realizar a aplicação pretendida ou realizar tarefas específicas. Os carros robóticos podem ser controlados com um controle remoto que pode ser conectado ao robô por meio de uma conexão com fio ou de uma interface sem fio. A conectividade sem fio geralmente é fornecida por redes Wi-Fi, Bluetooth, RF ou móveis. Uma das tecnologias de RF disponíveis para fornecer conexão sem fio é o Zigbee.

Zig Bee é uma tecnologia de comunicação sem fio padrão que transfere dados em bandas de rádio ISM. Opera em 2,4 GHz em todo o mundo e em outras frequências ISM em países selecionados. O protocolo de comunicação é comumente usado para criar redes de área pessoal para aplicações como automação residencial, redes de escritório sem fio e redes de dados baseadas em sensores. Os módulos Zig-Bee são comumente usados ​​para conectar dispositivos embarcados de baixo consumo de energia que precisam operar em uma área pequena com baixas taxas de dados. Um módulo Zig-Bee operando na banda de 2,4 GHz tem taxa de dados de 250 Kbps. X-bee é um módulo Zigbee da Digi International. Neste projeto é projetado um robô sem fio que se conecta ao controle remoto usando o módulo X-Bee.

O controle remoto possui sensores capacitivos para alimentar a entrada do usuário em vez dos botões típicos. Os sensores capacitivos são sensores baseados em toque que usam capacitância para detectar o toque do usuário. Sendo sensíveis ao toque, esses sensores respondem rapidamente e permitem controlar o robô com mais precisão e rapidez. Devido à sensibilidade ao toque, o tempo de resposta no controle do robô por um operador humano é consideravelmente reduzido. Os sensores capacitivos no controle remoto para este projeto são usados ​​para mover o robô para frente, para trás, para a esquerda ou para a direita ou para parar o robô. Assim, o sensor de toque capacitivo recebe informações do usuário para controlar a navegação do robô.

Um sensor de toque capacitivo realimenta a entrada do usuário na forma de tensão analógica para um pino do microcontrolador. O sensor funciona segundo o princípio da capacitância. Qualquer capacitor de placas paralelas tem uma capacitância dada pelas fórmulas –

C = εA/d

Onde;

C é a capacitância

A é a área das placas

d é a distância entre as placas

ε é a permissividade do dielétrico.

A capacitância está relacionada à tensão pelas fórmulas –

C = Q/V

ou V = Q/C

Assim, à medida que a distância entre as placas aumenta, a capacitância diminui e a tensão entre as placas aumenta. Um sensor capacitivo pode ser feito por uma única placa metálica conectando dois terminais. O dedo do usuário serve como a outra placa do capacitor e o ar entre o dedo e a placa de metal serve como dielétrico. A tensão de entrada é fornecida a um terminal e recebida em um pino de entrada do microcontrolador do outro terminal. Quando o dedo se aproxima da placa metálica ou toca fisicamente a placa metálica, a distância entre a placa metálica e o dedo é reduzida, o que diminui a capacitância e aumenta a tensão de saída no terminal receptor.

A entrada de tensão da placa metálica – capacitor de dedo pode ser lida no pino do microcontrolador, digitalizada através do ADC e comparada com um valor de referência para operá-lo como uma chave. Este conceito de toque capacitivo é utilizado para fazer no projeto sensores de toque ou proximidade que funcionam como botões de controle.

Os sensores capacitivos são usados ​​no controle remoto. O controle remoto é conectado ao robô usando a tecnologia sem fio Zigbee, para a qual são usados ​​dois módulos X-bee. Portanto, existem dois circuitos – um é o circuito remoto e o outro é o circuito receptor montado no robô. O robô é construído usando duas rodas e um corpo de rodízio e os motores DC acoplados às rodas são controlados usando o driver de motor L293D IC.

O circuito remoto tem o seguinte diagrama de blocos –

O circuito receptor montado no robô possui o seguinte diagrama de blocos –

Existem dois circuitos que compõem este projeto – um é o circuito remoto construído usando Arduino UNO, sensores capacitivos e módulo X-Bee. O outro é um circuito receptor montado em um robô construído usando Arduino UNO, módulo X-bee e driver de motor IC L293D.

O circuito remoto é construído usando os seguintes componentes –

Arduino UNO – Arduino UNO é uma das placas de prototipagem mais populares. Ele é usado com frequência em aplicações robóticas porque é pequeno e repleto de recursos avançados. A placa vem com carregador de inicialização Arduino integrado. É uma placa controladora baseada em Atmega 328 que possui 14 pinos GPIO, 6 pinos PWM, 6 entradas analógicas e interfaces UART, SPI e TWI integradas. Neste circuito remoto são utilizados 8 pinos da placa. Existem seis pinos usados ​​para fazer a interface dos sensores capacitivos. Destes cinco pinos são usados ​​como pinos de entrada analógica. Os dois pinos RX e TX da placa são usados ​​para fazer a interface do módulo X-bee e estabelecer comunicação serial via USART. Saiba mais sobre o Arduino UNO aqui.

Módulo X-Bee – X-Bee é um módulo Zigbee da Digi International. Zigbee é um módulo de comunicação sem fio que utiliza o padrão IEEE 802.15.4. O 802.15.4 é um padrão IEEE para aplicações de baixa potência de radiofrequência. É usado em muitos produtos para funcionalidade de comunicação sem fio. Ele pode ser usado como transmissor e receptor. Ele usa comunicação serial para enviar e receber dados. Possui duas séries, série 1 e série 2. A série 1 é comparativamente fácil de usar e é recomendada para iniciantes. Neste projeto é usado o módulo X-bee Série 1. O módulo Zigbee Série 1 não pode funcionar em rede mesh. Isso significa que ele não pode falar com mais de um Zigbee ao mesmo tempo. Saiba mais sobre a tecnologia Zigbee.

O X-bee série 1 é um módulo de 20 pinos com a seguinte configuração de pinos –

Sensores Capacitivos – Os sensores capacitivos são construídos com cinco placas metálicas. Um terminal de cada placa metálica é conectado ao pino 2 da placa Arduino. Os demais terminais das placas capacitivas são conectados aos pinos 7, 8, 9, 10 e 11 do Arduino. Esses pinos servem para detectar a tensão dos sensores capacitivos. Um resistor de sensibilidade de 1M Ω é conectado em série no terminal comum de cada placa. O resistor fornece a tensão na placa. Quanto maior for o valor desta resistência maior será a sensibilidade. Durante o teste dos sensores, constatou-se que ao conectar 1M Ω de resistor e manter uma tensão de referência na metade da largura do canal ADC, o sensor respondia ao toque do dedo. Ao conectar um resistor de 10M Ω e manter uma tensão de referência na metade da largura do canal ADC, o sensor estava respondendo de 4 a 6 polegadas de distância e ao conectar um resistor de 40M Ω e manter uma tensão de referência na metade da largura do canal ADC, o sensor estava respondendo de 12 a 24 polegadas de distância.

Os sensores conectados nos pinos 7, 8, 9, 10 e 11 do Arduino controlam o movimento do robô para frente, para trás, para a esquerda e para a direita e param o robô respectivamente.

Fonte de alimentação – Todos os componentes do circuito remoto requerem uma fonte de 5V DC. A placa Arduino é alimentada com 5V por um cabo USB. A entrada de tensão para o módulo X-bee é extraída do pino Vout de 5V do Arduino. A tensão para funcionamento dos sensores capacitivos é fornecida pelo pino 2 (pino comum conectado aos sensores) do Arduino.

O circuito receptor montado no robô consiste nos seguintes componentes –

Arduino UNO – O circuito receptor também usa Arduino UNO como placa controladora. O Arduino usado no circuito receptor possui 6 pinos utilizados. Os pinos GPIO deste Arduino são usados ​​para fazer interface com o IC do driver do motor L293D. Esses pinos são conectados aos pinos de entrada do IC do driver do motor. Os dois pinos do Arduino são usados ​​para fazer a interface do módulo X-Bee Série 1.

Módulo X-Bee – O módulo X-Bee utilizado no circuito receptor está configurado para funcionar como receptor de dados RF. O módulo faz interface com o Arduino conectando seu pino DOUT (UART Data Out) ou TX com o pino RX do Arduino e DIN (UART Data In) ou pino RX com o pino TX do Arduino. Os pinos VCC e Terra do módulo devem ser conectados ao VCC comum e ao aterramento.

IC do driver do motor L293D – O L293D é um circuito integrado (IC) do driver do motor com 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 – O Arduino UNO, módulo X-Bee e os pinos de alimentação lógica do IC do driver do motor requerem 5 V DC, enquanto o pino de alimentação do IC do driver requer 12 V DC. Uma bateria NIMH de 12V é usada como fonte primária de energia. 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.

O robô sem fio é alimentado por uma bateria e assim que a bateria é conectada ao circuito de controle do robô, ele começa a operar. Ao ser energizado, o módulo X-Bee interfaceado no circuito receptor é configurado como receptor de dados RF e passa a aguardar comandos do controle remoto. Os comandos são transmitidos na forma de sequências de caracteres únicos pelo controle remoto. As seguintes sequências são passadas pelo circuito remoto para o circuito receptor para mover o robô para frente, para trás, para a esquerda e para a direita e parando o robô –

O circuito remoto possui sensores capacitivos para obter informações do usuário por toque. Quando um sensor capacitivo não é tocado, o sensor não tem capacitância efetiva e a queda de tensão no resistor de sensibilidade não tem efeito no outro terminal do sensor. Quando o sensor é tocado por um dedo, há uma capacitância efetiva através do sensor e uma tensão é induzida no terminal de saída do sensor devido a esta capacitância. A tensão é lida pelo pino do microcontrolador e convertida em uma leitura digitalizada. O Arduino UNO possui canal ADC de 10 bits, por isso, a leitura digitalizada tem valor máximo de 1023. O valor de referência para comparação da tensão é tomado 900.

Ao detectar o toque em um sensor capacitivo, as sequências de comando são passadas serialmente pelo Arduino para o módulo X-Bee. Os sensores capacitivos são conectados aos seguintes pinos do Arduino e possuem as seguintes sequências de comando e operações pretendidas associadas a eles –

Agora siga as seguintes etapas –

Abra o aplicativo CoolTerm e navegue até conexão -> opções -> porta serial e selecione a porta COM. Defina a taxa de transmissão e vá para a opção Terminal e marque a caixa de seleção Eco local para exibir os comandos digitados e clique em OK para salvar as alterações.

Para configurar o X-Bee, os seguintes comandos AT devem ser usados.

Primeiro faça o X-Bee entrar em modo de comando digitando +++ no terminal, quando estiver OK, siga com os outros comandos AT

Em primeiro lugar, os rádios XBEE operam apenas a uma determinada taxa de transmissão, este é o número de bits por segundo que o X-Bee pode enviar. Um X-Bee totalmente novo tem taxa de transmissão padrão de 9600 bps, o que é bastante lento. A taxa de transmissão pode ser alterada alterando o registro ATBD. Ambos os módulos X-Bee devem ter a mesma taxa de transmissão para se comunicarem entre si. As taxas de transmissão disponíveis (e o valor ATBD correspondente) são as seguintes –

Portanto, para definir a taxa de transmissão em 9600, o seguinte comando deve ser passado –

O próximo parâmetro importante é o ID da rede de área pessoal. Este é um número compartilhado entre cada XBEE em uma rede. Aqui, existem apenas 2 módulos X-Bee, mas pode haver muitos módulos X-Bee em uma rede (para os quais os módulos X-Bee Série 2 devem ser usados). Os módulos X-Bee em redes diferentes não “vêem” uns aos outros. O PAN padrão é 3332, portanto evite usar esse número. O PAN ID é armazenado no registro ATID. O registro pode ser alterado passando o seguinte comando –

Uma vez que ambos os módulos X-Bee estejam na mesma rede, cada um deles deve receber um número de endereço indicado pelo registro ATMY. O endereço de destino também pode ser definido, que é o número de endereço com o qual se deve comunicar e é indicado pelo registro ATDL (para destino baixo, não há necessidade de usar os bytes altos se os números de endereço tiverem menos de 16 bits de comprimento). Um exemplo de configuração de dois módulos X-Bee que se comunicarão diretamente entre si a 38,4 kbps pode ser feito passando os seguintes comandos –

Portanto, ambos os módulos X-Bee são configurados passando os seguintes comandos AT –

ATID1001

ATMY10

ATDL11

ATBD3

ATID1001

ATMY11

ATDL10

ATBD3

Uma coisa importante a notar é que as alterações feitas são armazenadas na memória temporária. se os módulos X-Bee forem desligados, as configurações serão perdidas. Envie ATWR para gravar as alterações na memória não volátil, para que não sejam perdidas durante o desligamento.

Uma vez configurados os módulos X-Bee, o esboço do Arduino para o circuito remoto e o circuito receptor pode ser carregado na respectiva placa controladora.

Verifique o Arduino Sketch carregado no Arduino conectado no circuito remoto para ver como o Arduino detecta o toque por sensor usando a biblioteca de sensores capacitivos e usa a leitura do sensor para enviar strings de comando serialmente para o módulo X-bee. Verifique o Arduino Sketch carregado no Arduino conectado no circuito receptor para ver como as strings de comando são lidas através do módulo X-Bee e o IC do driver do motor é controlado de acordo com os comandos recebidos.

Programa de circuito remoto: O código Arduino carrega o CapacitiveSensor.h para lidar com sensores capacitivos. Cinco objetos do tipo sensor capacitivo são instanciados com mapeamento para os pinos conectados usando o método CapacitiveSensor no qual o primeiro parâmetro determina a resistência da sensibilidade e o segundo parâmetro determina o pino que conecta o sensor. Um conjunto de variáveis ​​para manter os níveis de tensão nos sensores capacitivos é declarado seguido por um conjunto de variáveis ​​que mantêm o status dos dispositivos. Uma variável para manter o nível de tensão de referência é declarada. A taxa de transmissão para comunicação serial com o módulo X-bee é definida para 9600 bits por segundo usando o método Begin na classe Serial.

A função loop é chamada na qual o nível de tensão dos sensores capacitivos é lido e armazenado em variáveis ​​​​declaradas para ele usando o método capacitiveSensor com um número de amostras passadas como parâmetro. Com o valor da tensão comparado com o valor de referência seguindo a condição e os respectivos dados são enviados para o X-bee usando a função pritln .

Programa do Circuito Receptor: – Na codificação do lado do receptor, a variável de caractere é inicializada para armazenar os dados recebidos. Os pinos do motor são definidos e conectados entre o Arduino e o IC do driver do motor. Na função setup , a função Begin é usada para definir a taxa de transmissão para 9600 para receber os dados seriais do X-bee. Os pinos do Arduino conectados aos pinos de entrada do IC do driver do motor são configurados para saída digital usando a função pinMode.

A função loop é chamada e verifica continuamente os dados seriais recebidos. Se os dados seriais estiverem disponíveis, os dados são lidos usando a função serial.read e armazenados na variável. Em seguida, os dados armazenados são verificados com a condição mencionada. Então, com relação às condições, a chamada da função para movimento do robô é realizada.

A função move_forward é chamada para mover o robô na direção para frente. A função move_backward é chamada para mover o robô para trás. A função turn_left é usada para virar o robô na direção esquerda e a função turn_right é usada para virar o robô na direção direita. A função robo_stop é usada para parar o robô.

Confira os códigos completos do Arduino e coloque a mão na massa rapidamente com um IDE do Arduino. Será divertido fazer este robô.

###

//Program to 
char msg = ' ';

//definining the arduino pin number for arduino
#define L_motor1 2
#define L_motor2 3
#define R_motor1 4
#define R_motor2 5

//function prototype
void move_forward ;
void move_backward ;
void turn_right ;
void turn_left ;

void setup 
{
  //For enabling serial data transfer at rate of 9600
   Serial.begin(9600);

   //pin modes of motor conected with arduino
   pinMode(L_motor1, OUTPUT);
   pinMode(L_motor2, OUTPUT);
   pinMode(R_motor1, OUTPUT);
   pinMode(R_motor2, OUTPUT);

  digitalWrite(L_motor1, LOW);
  digitalWrite(L_motor2, LOW);
  digitalWrite(R_motor1, LOW);
  digitalWrite(R_motor2, LOW);
}

void loop 
{
  //checking for serial data receiving
  if(Serial.available  > 0)
  {
    //if reading the serial data
    msg = Serial.read ;

    //with respect to the data received controlling the direction of motor
    if(msg == 'R')
    {
      turn_right ;
    }
    if(msg == 'L')
    {
      turn_left ;
    }
    if(msg == 'F')
    {
      move_forward ;
    }
    if(msg == 'B')
    {
      move_backward ;
    }
    if(msg == 'S')
    {
      robo_stop ;
    }
  }
  delay(80);
}

void move_forward 
{
  digitalWrite(L_motor1, HIGH);
  digitalWrite(L_motor2, LOW);
  digitalWrite(R_motor1, HIGH);
  digitalWrite(R_motor2, LOW);
}

void move_backward 
{
  digitalWrite(L_motor1, LOW);
  digitalWrite(L_motor2, HIGH);
  digitalWrite(R_motor1, LOW);
  digitalWrite(R_motor2, HIGH);
}

void turn_left 
{
  digitalWrite(L_motor1, LOW);
  digitalWrite(L_motor2, LOW);
  digitalWrite(R_motor1, HIGH);
  digitalWrite(R_motor2, LOW);
}

void turn_right 
{
  digitalWrite(L_motor1, HIGH);
  digitalWrite(L_motor2, LOW);
  digitalWrite(R_motor1, LOW);
  digitalWrite(R_motor2, LOW);
}

void robo_stop 
{
  digitalWrite(L_motor1, LOW);
  digitalWrite(L_motor2, LOW);
  digitalWrite(R_motor1, LOW);
  digitalWrite(R_motor2, LOW);
}

###

Diagrama de circuito-sensor de toque capacitivo-teclado-robô sem fio
Diagrama de Circuito-XBee-Robô Capacitivo-Controlado por Toque