Carro robótico controlado pela Internet

16 de junho de 2024 Roberto Magalhães

Existem muitos modelos de veículos robóticos controlados sem fio. Normalmente tais robôs são conectados a um controle remoto através de módulo RF, Bluetooth, Wi-Fi ou telefones celulares. Todas essas tecnologias sem fio têm suas próprias limitações e estão restritas a faixas específicas. Como se o veículo robótico estivesse conectado ao controle remoto via módulo Bluetooth (como o módulo Bluetooth HC-05), ele pode ter alcance operacional máximo de até 10 metros. Se o veículo robótico estiver conectado ao controle remoto via módulo RF, ele poderá ter alcance operacional máximo até uma distância de 50 a 60 metros. Neste projeto, é projetado um veículo robótico controlado pela internet que será controlado por uma página web. A página da web pode ser aberta em qualquer desktop, laptop ou celular. O veículo robótico pode estar em qualquer lugar com acesso à internet e pode ser controlado remotamente de qualquer lugar.

O veículo robótico foi projetado em Particle Photon. Para fabricar o veículo, dois motores DC são interligados ao painel de partículas por meio do IC do driver do motor L293D. Um sensor de temperatura e umidade DHT-11 e um sensor LDR também estão conectados à placa para monitorar o ambiente físico ao redor do carro robótico. Particle Photon é uma placa IOT com módulos Wi-Fi e Bluetooth integrados. A placa opera no ar conectando-se a uma conexão Wi-Fi. A placa se conecta automaticamente ao serviço Particle's Cloud e pode ser controlada pela internet enviando dados pelo serviço de nuvem da empresa.

Particle Photon é uma placa IOT compatível com Arduino. Para escrever o código do programa para qualquer Photon, o desenvolvedor precisa criar uma conta no site do Particle e registrar a placa Photon com sua conta de usuário. O código do programa pode então ser escrito no Web IDE no site da Particle e transferido para uma placa IOT registrada pela Internet. Se o painel de partículas selecionado, Photon aqui, estiver ligado e conectado ao serviço de nuvem do Particle, o código é gravado no painel selecionado pelo ar via conexão com a internet e o painel passa a operar de acordo com o código transferido.

Para controlar a placa pela internet, foi desenvolvida uma página web que utiliza Ajax e JQuery para enviar dados à placa utilizando o método HTTP POST. A página identifica a placa por um ID de dispositivo e se conecta ao Particle's Cloud Service por meio de um token de acesso.

Componentes necessários –

Lado do receptor:

1. Partícula Fóton.

2. Sensor DHT11.

3. Sensor LDR.

4. Conexão Wi-Fi doméstica.

5. IC do driver do motor L293D

9. Motores CC

Lado do transmissor:

1. Página da Web (EngineersGarageIoT.html)

Diagrama de bloco –

Figura 1: Diagrama de blocos de um carro robô controlado pela Internet baseado em fótons de partículas

Conexões de Circuito –

Protótipo de carro robô controlado pela Internet baseado em fótons de partículas

Fig. 2: Protótipo de carro-robô controlado pela Internet baseado em partículas fótons

O IC do driver do motor e os sensores fazem interface com o Particle Photon. O circuito é montado da seguinte maneira –

Fonte de alimentação – No circuito, Photon e outros ICs precisam de uma CC regulada de 5 V para seu funcionamento. Uma bateria de 18 V é 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.

Sensor de temperatura e umidade DHT-11 – O sensor DHT-11 lê a temperatura e umidade ambiente e retransmite os dados para o microcontrolador como dados digitais. O pino de dados do sensor de temperatura e umidade DHT11 é conectado ao pino A0 do Particle Photon e o VCC e o aterramento são conectados ao VCC comum e ao aterramento.

Sensor LDR – O LDR é usado para detectar a intensidade da luz. O sensor está conectado ao pino A1 do Particle Photon. O sensor está conectado em um circuito divisor de potencial. O LDR fornece uma tensão analógica que é convertida em leitura digital pelo ADC integrado.

