Faça um robô conectado à Web (por cerca de US $ 500) (usando um Arduino e um netbook): 6 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:40

Este Instructable mostrará como construir seu próprio Web Connected Robot (usando um microcontrolador Arduino e Asus eee pc). Por que você quer um Web Connected Robot? Para brincar, é claro. Dirija seu robô pela sala ou pelo país, usando nada mais do que Skype e um navegador da web (nada para instalar no computador de controle). Depois disso? Explore o software e adapte-o como quiser, adicione um GPS para que você possa observar onde está dirigindo em um mapa, adicione sensores de temperatura para mapear gradientes de temperatura em sua casa ou sensores de sonar para adicionar controles sobre o que você está na web os motoristas podem e não podem correr. Recursos:

• Barato - (~ $ 500 se você comprar todas as peças novas e consideravelmente mais barato se você vasculhar a caixa de peças)
• Uma vez instalado e funcionando, o controle do robô requer apenas um navegador da web - (e o Skype se você quiser ver para onde está dirigindo)
• Código aberto e facilmente adaptável - (usa um microcontrolador Arduino, processamento para o servidor da web e todo o software pode ser executado no Linux (todo o código também é muito comentado para facilitar a mudança e a mudança))
• Design modular (não é um sistema completamente integrado, se você quiser usar um serviço de videoconferência diferente, não se preocupe, ou se você tiver um carimbo básico em vez de um Arduino, basta corrigir um pequeno pedaço de código e encaixá-lo)

Aqui está um vídeo rápido de meu Web Connected Robot sendo expulso da cozinha.

Etapa 1: Peças e Ferramentas

Apenas algumas partes são necessárias: Robô: Arduino Controlled Servo Robot - (SERB) ($ 175 @ oomlout.com) ou (faça o seu próprio)

Um robô de código aberto que usa um microcontrolador Arduino como seu cérebro

