Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

WiDC:Robô FPV controlado por Wi-Fi

Componentes e suprimentos

Arduino UNO
× 1
Espressif ESP8266 ESP-01
× 1
Arduino Proto Shield
× 1
Motor DC com roda
× 1
H-bridge
× 1

Aplicativos e serviços online

Autodesk Fusion 360
Arduino IDE

Sobre este projeto




Que tal usar um robô com controle remoto para explorar os arredores, chegar a lugares inacessíveis, espiar, tirar fotos, fazer filmes ou transmitir um vídeo? Este tutorial vai mostrar como fazer um barato para todos esses fins!

Este tutorial é uma melhoria do meu tutorial anterior (https://www.instructables.com/id/Wi-fi-Controlled-FPV-Rover-Robot-with-Arduino-ESP8/), no qual apresento uma página inicial mais rápida feito robô. Ele mostra como projetar um robô de duas rodas controlado remotamente em uma rede Wi-Fi, usando dois motores DC, um Arduino Uno e um módulo ESP8266 Wi-fi.

O robô pode ser controlado a partir de um navegador comum da Internet, usando uma interface projetada em HTML. Um smartphone Android pode ser usado para transmitir vídeo e áudio do robô para a interface de controle.

Como em meu tutorial anterior, mostro como desenhar e construir uma estrutura de baixo custo para um projeto robótico, usando apenas ferramentas comuns (sem necessidade de impressora 3D, cortador a laser ou roteador CNC).

Pode-se notar que os componentes usados ​​aqui podem não ser otimizados para seu propósito. Um NodeMCU pode ser usado em vez da combinação Arduino + ESP8266, por exemplo. Um Rapsberry Pi com câmera substituiria o smartphone e controlaria os motores também. É até possível usar um smartphone Android como o "cérebro" do seu robô. Isso é verdade...

Este tutorial foi derivado de outro projeto do qual faço parte:Joy Robot (https://hackaday.io/project/12873-rob-da-alegria-joy-robot ou https://www.hackster.io/igorF2/ robo-da-alegria-joy-robot-85e178), e o mesmo hardware foi usado aqui para simplificar. Um Arduino Uno foi escolhido porque é muito acessível e fácil de usar para todos, e queríamos projetar um escudo simples para ele. Em nosso projeto original, também controlamos alguns servos e matrizes de LED, e interfaces com o ESP. Na verdade, o smartphone foi substituído por um tablet, que também executa outros aplicativos. Você pode encontrar outros tutoriais relacionados a esse robô nos links abaixo:

Controlando Matriz de LEDs com Arduino Uno:

https://www.instructables.com/id/Controlling-a-LED-Matrix-Array-With-Arduino-Uno/

Servo motores controlados por navegador Wi-Fi:

https://www.instructables.com/id/Wi-Servo-Wi-fi-Browser-Controlled-Servomotors-with/

Este guia pode ser adaptado e ter sua forma ou interface de controle alterada para atender às suas necessidades.

Neste outro tutorial, apresento uma maneira de controlar um robô de um smartphone usando o aplicativo Blynk! Confira:

https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198





Etapa 1:Ferramentas


As seguintes ferramentas foram utilizadas para a construção deste protótipo:

Ferramentas:
  • Serra manual (para cortar chapas de acrílico)
  • Chave de fenda (para colocar parafusos e porcas)
  • Régua (para medir as dimensões do modelo)
  • Faca utilitária (para cortar a estrutura e fazer orifícios)
  • Máquina de perfuração (usada para furar o acrílico para instalação dos parafusos)
  • Lixa (para alisar bordas irregulares)
  • Ferro de soldar (para terminais de motores de solda)
  • Um computador (para compilar e enviar o código Arduino)

Essas ferramentas foram utilizadas para a produção da estrutura mecânica do robô, montagem do robô e conexão de componentes eletrônicos. Algumas das ferramentas não são necessárias se você decidir comprar uma estrutura em vez de construir a sua própria.

Você pode até utilizar outros equipamentos (impressora 3D ou cortador a laser, por exemplo), dependendo das ferramentas disponíveis no seu makerpace.





Etapa 2:Estrutura e materiais mecânicos


Os seguintes materiais foram usados ​​na estrutura mecânica:

Materiais mecânicos:
  • Folha de acrílico de 2 mm
  • motor redutor DC com roda (x2)
  • Roda giratória de 30 mm (x1)
  • parafusos M2 x 10mm (x5)
  • porcas M2 x 1,5 mm (x5)
  • Parafusos M3 x 10mm (x9)
  • Parafusos M3 x 10mm (x9)
  • Parafusos M3 x 40 mm (x4)
  • porcas M3 x 1,5 mm (x12)
  • parafusos 5/32 "x 1" (x4)
  • 5/32 "nozes (x12)
  • Suporte universal para telefone
  • Suporte angular de aço em forma de "L" (30 x 30 mm) (x4)





Etapa 3:Componentes eletrônicos


Os seguintes componentes eletrônicos foram usados ​​neste robô:

• Arduino Uno (comprar / comprar)

• ESP8266 (comprar)

• Protoshield (para uma versão mais compacta) ou um breadboard comum (comprar)

• resistor de 1 kohm (x2)

• resistor de 10 kohm (x1)

• Motor redutor DC com roda (x2) (comprar)

• Módulo H-bridge (comprar)

• Alguns fios de ligação

• banco de energia 5V USB

Você pode encontrar todos os componentes online facilmente em sua loja de e-commerce favorita.

Como foi destacado na introdução deste tutorial, a escolha dos componentes foi derivada de outro projeto que desenvolvi, e podem ser otimizados usando um microcontrolador diferente, por exemplo.





Etapa 4:Projetando a estrutura


Primeiro, tive que projetar a estrutura mecânica do meu robô. Você também pode comprar a estrutura completa online se não quiser construir sua própria estrutura personalizada (há muitos kits robóticos disponíveis online). Nesse caso, você pode pular para a Etapa 6. Para este tutorial, uma moldura de acrílico de baixo custo foi projetada para a fixação dos motores e outros componentes. A estrutura apresentada neste tutorial foi projetada em 3D usando o software Fusion 360 CAD e construída com ferramentas comuns (nenhuma impressora 3D, cortador a laser ou roteador CNC são necessários). Você pode usar os mesmos princípios descritos abaixo para projetar uma estrutura personalizada que atenda às suas necessidades.

Primeiro tive que fazer um modelo 3D dos componentes principais, a fim de decidir a disposição da estrutura. Alguns deles foram baixados da GrabCAD Comunity Library ( https://grabcad.com/library ):
  • Arduino Uno (https://grabcad.com/library/arduino-uno-13)
  • Motor de engrenagens (https://grabcad.com/library/bomotor-1)
  • H-bridge (https://grabcad.com/library/motor-driver-l9110-1)
  • Banco de potência (https://grabcad.com/library/power-bank-7)
  • Suporte universal para telefone (https://grabcad.com/library/universal-phone-holder-for-the-gopro-accessories-1)

Os componentes eletrônicos foram dispostos em um plano, para que eu pudesse descobrir a necessidade de pegada do meu robô. Depois disso, tive que escolher a posição dos motores e rodas para criar uma estrutura estável.

A partir dessas posições, foi projetada a estrutura principal, que é composta por três placas (uma placa de base e duas placas laterais) que são conectadas por meio de alguns suportes.
base.pdf base.svg





Etapa 5:construção e montagem da estrutura


A construção da estrutura da base divide-se nas seguintes etapas: 1. Corte a base de acrílico de acordo com as dimensões no desenho 2D: Isso pode ser feito com um cortador a laser (se você tiver acesso a um) ou, como no meu caso, com ferramentas comuns.

Primeiro, você precisará transferir as dimensões do seu modelo para a folha de acrílico. Imprima seu desenho 2D usando uma impressora comum em um papel adesivo, depois corte o papel nas dimensões adequadas e aplique aquela máscara na superfície do acrílico. Com uma faca e com a ajuda de uma régua ou escala, corte o acrílico em linhas retas. Você não precisará cortar totalmente a folha, apenas pontue-a para criar algumas trilhas onde a peça será cortada posteriormente. Coloque o acrílico sobre uma superfície plana, segure-o no lugar com alguns grampos e aplique um pouco de pressão até que a folha se parta em duas. Repita este processo até que todos os cortes sejam feitos. Depois disso, você pode usar uma lixa para alisar as arestas. Você também pode usar uma serra manual para cortar o acrílico. 2. Faça os furos nas posições mostradas no desenho 2D: Faça os furos nas posições mostradas no desenho 2D (indicado na máscara) com uma furadeira. O acrílico é relativamente fácil de perfurar. Portanto, se você não descarta uma furadeira, pode fazer os furos manualmente com uma ferramenta afiada, como uma faca. Você também pode usá-lo para aumentar pequenos orifícios para se ajustar ao tamanho dos parafusos. Remova a máscara e sua base estará pronta.

3. Monte os componentes com parafusos e porcas de acordo com o desenho 3D: Monte os componentes com parafusos e porcas de acordo com o vídeo, e sua estrutura estará pronta para funcionar. Parafusos M3 são usados ​​para a instalação dos suportes e motores DC. Para a instalação dos componentes eletrônicos foram utilizados os parafusos M2 e os de 5/32 "para a instalação da roda dianteira e do clipe do smartphone. Agora faça uma pausa e comece a montar o circuito na etapa seguinte ...
base.pdf





Etapa 6:montagem da eletrônica


O circuito proposto aqui usa um Arduino Uno como controlador principal, que faz interface com um ESP8266 para comunicação Wi-Fi. O Arduino controla os motores DC por meio de um circuito de acionamento H-brige, que é capaz de controlar até dois motores giratórios eles de forma independente em ambas as direções.

Um banco de energia foi usado para alimentar os componentes eletrônicos, conectado diretamente à porta USB do Arduino. Esta é uma maneira fácil de alimentar seu Arduino:fácil de carregar, pode ser facilmente substituído e fornece uma tensão de 5 V segura.

Conecte todos os componentes de acordo com o esquema. Você precisará de alguns fios de jumper para conectar o módulo ESP8266, que não é compatível com protoboard, h-bridge e motores DC. Você pode usar um proto-escudo (para um circuito mais compacto), uma placa de ensaio comum ou projetar seu próprio escudo Arduino.

Você notará que o ESP8266-1 não é compatível com breadboard. Ele será conectado usando alguns fios de jumper, mas não será conectado à estrutura.

Conecte um cabo USB à placa do Arduino e prossiga para a próxima etapa.
wiDC_Esquem_C3_A1tico.pdf wiDC.fzz wiDC_bb.pdf





Etapa 7:Código Arduino


Instale o IDE Arduino mais recente. Nenhuma biblioteca foi necessária para comunicação com o módulo ESP-8266 ou controle dos motores. Verifique a taxa de transmissão de seu ESP8266 e defina-a corretamente no código. Baixe o código do Arduino (WiDC.ino) e substitua o XXXXX pelo SSID do roteador wi-fi e YYYYY pela senha do roteador. Conecte a placa Arduino à porta USB do seu computador e faça o upload do código.

Conecte um cabo USB à placa do Arduino e prossiga para a próxima etapa.
  // inclui bibliotecas # include  SoftwareSerial esp8266 (3, 2); // RX pin =3, TX pin =2 // definição de variáveis ​​# define DEBUG true // mostra mensagens entre ESP8266 e Arduino em serial portint state =5; // define o estado inicial do robô (5 =stand-by) // define os pinos do motorconst int motor1Pin1 =5; const int motor1Pin2 =6; const int motor2Pin1 =9; const int motor2Pin2 =10; // define a velocidade do motorint motorSpeed ​​=150; // velocidade do motor (PWM) // ***** // CONFIGURAÇÃO // ***** void setup () {// definir modos de pino pinMode (motor1Pin1, OUTPUT); pinMode (motor1Pin2, OUTPUT); pinMode (motor2Pin1, OUTPUT); pinMode (motor2Pin2, OUTPUT); // inicia a comunicação Serial.begin (9600); esp8266.begin (9600); sendData ("AT + RST \ r \ n", 2000, DEBUG); // redefine o módulo sendData ("AT + CWMODE =1 \ r \ n", 1000, DEBUG); // definir o modo da estação sendData ("AT + CWJAP =\" XXXXX \ ", \" YYYYY \ "\ r \ n", 2000, DEBUG); // conecte a rede wi-fi (substitua XXXXX pelo SSID do roteador Wi-Fi e YYYYY pelo atraso da senha (5000); // aguarde a conexão sendData ("AT + CIFSR \ r \ n", 1000, DEBUG); / / mostrar endereço IP sendData ("AT + CIPMUX =1 \ r \ n", 1000, DEBUG); // permitir conexões múltiplas sendData ("AT + CIPSERVER =1,80 \ r \ n", 1000, DEBUG); / / iniciar servidor web na porta 80} // ********* // MAIN LOOP // ********* void loop () {if (esp8266.available ()) // verificar dados de entrada {if (esp8266.find ("+ IPD,")) // se houver uma mensagem {String msg; esp8266.find ("?"); // procure a mensagem msg =esp8266.readStringUntil ('' ); // ler a mensagem inteira String command =msg.substring (0, 3); // primeiros 3 caracteres =comando Serial.println (command); // avançar if (command =="cm1") {state =1;} // retroceder if (command =="cm2") {state =2;} // virar à direita if (command =="cm3") {state =3;} // virar à esquerda if (command ==" cm4 ") {state =4;} // não fazer nada if (command ==" cm5 ") {state =5;}}} // ESTADO 1:avançar if (state ==1) {analogWrite (m otor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } // ESTADO 2:retroceder if (state ==2) {digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ESTADO 3:mova para a direita if (estado ==3) {analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ESTADO 4:mover para a esquerda if (state ==4) {digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } // ESTADO 5:não fazer nada se (estado ==5) {digitalWrite (motor1Pin1, BAIXO); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); digitalWrite (motor2Pin2, LOW); }} // ******************* // Funções auxiliares // ******************* String sendData (Comando String, tempo limite int const, depuração booleana) {Resposta String =""; esp8266.print (comando); tempo interno longo =milis (); while ((tempo + tempo limite)> millis ()) {while (esp8266.available ()) {char c =esp8266.read (); resposta + =c; }} se (depurar) {Serial.print (resposta); } resposta de retorno;}  

Código explicado:

O código usa uma porta serial para a comunicação entre o Arduino e o ESP8266 e outra para a comunicação entre o Arduino e um computador. Uma vez que o Arduino Uno possui apenas uma porta serial, a biblioteca SoftwareSeial foi usada para criar uma porta secundária, usando os pinos digitais 2 e 3.
  // inclui bibliotecas # include  SoftwareSerial esp8266 (3, 2); // RX pin =3, TX pin =2  

Durante a configuração, ambas as comunicações seriais devem ser iniciadas e sua taxa de transmissão definida (uma entre o Arduino e seu monitor serial e outra para corresponder à velocidade ESP8266). Observe que meu ESP8266 foi definido para 9600 kbps. Por padrão, a maioria desses módulos vem com 115200kbps, mas a biblioteca SoftwareSerial não pode funcionar nessa velocidade e você terá que alterar sua taxa de transmissão. Para mim, 9600 kbps funcionou bem.

Neste projeto não usei uma biblioteca específica para a comunicação com o módulo wi-fi. Em vez disso, apenas os seguintes comandos AT comuns (um conjunto de instruções definido no firmware padrão ESP8266) foram usados:
  • AT + RST:reinicie o módulo ESP8266
  • AT + CWMODE:definir módulo para modo de estação ou ponto de acesso
  • AT + CWJAP:conecte uma rede Wi-Fi fornecida por seu SSID e senha
  • AT + CIPMUX:definir módulo para conexões múltiplas ou conexão única
  • AT + CIPSERVER:inicia o servidor da web em uma determinada porta // inicia a comunicação
  Serial.begin (9600); esp8266.begin (9600); sendData ("AT + RST \ r \ n", 2000, DEBUG); // redefine o módulo sendData ("AT + CWMODE =1 \ r \ n", 1000, DEBUG); // definir o modo da estação sendData ("AT + CWJAP =\" XXXXX \ ", \" YYYYY \ "\ r \ n", 2000, DEBUG); // conecte a rede wi-fi (substitua XXXXX pelo SSID do roteador Wi-Fi e YYYYY pelo atraso da senha (5000); // aguarde a conexão sendData ("AT + CIFSR \ r \ n", 1000, DEBUG); / / mostrar endereço IP sendData ("AT + CIPMUX =1 \ r \ n", 1000, DEBUG); // permitir conexões múltiplas sendData ("AT + CIPSERVER =1,80 \ r \ n", 1000, DEBUG); / / start servidor web na porta 80  

Uma função auxiliar (sendData) é usada para enviar dados (do Arduino para o ESP8266), lendo e exibindo a resposta no Serial Monitor.
  String sendData (comando String, tempo limite const int, depuração booleana) {String response =""; esp8266.print (comando); tempo interno longo =milis (); while ((tempo + tempo limite)> millis ()) {while (esp8266.available ()) {char c =esp8266.read (); resposta + =c; }} se (depurar) {Serial.print (resposta); } resposta de retorno;}  

Usar o código acima faz com que o Arduino reinicie o módulo, entre em uma rede, espere algum tempo pela conexão, depois mostre seu endereço IP e inicie um servidor web. Depois disso, o loop principal será iniciado e o microcontrolador aguardará os comandos.
  void loop () {if (esp8266.available ()) // verificar os dados de entrada {if (esp8266.find ("+ IPD,")) // se houver uma mensagem {String msg; esp8266.find ("?"); // procure a mensagem msg =esp8266.readStringUntil (''); // lê a mensagem inteira String command =msg.substring (0, 3); // primeiros 3 caracteres =comando Serial.println (comando); // avança if (command =="cm1") {state =1; } // retrocede if (command =="cm2") {state =2; } // vire à direita if (command =="cm3") {state =3; } // vire à esquerda if (command =="cm4") {state =4; } // não faça nada if (command =="cm5") {state =5; }}}  

Cinco comandos possíveis foram definidos (cm1 a cm5). Sempre que o Arduino recebe um desses comandos, ele entra em um dos cinco estados possíveis (para frente, para trás, para a direita, para a esquerda e em espera) e continua nesse estado até receber um comando diferente.

Cada estado define os sinais para os pinos dos motores. Usei digitalWrite (pin, LOW) quando queria definir um pin para 0V e analogWrite (pin, motoSpeed) quando queria ligar um pin. Usar analogWrite me permitiu mudar a velocidade do motor e fazer o robô se mover mais devagar.
  // ESTADO 1:avançar if (estado ==1) {analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } // ESTADO 2:retroceder if (state ==2) {digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ESTADO 3:mova para a direita if (estado ==3) {analogWrite (motor1Pin1, motorSpeed); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); analogWrite (motor2Pin2, motorSpeed); } // ESTADO 4:mover para a esquerda if (state ==4) {digitalWrite (motor1Pin1, LOW); analogWrite (motor1Pin2, motorSpeed); analogWrite (motor2Pin1, motorSpeed); digitalWrite (motor2Pin2, LOW); } // ESTADO 5:não fazer nada se (estado ==5) {digitalWrite (motor1Pin1, BAIXO); digitalWrite (motor1Pin2, LOW); digitalWrite (motor2Pin1, LOW); digitalWrite (motor2Pin2, LOW); }  

Observe que os motores funcionam entre 3 e 6V. Uma vez que uma fonte de alimentação de 5 V é usada, você pode modular a tensão média dos motores (usando PWM) entre 3 e 5 V, alterando assim sua velocidade. Não vai permitir que você controle a velocidade do robô
WiDC.ino





Etapa 8:Interface de controle baseada na web


Uma interface html foi projetada para o controle do robot.Download interface.rar e extrair todos os arquivos para uma determinada pasta. Em seguida, abra-o no Firefox. Uma forma de caixa de texto é usada nessa interface para inserir os endereços IP do módulo ESP e do servidor de vídeo / áudio (do aplicativo Android IP Webcam). Existe um teste mas, que fará o robô girar até que um comando seja recebido. As teclas de seta do teclado são usadas para mover o robô para frente ou para trás e para girar para a esquerda ou direita. Um smartphone Android foi usado para transmitir o vídeo e o áudio do robô para a interface de controle. Você pode encontrar o aplicativo na Google Play Store (https://play.google.com/store/apps/details?id=com.pas.webcam).Instale-o e siga para a próxima etapa.

Código HTML explicado:

A interface html tem duas divisões:uma para áudio e vídeo (do servidor Android IP Webcam) e outra para os comandos.

A divisão de áudio e vídeo tem uma forma com uma caixa de texto como botão. Isso é usado como uma entrada para especificar o endereço IP do servidor da webcam e carregá-lo. Ele vem com um endereço IP padrão (192.168.0.5), mas o uso pode inserir um IP diferente. Vídeo e áudio são carregados em objetos abaixo da caixa de texto.
  
IP Webcam ( IP):

A outra divisão possui outro formulário com uma caixa de texto, para que o usuário possa informar seu endereço IP ESP8266.
  
Endereço IP do Arduino:

Pressione e segure as teclas de seta do teclado para mover o robô


JavaScript é usado para lidar com a interface e enviar dados para o Arduino. Esses scripts são codificados em arquivos diferentes e adicionados no cabeçalho html.
      Interface de controle      

Javascript explicado:

Uma função (readUrlAV) é usada para ler o endereço IP do formulário html e carregá-los em objetos de "vídeo" e "áudio".
  função readUrlAV (form) {TextVar =form.inputbox.value; VideoVar ="http://" + TextVar + ":8080 / vídeo"; AudioVar ="http://" + TextVar + ":8080 / audio.opus"; document.getElementById ("video"). setAttribute ('data', VideoVar); document.getElementById ("audio"). setAttribute ('data', AudioVar);}  

O script lê o teclado periodicamente, esperando que o usuário pressione qualquer tecla. Se o usuário pressionar qualquer tecla de seta (esquerda ='37', cima ='38', direita ='39' ou 'baixo' =40), ele envia um comando ("cm1" a "cm4") para um determinado IP Morada. Observe que há uma função de trava, que evita que o mesmo comando seja repetido indefinidamente. Os dados serão transferidos apenas quando a tecla for pressionada.
  var latch =false; document.onkeydown =checkKeyDown; função checkKeyDown (e) {e =e || window.event; if (e.keyCode =='38') {// seta para cima if (latch ==false) {TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $ .get (ArduinoVar, {"cm1":1000}); {Conexão:fechar}; trava =verdadeiro; } } else if (e.keyCode =='40') { // down arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm2":1000 }); {Connection:close}; latch =true; } } else if (e.keyCode =='37') { // left arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm3":1000 }); {Connection:close}; latch =true; } } else if (e.keyCode =='39') { // right arrow if (latch ==false) { TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm4":1000 }); {Connection:close}; latch =true; } }} 

When any arrow key is released, doNothing function is executed, which sends command "cm5" (stop the motors), and resets the latch, allowing interface to send differente commands.
document.onkeyup =checkKeyUp;function checkKeyUp(e) { e =e || window.event; if ((e.keyCode =='38')||(e.keyCode =='40')||(e.keyCode =='37')||(e.keyCode =='39')) { setTimeout(doNothing, 200); }}function doNothing(){ TextVar =myform2.inputbox.value; ArduinoVar ="http://" + TextVar + ":80"; $.get( ArduinoVar, { "cm5":1000 }); {Connection:close}; latch =false;}  
interface.rar





Step 9:Usage


When the Arduino is restarted, it will try to connect your wi-fi network automatically. Use the Serial Monitor to check if the connection was successfull, and to obtain which IP was assigned to your ESP-8266 by your router. Open the html file in an internet browser (Firefox) and inform this IP address in the textbox.You might also user other means to find out which IP address you router assigned to your device. Disconnect the the Arduino Uno from your computer and connect it to the power bank. Wait for it to connect again. Launch IP Webcam app in the smartphone attached to the robot. Type the video/audio IP on your control interface and connect to the server and you'll be ready to go. You might need to reduce the resolution of the video in the app to reduce the delay between during the transmission. Click and hold the arrow buttons of your keyboar to rotate the robot or move it forward/backward and have fun exploring your environment.

Notice that robot runs on open loop. This way, it's quite difficult to make it move straight forward. Small difference between the motors, aligment, etc. will cause cumulative deviations.

The robot start moving when it receives a given command ("cm1" to "cm4"), and keep that state until a different command is received ("cm1" to "cm5"). Sometimes the ESP8266 loses some messages, and that might cause some trouble. If, for instance, a "cm5" command is lost, the robot will keed moving even after any arrow key was released. I'm still dealing with this problem. Feel free to change the way the commands are interpreted to avoid this kind of problem.

Código

  • Arduino code
  • Interface
Arduino codeArduino
//include libraries#include SoftwareSerial esp8266(3, 2); //RX pin =3, TX pin =2//definition of variables#define DEBUG true //show messages between ESP8266 and Arduino in serial portint state =5; //define initial state of the robot (5 =stand-by)//define motor pinsconst int motor1Pin1 =5;const int motor1Pin2 =6;const int motor2Pin1 =9;const int motor2Pin2 =10;//define motor speedint motorSpeed =150; //motor speed (PWM)//*****//SETUP//*****void setup(){ //set pin modes pinMode(motor1Pin1, OUTPUT); pinMode(motor1Pin2, OUTPUT); pinMode(motor2Pin1, OUTPUT); pinMode(motor2Pin2, OUTPUT); //start communication Serial.begin(9600); esp8266.begin(9600); sendData("AT+RST\r\n", 2000, DEBUG); //reset module sendData("AT+CWMODE=1\r\n", 1000, DEBUG); //set station mode sendData("AT+CWJAP=\"XXXXX\",\"YYYYY\"\r\n", 2000, DEBUG); //connect wi-fi network (replace XXXXX by your Wi-Fi router SSID and YYYYY by its password delay(5000); //wait for connection sendData("AT+CIFSR\r\n", 1000, DEBUG); //show IP address sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); //allow multiple connections sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // start web server on port 80}//*********//MAIN LOOP//*********void loop(){ if (esp8266.available()) //verify incoming data { if (esp8266.find("+IPD,")) //if there is a message { String msg; esp8266.find("?"); //look for the message msg =esp8266.readStringUntil(' '); //read whole message String command =msg.substring(0, 3); //first 3 characters =command Serial.println(command); //move forward if(command =="cm1") { state =1; } //move backward if(command =="cm2") { state =2; } //turn right if(command =="cm3") { state =3; } //turn left if(command =="cm4") { state =4; } //do nothing if(command =="cm5") { state =5; } } } //STATE 1:move forward if (state ==1) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 2:move backward if (state ==2) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 3:move right if (state ==3) { analogWrite(motor1Pin1, motorSpeed); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); analogWrite(motor2Pin2, motorSpeed); } //STATE 4:move left if (state ==4) { digitalWrite(motor1Pin1, LOW); analogWrite(motor1Pin2, motorSpeed); analogWrite(motor2Pin1, motorSpeed); digitalWrite(motor2Pin2, LOW); } //STATE 5:do nothing if (state ==5) { digitalWrite(motor1Pin1, LOW); digitalWrite(motor1Pin2, LOW); digitalWrite(motor2Pin1, LOW); digitalWrite(motor2Pin2, LOW); } }//*******************//Auxiliary functions//*******************String sendData(String command, const int timeout, boolean debug){ String response =""; esp8266.print(command); long int time =millis(); while ( (time + timeout)> millis()) { while (esp8266.available()) { char c =esp8266.read(); response +=c; } } if (debug) { Serial.print(response); } return response;}
InterfaceHTML
 Sem visualização (apenas download). 

Peças personalizadas e gabinetes

base_7JLgOpcox6.svg

Esquemas


Processo de manufatura

  1. Robô Raspberry Pi controlado por Bluetooth
  2. Dados digitais Arduino
  3. Controlador de jogo Arduino
  4. Robô seguidor de linha
  5. Robô controlado por fala
  6. MobBob:DIY Arduino Robot Controlado por Smartphone Android
  7. Jogo Pixel Chaser
  8. Levitação eletromagnética repulsiva Arduino
  9. Robô de piano controlado por Arduino:PiBot
  10. Robô assistente autônomo da casa