IC do driver do motor DC L293D – O L293D é o IC do driver de controle do motor. Possui 16 pinos com a seguinte configuração de pinos:

Fig. 3: Tabela listando a configuração dos pinos do IC do driver do motor L293D

Existem dois motores DC usados para fazer o carro robótico. Os motores DC fazem interface entre os pinos 3 e 6 e os pinos 14 e 11 do IC do driver do motor.

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

Fig. 4: Tabela verdade do IC do driver do motor L293D

Fig. 5: Tabela verdade do IC do driver do motor L293D

Os pinos 4, 5, 13 e 12 do L293D são aterrados enquanto os pinos 1, 16 e 9 estão conectados a 5 Vcc e o pino 8 está conectado a 9 Vcc. Os pinos 15, 2, 7 e 10 do IC do driver do motor estão conectados aos pinos D3, D2, D1 e D0 do Particle Photon.

Como funciona o circuito –

Fig. 6: Imagem de um carro robô controlado pela Internet baseado em partículas fótons

Assim que o código do programa é transferido para o Particle Photon, ele começa a operar de acordo com ele. O Particle Photon deve estar conectado a qualquer hotspot de internet via Wi-Fi. O código compatível com Arduino no Photon envia inicialmente uma lógica LOW em todos os pinos de dados, pausando ambos os motores e começa a buscar dados dos sensores.

O Sensor de Temperatura e Umidade DHT11 é um sensor digital com sensor de umidade capacitivo embutido e termistor. Ele transmite uma leitura de temperatura e umidade em tempo real a cada 2 segundos. O sensor opera com alimentação de 3,5 a 5,5 V e pode ler temperatura entre 0° C e 50° C e umidade relativa entre 20% e 95%. O Sensor DHT 11 envia dados em formato digital para um pino controlador no protocolo one-wire que deve ser implementado no lado do firmware. Primeiro, o pino de dados é configurado para entrada e um sinal de início é enviado a ele.

O sinal de início compreende um BAIXO por 18 milissegundos seguido por um ALTO por 20 a 40 microssegundos seguido por um BAIXO novamente por 80 microssegundos e um ALTO por 80 microssegundos. Depois de enviar o sinal de início, o pino é configurado para saída digital e os dados de 40 bits compostos pela leitura de temperatura e umidade são bloqueados. Dos dados de 5 bytes, os dois primeiros bytes são a parte inteira e decimal da leitura da umidade relativa, respectivamente, o terceiro e o quarto bytes são a parte inteira e decimal da leitura da temperatura e o último é o byte da soma de verificação. O protocolo one-wire é implementado no firmware usando uma biblioteca de código aberto disponível para Photon.

O sensor IR emite uma tensão analógica no pino do controlador com interface. A tensão analógica é lida e digitalizada usando o canal ADC integrado. A função analogRead é usada para ler a tensão analógica no pino do controlador.

Os dados lidos do sensor são passados para o Particle Cloud via conexão Wi-Fi e a placa aguarda o comando para movimentar o veículo. O usuário vê os dados do sensor na página da web e tem botões para mover e virar o carro na mesma página da web. À medida que o usuário toca em um botão, o comando em forma de string é transferido pela internet por meio do serviço Particle's Cloud. As strings são recebidas via método HTTP POST pelo Particle Photon. Ao detectar o comando, a placa altera a lógica digital nos pinos de dados girando os motores no sentido horário ou anti-horário.

No circuito do robô, considerando a tração nas duas rodas, seja dianteira ou traseira, o motor do lado direito (RHS) é conectado entre os pinos 3 e 6 e o motor do lado esquerdo (LHS) é conectado entre os pinos 11 e 14 do L293D. O motor RHS é controlado pelos pinos 2 e 7 do L293D enquanto o motor LHS é controlado pelos pinos 10 e 15 do L293D. Portanto, para mover o robô em direções diferentes, são necessárias as seguintes saídas digitais nos pinos L293D:

Fig. 7: Tabela lógica do IC do driver do motor L293D para carro robótico baseado em fótons IoT