(qualquer plataforma de robô servo duplo com um arduino pode ser usada (opção 1) (envie uma mensagem se descobrir alguma outra opção) Computador: Asus eee PC 4G ($ 280) (@Best Buy)

Um pequeno laptop barato que é perfeito para essa finalidade

(qualquer laptop (ou desktop se você quiser rodar com um chord) capaz de rodar Processing sketches pode ser usado) Laptop Desk: Laser Cut Acrylic ($ 25 (@ oomlout)) ou (construa seu próprio passo 3)

Algumas peças de acrílico adicionais que são aparafusadas em um (SERB) para dar a ele uma mesa para o laptop se sentar

Nuts and Bols: (disponível em home depot)

• Parafuso de 3 mm x 10 mm (x 4)
• Parafuso de 3 mm x 15 mm (x 4)
• Porca de 3 mm (x8)

Etapa 2: Corte e montagem de peças

Existem três opções para obter peças para a mesa do seu laptop. Opção de corte 1: (Compra em oomlout.com)

peças de mesa cortadas a laser e o hardware necessário estão disponíveis na oomlout por US $ 25 (aqui)

Opção 2: (Corte em seu próprio cortador a laser ou Ponoko.com)

• Baixe o arquivo abaixo (03-WEBB-Acrylic Parts.cdr ou 03-WEBB-Acrylic Parts (Ponoko P2).eps)
• Corte-os em acrílico de 3 mm (1/8 ")

Opção 3: (serra de rolagem)

• Baixe o padrão de serra em espiral abaixo (03-WEBB-ScrollSaw Pattern (A4).pdf (para papel tamanho A4) ou 03-WEBB-ScrollSaw Pattern (carta).pdf (para papel tamanho carta))
• Verifique se ele não foi dimensionado durante a impressão (medindo as réguas impressas)
• Cole em um pedaço de acrílico de 3 mm (1/8 ") e corte os pedaços.

Montagem: Baixe o guia de montagem (04-WEBB-Assembly Guide.pdf) abaixo e monte a mesa do laptop.

Etapa 3: Software - (Arduino)

Para aqueles que são novos no Arduino, confira o excelente guia de primeiros passos em Arduino.cc. Primeiro, veja o software em execução no Arduino. É um programa muito simples, o que o Arduino faz é monitorar sua porta serial em busca de dados. O que ele está procurando é uma conversação de 5 bytes.

• Byte 1-3 (verifique os bytes "AAA")
• Comando Byte 4 (Diz ao arduino o que fazer) (Comandos suportados 'F' - Avançar, 'B' - Retroceder, 'L' - Esquerda, 'R' - Direita, 'S' - Velocidade, 'X' - SetSpeedLeft, 'Y' - SetSpeedRight, 'C' - Parar)
• Parâmetro do Byte 5 - Para os comandos de movimento, é interpretado como um intervalo de tempo (Parâmetro * 100 ms), e para os comandos de velocidade, uma porcentagem de 0-100

O código é comentado minuciosamente e, dado esta estrutura, adicionar comandos adicionais deve ser fácil. Para fazer o download:

• Baixe o arquivo zip anexado. (05-WEBB-Arduino Code.zip)
• Descompacte para o diretório do Arduino Sketch. (padrão: My Documents / Arduino)
• Abra o ambiente de desenvolvimento do Arduino e faça upload para o Arduino.

Para copiar e colar

• Copie o código abaixo.
• Cole no ambiente de desenvolvimento do Arduino.
• Faça upload para o seu Arduino.

Apêndice: O Programa Arduino

/ * * Arduino Controlled Web Connected Robot (WEBB) - Serial Host * Para obter mais detalhes, visite: https://www.oomlout.com/serb * * Comportamento: O Arduino escuta sua porta serial para um comando * no formato 254, 88, 88, (COMANDO), (TIME) * Comandos suportados - & aposF & apos - 70 - Avançar * & aposB & apos - 66 - Retroceder * & aposL & apos - 76 - Esquerda * & aposR & apos - 82 - Direita * & aposS & apos - 83 - Velocidade * & aposX & apos - 88 - SetSpeedLeft * & aposY & apos - 89 - SetSpeedRight * & aposC & apos - 67 - Stop * Tempos suportados - 0 - 255 (0 a 25,5 segundos) valor * 100 milissegundos * sp * Fiação: Sinal do servo direito - pino 9 * Sinal do servo esquerdo - pino 10 * * Licença: Este trabalho está licenciado sob a licença Creative Commons * Attribution-Share Alike 3.0 Unported. Para * visualizar uma cópia desta licença, visite * https://creativecommons.org/licenses/by-sa/3.0/ * ou envie uma carta para Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * EUA. * * / // --------------------------------------------- ---------------------------- // INÍCIO DO ARDUINO SERIAL SERVER PREÂMBULO // Definindo constantes correspondentes a cada comando (também o número do código ascii) #define FORWARD 70 // F # define BACKWARD 66 // B # define LEFT 76 // L # define RIGHT 82 // R # define SETSPEED 83 // S # define STOP 67 // C # define SETSPEEDLEFT 88 // X #define SETSPEEDRIGHT 89 // Y / * Os três bytes de verificação (usados para evitar que o robô responda a dados * seriais aleatórios) atualmente "AAA" * / # define checkByte1 65 // "A" #define checkByte2 65 // "A "#define checkByte3 65 //" A "// -------------------------------------- ------------------------------------ // INÍCIO DO SERVO ROBÔ COM ARDUINO CONTROLADO (SERB) PREÂMBULO # inclui #define LEFTSERVOPIN 10 // O pino do servo esquerdo está conectado # define RIGHTSERVOPIN 9 // O pino do servo direito está conectado ao servo leftServo; Servo direitoServo; int leftSpeed = 50; // mantém a velocidade dos robôs leftServo // uma porcentagem entre 0 e 100int rightSpeed = 100; // mantém a velocidade dos robôs rightServo // uma porcentagem entre 0 e 100 // FIM DO ARDUINO SERVO ROBÔ CONTROLADO (SERB) PREÂMBULO // ------------------- -------------------------------------------------- ----- // Coloca tudo pronto e em execuçãovoid setup () {Serial.begin (9600); // Inicia a porta serial serbSetup (); // define o estado de todos os // pinos necessários e adiciona servos ao seu esboço} // O programa principal loopvoid loop () {serbPollSerialPort (); // olha continuamente para a porta serial // se houver dados, ele os processa} // ------------------------------ ----------------------------------------- // INÍCIO DAS ROTINAS DO SERVIDOR SERIAL ARDUINO / * * Processa comandos entregues à porta serial do arduino & aposs * / void serbPollSerialPort () {int dta; // variável para armazenar o byte serial if (Serial.available ()> = 5) {// se 5 bytes estiverem no buffer (comprimento de uma solicitação completa) dta = Serial.read (); if (dta = checkByte1) {// Verifica o primeiro byte de verificação dta = Serial.read (); if (dta = checkByte2) {// Verifica o segundo byte de verificação dta = Serial.read (); if (dta = checkByte3) {// Verifica o terceiro byte de verificação int command = Serial.read (); // O quarto byte é o comando int param1 = Serial.read (); // O quinto byte é param1 interpretCommand (command, param1); // envia a solicitação analisada para o manipulador & aposs}}}}} / * * Pega o comando e o parâmetro e passa para o robô * / void interpretCommand (comando int, param1 int) {if (comando == FORWARD) {goForward (); atraso (param1 * 100); goStop ();} // se encaminhar else if (comando == BACKWARD) {goBackward (); atraso (param1 * 100); goStop ();} // se para trás else if (command == LEFT) {goLeft (); atraso (param1 * 100); goStop ();} // se deixado else if (command == RIGHT) {goRight (); atraso (param1 * 100); goStop ();} // se estiver certo else if (command == SETSPEED) {setSpeed (param1);} // se definir a velocidade else if (command == STOP) {goStop ();} // se parar else if (command == SETSPEEDLEFT) {setSpeedLeft (param1);} // se definir a velocidade à esquerda else if (command == SETSPEEDRIGHT) {setSpeedRight (param1);} // se definir a velocidade certa else {// se o comando não reconhecido, faça um pequeno shimmey vá para esquerda(); atraso (150); vá para a direita(); atraso (150); goStop (); }} // ---------------------------------------------- -------------------------- // INÍCIO DAS ROTINAS DO SERVO-ROBÔ CONTROLADO POR ARDUINO (SERB) / * * configura seu arduino para endereçar seu SERB usando as rotinas incluídas * / void serbSetup () {setSpeed (leftSpeed); pinMode (LEFTSERVOPIN, OUTPUT); // define o pino do servo-sinal esquerdo // para output pinMode (RIGHTSERVOPIN, OUTPUT); // define o pino do sinal servo direito // para a saída leftServo.attach (LEFTSERVOPIN); // anexa o servo esquerdo rightServo.attach (RIGHTSERVOPIN); // anexa o servo direito goStop ();} / * * define a velocidade do robô entre 0- (parado) e 100- (velocidade total) * NOTA: a velocidade não mudará a velocidade atual, você deve alterar a velocidade * e então chamar um dos métodos go antes que as alterações ocorram. * / void setSpeed (int newSpeed) {setSpeedLeft (newSpeed); // define a velocidade à esquerda setSpeedRight (newSpeed); // define a velocidade certa} / * * Define a velocidade da roda esquerda * / void setSpeedLeft (int newSpeed) {if (newSpeed> = 100) {newSpeed = 100;} // se a velocidade é maior que 100 // faça 100 if (newSpeed = 100) {newSpeed = 100;} // se a velocidade for maior que 100 // torná-la 100 if (newSpeed <= 0) {newSpeed = 0;} // se a velocidade for menor que 0 faça // it 0 rightSpeed = newSpeed * 0,9; // dimensiona a velocidade para ser} / * * envia o robô para frente * / void goForward () {leftServo.write (90 + leftSpeed); rightServo.write (90 - rightSpeed);} / * * envia o robô para trás * / void goBackward () {leftServo.write (90 - leftSpeed); rightServo.write (90 + rightSpeed);} / * * envia o robô para a direita * / void goRight () {leftServo.write (90 + leftSpeed); rightServo.write (90 + rightSpeed);} / * * envia o robô para a esquerda * / void goLeft () {leftServo.write (90 - leftSpeed); rightServo.write (90 - rightSpeed);} / * * pára o robô * / void goStop () {leftServo.write (90); rightServo.write (90);} // FIM DAS ROTINAS DO SERVO ROBÔ CONTROLADO DE ARDUINO (SERB) // ---------------------------- -----------------------------------------------

Etapa 4: Software - Robot Laptop (WebServer)

(Processing é uma linguagem de programação de código aberto e um ambiente muito fácil de começar. Para obter mais detalhes, visite Processing). O software que roda no laptop robô também é bastante simples. É um servidor da Web bastante rudimentar (ouvindo solicitações de páginas da Web de um navegador da Web), uma pequena interface de usuário (para configurá-lo) e recursos para passar os comandos recebidos do servidor da Web para o Arduino. Para instalar rapidamente: (no windows)

• Baixe o arquivo zip abaixo (06-WEBB-Processing Webserver (windows exe).zip)
• Descompacte-o e execute o arquivo.exe (_WEBB_WebServer_RobotComputer.exe)

Para editar no processamento:

• Baixe o arquivo zip abaixo (06-WEBB-Processing Webserver (arquivos de origem).zip)
• Descompacte em qualquer lugar do seu computador.
• Abra o ambiente de processamento e abra (_WEBB_WebServer_RobotComputer.pde)

Testar:

• Execute o programa.
• Na caixa 1, haverá uma lista das portas de comunicação disponíveis em seu computador (clique naquela à qual seu Arduino está conectado. (Seu robô se contorcerá algumas vezes enquanto o computador se conecta, e um ponto ciano aparecerá ao lado do escolhido porta de comunicação)
• Na caixa nº 2, teste para ver se seu Arduino está conectado. Clique em uma das setas e esperançosamente seu robô se moverá na direção clicada por meio segundo.
• Na caixa nº 3, clique no botão "Iniciar" para iniciar o servidor web.
• Abra um navegador da web (no Laptop Robot) e visite https://127.0.0.1:12345/ControlPage.html (espero que a página da web de controle com botões apareça) -Detalhes sobre como usar esta página na próxima etapa -

O que está acontecendo:

• O servidor da web escuta a porta 12345 para solicitações http (o que é enviado quando você digita o endereço de uma página da web)
• Existem dois tipos de solicitações às quais ele responde.

1. Ele escuta "ControlPage.html" e enviará a página da Web de controle 2. Ele escuta as solicitações do formulário "/ request? Command = F & param1 = 100" (esses comandos são analisados e enviados para o Arduino (este exemplo resultaria no robô indo para frente por 10 segundos) Apêndice: (O código para o WebServer)

/ * * Arduino Controlled Web Connected Robot (WEBB) - Servidor da Web * Para obter mais detalhes, visite: https://www.oomlout.com/serb * * Comportamento: O programa escuta solicitações de http (página da web) no formato * "/ request ? command = F & param1 = 100 "e os passa para o * Arduino * Comandos suportados - & aposF & apos - 70 - Avançar * & aposB & apos - 66 - Retroceder * & aposL & apos - 76 - Esquerda * & aposR & apos - 82 - Direita * & aposS & apos - 83 - Velocidade * & aposX & apos - 88 - SetSpeedLeft * & aposY & apos - 89 - SetSpeedRight * & aposC & apos - 67 - Stop * param1 & aposs - 0 - 255 (0 a 25,5 segundos) valor * 100 milissegundos * * também serve a página da web de controle para o navegador se for solicitado ControlPage.html * * Operação: 1. Clique na porta Comm ao qual seu Arduino está conectado * 2. Use os botões de teste para ver se seu arduino está ouvindo * (moverá na direção clicada por meio segundo) * 3. Clique em Iniciar e seu servidor da web irá estar ouvindo os pedidos * * * Licença: Este trabalho está licenciado sob Creative Commons * Attribu Licença para compartilhar pela mesma licença 3.0 não portada. Para * visualizar uma cópia desta licença, visite * https://creativecommons.org/licenses/by-sa/3.0/ * ou envie uma carta para Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * EUA. * * / import processing.serial. *; // importe a biblioteca serial para usar Serial (para falar com o Arduino) import processing.net. *; // importe a biblioteca de rede para usar o servidor (para falar com a internet) / * Variáveis relacionadas à porta serial * / int serialPortIndex = -1; // o índice da porta serial que estamos usando em Serial.list () listString commOptions; // Uma variável para armazenar Serial.list () para que não haja necessidade de pesquisar // as portas seriais cada vez que desejamos refreenciá-la (a pesquisa causa um // salto nos servos arduino) Serial serialPort; // Torna a porta serial endereçável em todo este esboço / * Graphic and Rendering Related Variables * / PFont font; // torna a fonte pública para que ela só precise ser carregada uma vez (Arial-72) / * Network Related Variables * / Server wServer; // O servidor que lida com as solicitações da webint port = 12345; // A porta que o servidor escuta toint cycleCount = 0; // Conta o número de vezes que o loop de desenho é executado (usado para // animar o texto "em execução") / * Variáveis de utilitário * / PImage bg; // A imagem de fundo atualmente / WEBB-background.png / * * Variáveis relacionadas ao botão * (os botões são implementados de maneira muito aproximada, as caixas delimitadoras são armazenadas e o gráfico e o texto são * desenhados na imagem de fundo) ie. mover variáveis de botão não moverá a aparência dos botões * / Botão comm1; Botão comm2; Botão comm3; Botão comm4; // Os botões para escolher a porta serial corretaButton up; Botão direito; Botão esquerdo; Botão para baixo; // Os botões de direção para testar se o robô está respondendoButton webServer; // O botão para iniciar o webServer / * * define tudo para cima * / void setup () {frameRate (5); // Retarda o esboço um pouco para não sobrecarregar o sistema bg = loadImage ("WEBB-background.png"); // Carrega a imagem de fundo (armazenada na pasta de esboço) size (700, 400); // Define o tamanho da janela de esboço font = loadFont ("ArialMT-72.vlw"); // Carrega a fonte que usaremos neste esboço commOptions = Serial.list (); // Pesquisa as portas seriais e obtém uma lista de portas disponíveis // (fazer isso apenas uma vez impede o robô de se contorcer toda vez que a porta // serial é pesquisada) defineButtons (); // Define as caixas delimitadoras para cada botão background (bg); // Pinta a imagem de fundo (esta imagem tem todos os gráficos dos botões)} / * O loop principal dos esboços * / void draw () {if (cycleCount == 0) {// - chama as rotinas de desenho drawCommBox (); // Desenha os emelments na Comm Box (box 1) drawTestBox (); // Desenha todos os elementos da Caixa de Teste (caixa 2) drawWebServerBox (); // Desenha todos os elementos da caixa WebServer (caixa 3)} // - chama as rotinas de trabalho pollWebServer (); // Pesquisa o servidor da web para ver se alguma solicitação veio através da rede} // ------------------------------ ----------------------------------------------//Começar de rotinas de desenho (divididas apenas para tornar o código mais agradável de ler) / * * A rotina de atualização de desenho (executada a cada ciclo) para itens na caixa de comunicação (caixa 1) * / void drawCommBox () {fill (0, 0, 0); // Defina o preenchimento para preto textFont (font, 15); // Defina a fonte com o tamanho certo para (int i = 0; i 0) {running = running + ".";} // o número de pontos é baseado em cycleCount if ((cycleCount / 1)> 1) { running = running + ".";} if ((cycleCount / 1)> 2) {running = running + ".";} if ((cycleCount / 1)> 3) {cycleCount = 0;} texto (running, 520, 210); } cycleCount ++; // Cada vez que o CycleCount é incrementado em um} // Rotinas de fim de desenho // ------------------------------- ------------------------------ // ------------------ ------------------------------------------- // Início das rotinas de serviço / * * mousePressed é chamado toda vez que o mouse é pressionado * verifica se o mouse está dentro de alguma das caixas delimitadoras de botão * e se está a rotina apropriada é chamado * / void mousePressed () {if (comm1.pressed ()) { updateSerialPort (0);} // Alterações na porta de comunicação no índice 0 em Serial.list () else if (comm2.pressed ()) {updateSerialPort (1);} // Alterações na porta de comunicação no índice 1 em Serial.list () else if (comm3.pressed ()) {updateSerialPort (2);} // Altera para a porta de comunicação no índice 2 em Serial.list () else if (comm4.pressed ()) {updateSerialPort (3);} // Alterações na porta de comunicação no índice 3 em Serial.list () else if (up.pressed ()) {sendRobotCommand ("F", 5);} // Envia um comando para mover o robô para frente por 0,5 segundos mais if (left.pressed ()) {sendRobotCommand ("L", 5);} / / Envia um comando para mover o robô para a esquerda por 0,5 segundos else if (right.pressed ()) {sendRobotCommand ("R", 5);} // Envia um comando para mover o robô para a direita por 0,5 segundos else if (para baixo. pressionado ()) {sendRobotCommand ("B", 5);} // Envia um comando para mover o robô para trás por 0,5 segundos else if (webServer.pressed ()) {startWebServer ();} // Inicia o webServer cycleCount = 0; fundo (bg); // Redesenha a imagem de fundo (esta imagem tem todos os gráficos dos botões) draw ();} / * * Chamado assim que uma execução verifica o servidor para ver se há alguma conexão em espera * se houver uma conexão em espera que puxa a solicitação e a passa para a rotina parseRequest (String) * para remover o texto extra. Isso é então enviado para a rotina interpretRequest (String) para * chamar a rotina de ação apropriada (isto é, enviar instruções ao robô).* * Uma solicitação é passada inserindo o endereço do computador e a porta em um navegador da web * Para máquina local "https://127.0.0.1:12345/request?command=F&param1=100" * * Solicitação de exemplo: * GET / request? command = F & param1 = 100 HTTP / 1.1 * User-Agent: Mozilla / 5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit / 525.19 (KHTML, like Gecko) * Accept: * // * * Accept-Language: en-US, en * Accept-Charset: ISO-8859-1, *, utf-8 * Accept-Encoding: gzip, deflate, bzip2 * Host: 127.0.0.1:12345 * Conexão: Keep-Alive * * Exemplo de resposta (para solicitação processada) * HTTP / 1.1 200 OK * Conexão: fechar * Tipo de conteúdo: text / html * * comando: F param1: 100 * / void pollWebServer () {if (wServer! = null) {// If the webServer está executando a solicitação do cliente = wServer.available (); // Carrega o próximo cliente na fila no // servidor (nulo se não houver solicitações em espera) if (solicitação! = Nulo) {// se houver um processo de solicitação, ele String fullRequest = request.readString (); // Armazena o conteúdo da solicitação como uma string String ip = request.ip (); // Armazena o endereço IP do cliente como uma string String requestString = parseRequest (fullRequest.toUpperCase ()); // Retire todas as // informações extras deixando apenas a string de solicitação (texto após GET) // (muda para maiúsculas para tornar o teste de string mais fácil) if (requestString.indexOf ("REQUEST?")! = -1) { // Verifica se a solicitação tem "REQUEST?" String reply = interpretRequest (requestString); // Envia a solicitação para o interpretador de solicitações request.write ("HTTP / 1.1 200 OK / nConexão: fechar / nTipo de conteúdo: text / html / n / n" + resposta); // Envia a resposta 200 para dizer que a solicitação foi // tratada e a string "resposta" como a resposta wServer.disconnect (solicitação); // Desconecta o cliente} else if (requestString.indexOf ("CONTROLPAGE")! = -1) {// Se a solicitação for para a página da web de controle String webPageArray = loadStrings ("WEBB-ControlPage.html"); // Carrega o controle webPage de / data / WEBB-ControlPage.html // (carregado como um array de linhas) String webPage = ""; // Para tornar a edição mais fácil, a página da web foi deixada com // quebras de linha, de modo que este for loop retira essas linhas para (int i = 0; i portIndex) {// se o portIndex passado é um índice válido em Serial.list () // (ou seja, não é a opção três em uma lista de duas) serialPortIndex = portIndex; // defina a variável serialPortIndex para o novo índice serialport // (isso é usado para exibir o ponto ao lado da porta ativa)} if (serialPortIndex! = -1) {// verifique se uma porta foi escolhida algum tempo antes se (serialPort! = null) {serialPort.stop ();} // se uma porta serial já estiver sendo usada pare-a antes de carregar uma nova serialPort = new Serial (this, Serial.list () [serialPortIndex], 9600); // Cria um novo objeto Serial para se comunicar com o Arduino 9600 Baud}} / * * Pega uma string de solicitação (ex: "request? Command = F & param1 = 100") e irá retirar o comando * e param1 e passá-lo para o arduino (adicionar parâmetros extras ou comandos não arduino seria feito aqui) * / String interpretRequest (String requestString) {String returnValue = "OK"; // Prepara um comando String de variável returnValue; // As próximas três linhas extraem o valor após "command =" // (a linha extra é caso o parâmetro do comando esteja no // final da solicitação e não seja seguido por um & if (requestString.indexOf ("COMMAND =")! = -1) {command = requestString.substring (requestString.indexOf ("COMMAND =") + "COMMAND =". Length ());} else {command = "Z";} if (command.indexOf (" & ")! = -1) {command = command.substring (0, command.indexOf (" & "));} else {command = command;} String param1String; // As próximas três linhas extraem o valor após" param1 = "// (a linha extra é caso o parâmetro de comando esteja // no final da solicitação e não seja seguido por um & if (requestString.indexOf (" PARAM1 = ")! = -1) {param1String = requestString.substring (requestString.indexOf ("PARAM1 =") + "PARAM1 =". length ());} else {param1String = "0";} if (param1String.indexOf ("&")! = -1) {param1String = param1String.substring (0, param1String.indexOf ("&"));} else {param1String = param1String;} int param1 = Integer.parseInt (param1String); // Transforma a String param1 em um inteiro sendRobotCommand (comando, param1); // Envia o comando para a rotina que o envia para o Arduino returnValue = "command:" + command + "param1:" + param1; // no momento apenas o comando analisado, mas enviando // como html para que a formatação possa ser incluída return returnValue;} / * * Pega um comando (atualmente uma letra) e um parâmetro (um byte 0-255) e envia para o arduino * que está ouvindo e reasts * Comandos atualmente suportados * F - * / void sendRobotCommand (comando String, int param1) {println ("command:" + command + "time:" + param1); String checkString = "AAA"; if (serialPort! = null) {serialPort.write (checkString + comando); serialPort.write (byte (param1)); }} // Fim da configuração / rotinas não muito comumente chamadas // ----------------------------------- -------------------------------------------------- // Botão de exemplo e código RectButton do exemplo processing.org com algumas alterações // feitas principalmente para simplificar e remover a animação de rolagem // https://processing.org/learning/topics/buttons.html (2008-09-23) class Botão {int x, y; largura interna, altura; Botão (int ix, int iy, int iwidth, int iheight) {x = ix; y = iy; largura = iwidth; altura = iheight; } boolean pressionado () {if (overRect ()) {return true; } else {return false;}} boolean overRect () {if (mouseX> = x && mouseX = y && mouseY <= y + height) {return true; } else {return false; }}}

Etapa 5: Software - (página da Web)

Bem, estamos quase terminando tudo o que resta é falar com o seu robô. Para começar a falar: (em uma rede local -no windows-)

• Descubra o endereço IP local do laptop. Para fazer isso, vá para "Iniciar / Programas / Acessórios / Prompt de Comando" e quando a janela do terminal abrir digite "ipconfig". Anote o "Endereço IP" e vá para outro computador em sua rede local.
• Abra um navegador da web, digite "https:// (robot computer ip): 12345 / ControlPage.html
• A página da web de controle deve carregar, na caixa "Endereço IP" digite o ip dos computadores do robô.
• Comece a controlar seu robô.

Para começar a falar: (pela internet) Agora que você já tem tudo funcionando localmente, é preciso apenas alguns passos para falar pela internet.

• (etapa mais difícil) Configure o encaminhamento de porta - Seu computador precisa estar ouvindo a Internet, e não apenas a rede local. Para fazer isso, você precisa dizer ao roteador para passar certas solicitações ao computador que controla o robô. Isso é um pouco complexo e vai muito além do escopo deste Instructable. No entanto, se você visitar PortForward.com, eles fornecerão tudo o que você precisa saber sobre a configuração do seu roteador (você precisa encaminhar a porta 12345 para o seu laptop robô)
• Em seguida, descubra o seu IP de Internet (visite WhatIsMyIP.com)
• Por fim, acione o skype, configure uma videochamada e peça a quem você está falando para visitar "https:// (Internet IP): 12345 / ControlPage.html"
• Digite o IP da internet na caixa "Endereço IP" na página da Web de controle e seu Robô conectado à Web será conduzido de longe.

Etapa 6: Concluída

Bem, é isso. Espero que você esteja se divertindo dirigindo seu robô de longe. Se você tiver algum problema com o software ou hardware, sinta-se à vontade para deixar um comentário e eu tentarei ajudá-lo. Se você gostaria de verificar projetos mais legais, tente visitar: oomlout.com