Portanto, para impulsionar o robô nesta tração nas duas rodas, o motor RHS precisa ser girado no sentido horário e o motor LHS precisa ser girado no sentido anti-horário. Isso é feito passando sinais BAIXOS para os pinos 2 e 15 do L293D e sinais ALTOS para os pinos 7 e 10 do L293D de acordo com a tabela verdade. Para conduzir o robô para trás (aplicável à tração nas duas rodas), o motor RHS precisa ser girado no sentido anti-horário e o motor LHS precisa ser girado no sentido horário. Isso é feito passando sinais BAIXOS para os pinos 7 e 10 do L293D e sinais ALTOS para os pinos 2 e 15 do L293D de acordo com a tabela verdade.

Para virar o robô para a direita, o motor RHS deve ser parado e o motor LHS precisa ser girado no sentido anti-horário. Isso é feito passando sinais BAIXOS para os pinos 2, 7 e 15 do L293D e sinais ALTOS para o pino 10 do L293D de acordo com a tabela verdade. Para virar o robô para a esquerda, o motor LHS deve ser parado e o motor RHS precisa ser girado no sentido horário. Isso é feito passando sinais BAIXOS para os pinos 2, 10 e 15 do L293D e sinais ALTOS para o pino 7 do L293D de acordo com a tabela verdade. Os motores são parados no projeto fornecendo ambas as entradas de controle do L293D para cada motor uma lógica LOW.

Confira o código do fóton para saber como o código compatível com Arduino detecta comandos no ar e lê dados de sensores e publica-os no URL de registro de dados vinculado. Aprenda como a string do comando é manipulada para alterar a lógica digital nos pinos conectados ao IC do driver do motor L293D.

Guia de programação –

Código de fótons

Primeiro de tudo, a biblioteca do sensor DHT é importada. A biblioteca é adicionada automaticamente pelo Web IDE da partícula. Uma constante é definida para denotar o pino ao qual o sensor DHT 11 está conectado e uma constante é definida para denotar a variante do sensor DHT. Variáveis para conter valores de temperatura, umidade e intensidade de luz são declaradas. As variáveis que denotam a lógica de controle do motor são declaradas e atribuídas aos pinos do microcontrolador. Um objeto do tipo DHT é declarado.

Uma matriz de caracteres é declarada para conter os dados do sensor a serem enviados para a página da web.

A função setup é chamada na qual os pinos conectados ao L293D são declarados como pinos de saída usando a função pinMode e definidos como LOW por padrão usando a função digitalWrite . O sensor DHT é inicializado chamando o método begin no objeto dht. Uma variável getpos e uma função setpos são expostas da nuvem e recuperadas por meio do método POST chamando os métodos Particle.variable e Particle.function. A função setup é executada apenas uma vez no início do código.

A função loop é chamada e itera infinitamente. Na função loop , os dados do sensor DHT são obtidos usando os métodos getTempCelcius e getHumidity no objeto dht. Os dados do sensor LDR são obtidos chamando o método analogRead e convertidos em intensidade de luz usando fórmulas padrão. Os dados de diferentes sensores são armazenados em variáveis, agrupados em strings adequadas e enviados para a URL de registro de dados usando o métodopublish no objeto Particle.

A função ledToggle manipula a string de comando. A string é convertida em número inteiro e comparada com 1 a 4 para alterar a lógica nos pinos de entrada do motor L293D.

Fig. 8: Captura de tela da função ledToggle do Particle Photon Code para o carro robótico controlado pela Internet

Isso completa o código do programa no Photon for Internet controlada Veículo robótico.

Código HTML

Para controlar o robô pela internet, é necessário criar uma página web.

Fig. 9: Captura de tela do código-fonte da página da Web que controla o carro robótico

O doctype é declarado para definir a página para a versão HTML 5 e o elemento head é adicionado. Dentro do elemento head, o conjunto de caracteres é definido como utf-8 e a página da web é definida para abranger toda a janela. O bootstrap para CSS e Javascript é incluído no CDN usando o elemento link.

O elemento body é declarado e um elemento de divisão adicional é declarado para conter o conteúdo da página da web. A página da web é estruturada por meio de outros elementos de divisão e alguns elementos de parágrafo de cabeçalho e botões são adicionados.

O javascript é incorporado no qual o ID do dispositivo e o token de acesso são declarados como variáveis e uma função switchLED é criada para formatar a string de comando a ser passada para o painel de partículas. A string de comando contém um número entre 1 e 4. Os elementos da página são acessados por meio da função JavaScript getElementbyID. Os dados do sensor são obtidos usando o método JSON.parse e incorporados aos elementos HTML usando o método innerHTML. O método $.Post é usado para recuperar dados da nuvem usando o método HTTP POST.

Este é um arquivo HTML que precisa ser executado para enviar dados ao serviço Particle's Cloud. O serviço de nuvem se conecta automaticamente ao Photon e o Code on Photon opera de acordo com os dados recebidos da nuvem.

Código fonte do projeto

###

//Program to 

// This #include statement was automatically added by the Particle IDE.

#include 


// DHT parameters

#define DHTPIN A0

#define DHTTYPE DHT11


// Variables

int temperature;

int humidity;

int light;

int light_sensor_pin = A1;

int uv = A3;

int pos = 0;

int value;

// Pins

int motor0 = D0;

int motor1 = D1;

int motor2 = D2;

int motor3 = D3;

// DHT sensor

DHT dht(DHTPIN, DHTTYPE);


// publishjson.ino -- Spark Publishing Example 

unsigned long lastTime = 0UL;

char publishString(64);


void setup  {

    Serial1.begin(9600);

    pinMode(motor0,OUTPUT);

    pinMode(motor1,OUTPUT);

    pinMode(motor2,OUTPUT);

    pinMode(motor3,OUTPUT);

    digitalWrite(motor0,LOW);

    digitalWrite(motor1,LOW);

    digitalWrite(motor2,LOW);

    digitalWrite(motor3,LOW);

    dht.begin ;

    // We are also going to declare a Particle.function so that we can turn the LED on and off from the cloud.

    Particle.function("led",ledToggle);

}


void loop  {

  

   // Temperature measurement

    temperature = dht.getTempCelcius ;

    

    // Humidity measurement

    humidity = dht.getHumidity ;

    

    // Light level measurement

    float light_measurement = analogRead(light_sensor_pin);

    light = (int)(light_measurement/4096*100);


    unsigned long now = millis ;

    //Every 5 seconds publish uptime

    if (now-lastTime>5000UL) {

        lastTime = now;

    sprintf(publishString,"{"Temperature": %u, "Humidity": %u, "Light": %u}",temperature,humidity,light);

    Particle.publish("Uptime",publishString);

    digitalWrite(motor0,LOW);

    digitalWrite(motor1,LOW);

    digitalWrite(motor2,LOW);

    digitalWrite(motor3,LOW); 

    }

   

}



int ledToggle(String command) {

    value = command.toInt ;

    if (value == 1) {

        digitalWrite(motor0,HIGH);

        digitalWrite(motor1,LOW);

        digitalWrite(motor2,HIGH);

        digitalWrite(motor3,LOW);

        return 1;

    }

    else if (value == 2) {

        digitalWrite(motor1,HIGH);

        digitalWrite(motor0,LOW);

        digitalWrite(motor3,HIGH);

        digitalWrite(motor2,LOW);

        return 1;

    }

    else if(value == 3){

    digitalWrite(motor0,HIGH);

    digitalWrite(motor1,LOW);

    digitalWrite(motor2,LOW);

    digitalWrite(motor3,HIGH);

    return 1;

    }

    else if(value == 4){

    digitalWrite(motor0,LOW);

    digitalWrite(motor1,LOW);

    digitalWrite(motor2,HIGH);

    digitalWrite(motor3,LOW);

    return 1;

    }

    else {

    digitalWrite(motor0,LOW);

    digitalWrite(motor1,LOW);

    digitalWrite(motor2,LOW);

    digitalWrite(motor3,LOW);

    return 0;

    }


}
###