Haga un robot conectado a la web (por aproximadamente $ 500) (usando un Arduino y una netbook): 6 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:45

Este Instructable le mostrará cómo construir su propio robot conectado a la web (usando un microcontrolador Arduino y una computadora Asus eee). ¿Por qué querría un robot conectado a la web? Para jugar, por supuesto. Conduce tu robot desde el otro lado de la habitación o del país, usando nada más que Skype y un navegador web (nada que instalar en la computadora de control). ¿Después? Profundice en el software y adáptelo como desee, agregue un GPS para que pueda ver dónde está conduciendo en un mapa, agregue sensores de temperatura para mapear los gradientes de temperatura en su casa o sensores de sonar para agregar controles en lo que está en la web los conductores pueden y no pueden toparse con. Características:

• Barato - (~ $ 500 si compra todas las piezas nuevas y considerablemente más baratas si busca en su contenedor de piezas)
• Una vez en funcionamiento, controlar el robot solo requiere un navegador web (y Skype si desea ver por dónde conduce)
• Código abierto y fácilmente adaptable: (utiliza un microcontrolador Arduino, procesamiento para el servidor web y todo el software se puede ejecutar en Linux (todo el código también está muy comentado para facilitar el cambio y el salto))
• Diseño modular (no es un sistema completamente integrado, si desea utilizar un servicio de videoconferencia diferente, no se preocupe, o si tiene un sello básico en lugar de un Arduino, simplemente coloque un pequeño fragmento de código e introdúzcalo)

Aquí hay un video rápido de mi robot conectado a la web siendo sacado de la cocina.

Paso 1: Piezas y herramientas

Solo se requieren algunas partes: Robot: Servo Robot controlado por Arduino - (SERB) ($ 175 @ oomlout.com) o (haga el suyo propio)

Un robot de código abierto que utiliza un microcontrolador Arduino como cerebro

(Se puede usar cualquier plataforma de robot servo dual con un arduino (opción 1) (por favor, envíeme un mensaje si descubre alguna otra opción) Computadora: Asus eee PC 4G ($ 280) (@Best Buy)

Una computadora portátil pequeña y económica que es perfecta para este propósito

(se puede usar cualquier computadora portátil (o computadora de escritorio si desea ejecutar con un acorde) capaz de ejecutar bocetos de procesamiento) Escritorio para computadora portátil: acrílico cortado con láser ($ 25 (@ oomlout)) o (cree su propio paso 3)

Algunas piezas acrílicas adicionales que se atornillan a un (SERB) para darle un escritorio para que se siente la computadora portátil

Nuts and Bols: (disponible en Home Depot)

• Perno de 3 mm x 10 mm (x4)
• Perno de 3 mm x 15 mm (x4)
• Tuerca de 3 mm (x8)

Paso 2: corte de piezas y ensamblaje

Hay tres opciones para obtener piezas para el escritorio de su computadora portátil: Opción de corte 1: (Comprar en oomlout.com)

Las piezas de escritorio cortadas con láser y el hardware necesario están disponibles en oomlout por $ 25 (aquí)

Opción 2: (Cortar con su propia cortadora láser o Ponoko.com)

• Descargue el archivo a continuación (03-WEBB-Acrylic Parts.cdr o 03-WEBB-Acrylic Parts (Ponoko P2).eps)
• Córtelos de acrílico de 3 mm (1/8 ")

Opción 3: (Sierra de desplazamiento)

• Descargue el patrón de sierra de marquetería desde abajo (03-WEBB-ScrollSaw Pattern (A4).pdf (para papel de tamaño A4) o 03-WEBB-ScrollSaw Pattern (carta).pdf (para papel de tamaño carta))
• Verifique que no se haya escalado al imprimir (midiendo las reglas impresas)
• Pegue a una pieza de acrílico de 3 mm (1/8 ") y corte las piezas.

Montaje: Descargue la guía de montaje (04-WEBB-Assembly Guide.pdf) a continuación y coloque el escritorio de la computadora portátil.

Paso 3: Software - (Arduino)

Para aquellos que son nuevos en Arduino, consulte la excelente guía de inicio en Arduino.cc Primero, el software que se ejecuta en Arduino. Es un programa muy simple, lo que hace el Arduino es monitorear su puerto serial en busca de datos, lo que busca es una conversación de 5 bytes de longitud.

• Byte 1-3 (comprobar bytes "AAA")
• Byte 4 Command (Le dice al arduino qué hacer) (Comandos admitidos 'F' - Adelante, 'B' - Atrás, 'L' - Izquierda, 'R' - Derecha, 'S' - Velocidad, 'X' - SetSpeedLeft, 'Y' - SetSpeedRight, 'C' - Detener)
• Parámetro Byte 5: para los comandos de movimiento, esto se interpreta como un intervalo de tiempo (parámetro * 100 ms), y para los comandos de velocidad, un porcentaje de 0 a 100.

El código se comenta a fondo y dado este marco, agregar comandos adicionales debería ser fácil.

• Descarga el archivo zip adjunto. (05-WEBB-Arduino Code.zip)
• Descomprima en su directorio de Arduino Sketch. (predeterminado: Mis documentos / Arduino)
• Abra su entorno de desarrollo arduino y cárguelo en su Arduino.

Copiar y pegar

• Copie el código de abajo.
• Pegue en el entorno de desarrollo de Arduino.
• Sube a tu Arduino.

Apéndice: El programa Arduino

/ * * Arduino Controlled Web Connected Robot (WEBB) - Serial Host * Para más detalles visite: https://www.oomlout.com/serb * * Comportamiento: El Arduino escucha su puerto serial para un comando * en formato 254, 88, 88, (COMMAND), (TIME) * Comandos admitidos - & aposF & apos - 70 - Forward * & aposB & apos - 66 - Backward * & aposL & apos - 76 - Left * & aposR & apos - 82 - Right * & aposS & apos - 83 - Speed * & aposftX & apos - 88 - SetSpeedLeft * & aposY & apos - 89 - SetSpeedRight * & aposC & apos - 67 - Stop * Tiempos admitidos - Valor 0-255 (0 a 25,5 segundos) * 100 milisegundos * sp * Cableado: Señal servo derecha - pin 9 * Señal servo izquierda - pin 10 * * Licencia: Este trabajo tiene la licencia Creative Commons * Attribution-Share Alike 3.0 Unported License. Para * ver una copia de esta licencia, visite * https://creativecommons.org/licenses/by-sa/3.0/ * o envíe una carta a Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * ESTADOS UNIDOS. * * / // --------------------------------------------- ---------------------------- // INICIO DEL SERVIDOR SERIE ARDUINO PREÁMBULO // Definición de las constantes correspondientes a cada comando (también el número de 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 / * Los tres bytes de verificación (utilizados para evitar que el robot responda a datos seriales aleatorios *) actualmente "AAA" * / # define checkByte1 65 // "A" #define checkByte2 65 // "A "#define checkByte3 65 //" A "// -------------------------------------- ------------------------------------ // INICIO DEL SERVO ROBOT CONTROLADO POR ARDUINO (SERB) PREÁMBULO # incluye #define LEFTSERVOPIN 10 // El pin al que está conectado el servo izquierdo # define RIGHTSERVOPIN 9 // El pin al que está conectado el servo derechoServo leftServo; Servo rightServo; int leftSpeed = 50; // mantiene la velocidad de los robots leftServo // un porcentaje entre 0 y 100int rightSpeed = 100; // mantiene la velocidad de los robots correctaServo // un porcentaje entre 0 y 100 // FIN DEL SERVO ROBOT CONTROLADO POR ARDUINO (SERB) PREÁMBULO // ------------------- -------------------------------------------------- ----- // Pone todo en funcionamientovoid setup () {Serial.begin (9600); // Inicia el puerto serie serbSetup (); // establece el estado de todos los // pines necesarios y agrega servos a su boceto} // El programa principal loopvoid loop () {serbPollSerialPort (); // busca continuamente el puerto serie // si hay datos, los procesa} // ------------------------------ ----------------------------------------- // INICIO DE LAS RUTINAS DEL SERVIDOR SERIE ARDUINO / * * Procesa los comandos enviados al puerto serie arduino & aposs * / void serbPollSerialPort () {int dta; // variable para contener el byte serial if (Serial.available ()> = 5) {// si hay 5 bytes en el búfer (longitud de una solicitud completa) dta = Serial.read (); if (dta = checkByte1) {// Verifica el primer byte de verificación dta = Serial.read (); if (dta = checkByte2) {// Verifica el segundo byte de verificación dta = Serial.read (); if (dta = checkByte3) {// Verifica el tercer byte de verificación int command = Serial.read (); // El cuarto byte es el comando int param1 = Serial.read (); // El quinto byte es param1 interpretCommand (comando, param1); // le envía la solicitud analizada & aposs handler}}}}} / * * Toma el comando y el parámetro y lo pasa al robot * / void interpretCommand (int command, int param1) {if (command == FORWARD) {goForward (); retraso (param1 * 100); goStop ();} // si avanza else if (comando == ATRÁS) {goBackward (); retraso (param1 * 100); goStop ();} // si al revés else if (comando == IZQUIERDA) {goLeft (); retraso (param1 * 100); goStop ();} // si se deja else if (comando == DERECHA) {goRight (); retraso (param1 * 100); goStop ();} // si es correcto else if (comando == SETSPEED) {setSpeed (param1);} // si se establece la velocidad else if (comando == STOP) {goStop ();} // si se detiene else if (command == SETSPEEDLEFT) {setSpeedLeft (param1);} // si se establece la velocidad izquierda else if (command == SETSPEEDRIGHT) {setSpeedRight (param1);} // si se establece la velocidad derecha else {// si el comando no se reconoce haz un poco de shimmey ve a la izquierda(); retraso (150); ve a la derecha(); retraso (150); goStop (); }} // ---------------------------------------------- -------------------------- // INICIO DE LAS RUTINAS DEL SERVO ROBOT CONTROLADO POR ARDUINO (SERB) / * * configura su arduino para que se dirija a su SERB usando las rutinas incluidas * / void serbSetup () {setSpeed (leftSpeed); pinMode (LEFTSERVOPIN, OUTPUT); // establece el pin de la señal del servo izquierdo // en la salida pinMode (RIGHTSERVOPIN, OUTPUT); // establece el pin de señal del servo derecho // para dar salida a leftServo.attach (LEFTSERVOPIN); // adjunta el servo izquierdo rightServo.attach (RIGHTSERVOPIN); // conecta el servo derecho goStop ();} / * * establece la velocidad del robot entre 0- (detenido) y 100- (velocidad máxima) * NOTA: la velocidad no cambiará la velocidad actual, debe cambiar la velocidad * luego llame a uno de los métodos go antes de que ocurran los cambios. * / void setSpeed (int newSpeed) {setSpeedLeft (newSpeed); // establece la velocidad izquierda setSpeedRight (newSpeed); // establece la velocidad derecha} / * * Establece la velocidad de la rueda izquierda * / void setSpeedLeft (int newSpeed) {if (newSpeed> = 100) {newSpeed = 100;} // si la velocidad es mayor que 100 // hágalo 100 if (newSpeed = 100) {newSpeed = 100;} // si la velocidad es mayor que 100 // hágalo 100 if (newSpeed <= 0) {newSpeed = 0;} // si la velocidad es menor que 0 make // it 0 rightSpeed = newSpeed * 0.9; // escala la velocidad para que sea} / * * envía el robot hacia adelante * / void goForward () {leftServo.write (90 + leftSpeed); rightServo.write (90 - rightSpeed);} / * * envía el robot hacia atrás * / void goBackward () {leftServo.write (90 - leftSpeed); rightServo.write (90 + rightSpeed);} / * * envía el robot a la derecha * / void goRight () {leftServo.write (90 + leftSpeed); rightServo.write (90 + rightSpeed);} / * * envía el robot a la izquierda * / void goLeft () {leftServo.write (90 - leftSpeed); rightServo.write (90 - rightSpeed);} / * * detiene el robot * / void goStop () {leftServo.write (90); rightServo.write (90);} // FIN DE LAS RUTINAS DEL SERVO ROBOT CONTROLADO POR ARDUINO (SERB) // ---------------------------- -----------------------------------------------

Paso 4: Software - Robot portátil (servidor web)

(Processing es un lenguaje y entorno de programación de código abierto con el que es muy fácil comenzar. Para obtener más detalles, visite Processing) El software que se ejecuta en la computadora portátil robot también es bastante simple. Es un servidor web bastante rudimentario (escucha las solicitudes de páginas web desde un navegador web), una pequeña interfaz de usuario (para configurarlo) y facilidades para pasar los comandos recibidos del servidor web al Arduino. (en ventanas)

• Descargue el archivo zip a continuación (06-WEBB-Processing Webserver (windows exe).zip)
• Descomprímalo y ejecute el archivo.exe (_WEBB_WebServer_RobotComputer.exe)

Para editar en procesamiento:

• Descargue el archivo zip a continuación (06-WEBB-Processing Webserver (archivos fuente).zip)
• Descomprima en cualquier lugar de su computadora.
• Abra el entorno de procesamiento y abra (_WEBB_WebServer_RobotComputer.pde)

Probar:

• Ejecuta el programa.
• En el recuadro # 1 habrá una lista de los puertos de comunicación disponibles en su computadora (haga clic en el que está conectado su Arduino. (Su robot se contraerá unas cuantas veces cuando la computadora se conecte, y aparecerá un punto cian al lado del elegido). puerto de comunicaciones)
• En el recuadro n. ° 2, pruebe para ver si su Arduino está conectado. Haga clic en una de las flechas y, con suerte, su robot se moverá en la dirección en la que se hizo clic durante medio segundo.
• En el cuadro # 3, haga clic en el botón "Inicio" para iniciar el servidor web.
• Abra un navegador web (en la computadora portátil robot) y visite https://127.0.0.1:12345/ControlPage.html (con suerte, aparecerá la página web de control con botones) -Detalles sobre cómo usar esta página en el siguiente paso -

Lo que está sucediendo:

• El servidor web escucha el puerto 12345 para las solicitudes http (lo que se envía cuando escribe la dirección de una página web)
• Hay dos tipos de solicitudes a las que responde.

1. Escucha "ControlPage.html" y enviará la página web de control 2. Escucha solicitudes de la forma "/ request? Command = F & param1 = 100" (estos comandos se analizan y envían al Arduino (este ejemplo daría como resultado en el robot avanzando durante 10 segundos) Apéndice: (El código para el servidor web)

/ * * Arduino Controlled Web Connected Robot (WEBB) - Webserver * Para obtener más detalles, visite: https://www.oomlout.com/serb * * Comportamiento: el programa escucha las solicitudes http (página web) en el formulario * "/ request ? command = F & param1 = 100 "y luego los pasa a * Arduino * Comandos compatibles - & aposF & apos - 70 - Forward * & aposB & apos - 66 - Backward * & aposL & apos - 76 - Left * & aposR & apos - 82 - Right * & aposS & apos - 83 - Speed * & aposX & apos - 88 - SetSpeedLeft * & aposY & apos - 89 - SetSpeedRight * & aposC & apos - 67 - Stop * param1 & aposs - 0-255 (0 a 25,5 segundos) valor * 100 milisegundos * * también sirve la página web de control al navegador si solicita ControlPage.html * * Operación: 1. Haga clic en el puerto Comm al que está conectado su Arduino * 2. Use los botones de prueba para ver si su arduino está escuchando * (se moverá en la dirección en la que se hizo clic durante medio segundo) * 3. Haga clic en Inicio y su servidor web Esté atento a las solicitudes * * * Licencia: Este trabajo está autorizado bajo Creative Commons * Attribu tion-Share Alike 3.0 Unported License. Para * ver una copia de esta licencia, visite * https://creativecommons.org/licenses/by-sa/3.0/ * o envíe una carta a Creative Commons, 171 Second * Street, Suite 300, San Francisco, California 94105, * ESTADOS UNIDOS. * * / import processing.serial. *; // importar la biblioteca serial para usar Serial (para hablar con Arduino) import processing.net. *; // importar la biblioteca de red para usar el servidor (para hablar con Internet) / * Variables relacionadas con el puerto serie * / int serialPortIndex = -1; // el índice del puerto serie que estamos usando en Serial.list () listString commOptions; // Una variable para almacenar Serial.list () para que no sea necesario sondear // los puertos seriales cada vez que deseamos hacer referencia a ellos (el sondeo provoca un // salto en los servos arduino) Serial serialPort; // Hace que el puerto serie sea direccionable a lo largo de este boceto / * Variables relacionadas con el gráfico y el renderizado * / PFont font; // hace que la fuente sea pública, por lo que solo necesita cargarse una vez (Arial-72) / * Variables relacionadas con la red * / Server wServer; // El servidor que maneja las solicitudes webint port = 12345; // El puerto al que escucha el servidorint cycleCount = 0; // Cuenta el número de veces que se ejecuta el bucle de dibujo (utilizado para // animar el texto "en ejecución") / * Variables de utilidad * / PImage bg; // La imagen de fondo actualmente / WEBB-background.png / * * Variables relacionadas con los botones * (los botones se implementan de manera muy aproximada, los cuadros delimitadores se almacenan y los gráficos y el texto * se dibujan en la imagen de fondo). mover las variables de los botones no moverá la apariencia de los botones * / Button comm1; Botón comm2; Botón comm3; Botón comm4; // Los botones para elegir el puerto serial correctoButton up; Botón a la derecha; Botón a la izquierda; Button down; // Los botones de dirección para probar si el robot respondeButton webServer; // El botón para iniciar el servidor web / * * configura todo * / void setup () {frameRate (5); // Ralentiza un poco el boceto para que no sea tan agotador para el sistema bg = loadImage ("WEBB-background.png"); // Carga la imagen de fondo (almacenada en la carpeta de bocetos) tamaño (700, 400); // Establece el tamaño de la ventana del boceto font = loadFont ("ArialMT-72.vlw"); // Carga la fuente que usaremos en este boceto commOptions = Serial.list (); // Sondea los puertos serie y obtiene una lista de puertos disponibles // (hacer esto solo una vez evita que el robot se mueva cada vez que & aposs // se consulta el puerto serie) defineButtons (); // Define los cuadros delimitadores para cada botón de fondo (bg); // Pinta la imagen de fondo (esta imagen tiene todos los gráficos de los botones)} / * El bucle principal de los bocetos * / void draw () {if (cycleCount == 0) {// - llama a las rutinas de dibujo drawCommBox (); // Dibuja las mejoras en el Comm Box (caja 1) drawTestBox (); // Dibuja todos los elementos del Cuadro de prueba (cuadro 2) drawWebServerBox (); // Dibuja todos los elementos del WebServer Box (caja 3)} // - llama a las rutinas de trabajo pollWebServer (); // Sondea el servidor web para ver si ha llegado alguna solicitud a través de la red} // ------------------------------ ----------------------------------------------//Inicio de dibujar rutinas (dividir solo para que el código sea más agradable de leer) / * * La rutina de actualización de dibujo (ejecutada en cada ciclo) para elementos en el cuadro de comunicación (cuadro 1) * / void drawCommBox () {fill (0, 0, 0); // Establece el relleno en negro textFont (font, 15); // Establezca la fuente en el tamaño correcto para (int i = 0; i 0) {running = running + ".";} // el número de puntos se basa en cycleCount if ((cycleCount / 1)> 1) { running = running + ".";} if ((cycleCount / 1)> 2) {running = running + ".";} if ((cycleCount / 1)> 3) {cycleCount = 0;} texto (en ejecución, 520, 210); } cycleCount ++; // Cada vez que pasa el cycleCount se incrementa en uno} // End of Draw rutinas // ------------------------------- ------------------------------ // ------------------ ------------------------------------------- // Inicio de rutinas de servicio / * * mousePressed se llama cada vez que se presiona el mouse esto * comprueba si el mouse está dentro de cualquiera de los cuadros delimitadores de botones * y si es la rutina apropiada se llama * / void mousePressed () {if (comm1.pressed ()) { updateSerialPort (0);} // Cambios en el puerto de comunicaciones en el índice 0 en Serial.list () else if (comm2.pressed ()) {updateSerialPort (1);} // Cambios en el puerto de comunicaciones en el índice 1 en Serial.list () else if (comm3.pressed ()) {updateSerialPort (2);} // Cambios en el puerto de comunicaciones en el índice 2 en Serial.list () else if (comm4.pressed ()) {updateSerialPort (3);} // Cambios en el puerto de comunicaciones en el índice 3 en Serial.list () else if (up.pressed ()) {sendRobotCommand ("F", 5);} // Envía un comando para mover el robot hacia adelante durante 0.5 segundos más if (left.pressed ()) {sendRobotCommand ("L", 5);} / / Envía un comando para mover el robot a la izquierda durante 0.5 segundos else if (right.pressed ()) {sendRobotCommand ("R", 5);} // Envía un comando para mover el robot a la derecha durante 0.5 segundos else if (down. presionado ()) {sendRobotCommand ("B", 5);} // Envía un comando para mover el robot hacia atrás durante 0.5 segundos else if (webServer.pressed ()) {startWebServer ();} // Inicia el webServer cycleCount = 0; fondo (bg); // Vuelve a pintar la imagen de fondo (esta imagen tiene todos los gráficos de los botones) draw ();} / * * Llamado una vez una ejecución, comprueba el servidor para ver si hay conexiones en espera * si hay una conexión en espera, extrae envía la solicitud y la pasa a la rutina parseRequest (String) * para eliminar el texto adicional. Esto luego se envía a la rutina interpretRequest (String) para * llamar a la rutina de acción apropiada (es decir, enviar instrucciones al robot).* * Se pasa una solicitud ingresando la dirección y el puerto de la computadora en un navegador web * Para la máquina local "https://127.0.0.1:12345/request?command=F&param1=100" * * Ejemplo de solicitud: * 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, como Gecko) * Aceptar: * // * * Aceptar-Idioma: en-US, en * Accept-Charset: ISO-8859-1, *, utf-8 * Accept-Encoding: gzip, deflate, bzip2 * Host: 127.0.0.1:12345 * Conexión: Keep-Alive * * Ejemplo de respuesta (para solicitud procesada) * HTTP / 1.1 200 OK * Conexión: cerrar * Tipo de contenido: texto / html * * comando: F param1: 100 * / void pollWebServer () {if (wServer! = null) {// Si el servidor web está ejecutando Client request = wServer.available (); // Cargue el siguiente Cliente en línea en el // servidor (nulo si no hay solicitudes en espera) if (solicitud! = Nulo) {// si hay una solicitud procesa eso String fullRequest = request.readString (); // Almacenar el contenido de la solicitud como una cadena String ip = request.ip (); // Almacene la dirección IP del cliente como una cadena String requestString = parseRequest (fullRequest.toUpperCase ()); // Elimina toda la // información adicional dejando solo la cadena de solicitud (texto después de GET) // (cambia a mayúsculas para facilitar la prueba de cadenas) if (requestString.indexOf ("REQUEST?")! = -1) { // Comprueba si la solicitud tiene "REQUEST?" Cadena de respuesta = interpretRequest (requestString); // Envía la solicitud al intérprete de solicitudes request.write ("HTTP / 1.1 200 OK / nConexión: cerrar / nTipo de contenido: texto / html / n / n" + respuesta); // Envía la respuesta a 200 para decir que la solicitud fue // manejada y la cadena de "respuesta" como respuesta wServer.disconnect (request); // Desconecta al Cliente} else if (requestString.indexOf ("CONTROLPAGE")! = -1) {// Si la solicitud es para la página web de control String webPageArray = loadStrings ("WEBB-ControlPage.html"); // Carga la página web de control desde / data / WEBB-ControlPage.html // (cargada como una matriz de líneas) String webPage = ""; // Para facilitar la edición, la página web se ha dejado con // saltos de línea, por lo que este bucle separa esas líneas para (int i = 0; i portIndex) {// si el portIndex pasado es un índice válido en Serial.list () // (es decir, no la opción tres en una lista de dos) serialPortIndex = portIndex; // establece la variable serialPortIndex en el nuevo índice del puerto serial // (esto se usa para mostrar el punto al lado del puerto activo)} if (serialPortIndex! = -1) {// verifica que se haya elegido un puerto en algún momento anterior si (serialPort! = null) {serialPort.stop ();} // si ya se está utilizando un puerto serial, deténgalo antes de cargar uno nuevo serialPort = new Serial (this, Serial.list () [serialPortIndex], 9600); // Crea un nuevo objeto Serial para comunicarse con Arduino 9600 Baud}} / * * Toma una cadena de solicitud (por ejemplo: "request? Command = F & param1 = 100") y eliminará el comando * y param1 y lo pasará al arduino (aquí se agregarían parámetros adicionales o comandos que no sean arduino) * / String interpretRequest (String requestString) {String returnValue = "OK"; // Prepara un comando String de variable returnValue; // Las siguientes tres líneas extraen el valor después de "command =" // (la línea adicional es en caso de que el parámetro de comando esté al // final de la solicitud y no seguido de & if (requestString.indexOf ("COMMAND =")! = -1) {comando = 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; // Las siguientes tres líneas extraen el valor después de" param1 = "// (la línea adicional es en caso de que el parámetro de comando esté // al final de la solicitud y no seguido de & 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); // Convierte la cadena param1 en una entero sendRobotCommand (comando, param1); // Envía el comando a la rutina que lo envía al Arduino returnValue = "command:" + command + "param1:" + param1; // en este momento solo el comando analizado pero enviando // como html para que se pueda incluir el formato return returnValue;} / * * Toma un comando (actualmente una letra) y un parámetro (un byte 0-255) y lo envía al arduino * que está escuchando y reafirma * Comandos soportados actualmente * F - * / void sendRobotCommand (comando String, int param1) {println ("comando:" + comando + "tiempo:" + param1); String checkString = "AAA"; if (serialPort! = null) {serialPort.write (checkString + comando); serialPort.write (byte (param1)); }} // Fin de la configuración / rutinas no muy comúnmente llamadas // ----------------------------------- -------------------------------------------------- // Botón de ejemplo y código RectButton del ejemplo de Processing.org con algunos cambios // realizados principalmente para simplificar y eliminar la animación de roll over // https://processing.org/learning/topics/buttons.html (2008-09-23) Botón de clase {int x, y; int ancho, alto; Botón (int ix, int iy, int iwidth, int iheight) {x = ix; y = iy; width = iwidth; altura = ialtura; } booleano presionado () {if (overRect ()) {return true; } else {return false;}} boolean overRect () {if (mouseX> = x && mouseX = y && mouseY <= y + height) {return true; } else {devolver falso; }}}

Paso 5: Software - (página web)

Bueno, ya casi terminamos, todo lo que queda es hablar con tu robot. Para ponerse a hablar: (a través de una red local -en windows-)

• Descubra la dirección IP local de la computadora portátil. Para hacer esto, vaya a "Inicio / Programas / Accesorios / Símbolo del sistema" y cuando se abra la ventana del terminal, escriba "ipconfig". Escriba "Dirección IP" y diríjase a otra computadora en su red local.
• Abra un navegador web, escriba "https:// (robot computer ip): 12345 / ControlPage.html
• La página web de control debe cargarse, en el cuadro "Dirección IP" escriba la ip de la computadora del robot.
• Comience a controlar su robot.

Para empezar a hablar: (a través de Internet) Ahora que lo tiene funcionando localmente, hacer que hable a través de Internet está a solo unos pocos pasos de distancia.

• (paso más difícil) Configurar el reenvío de puertos: su computadora debe estar escuchando Internet en lugar de solo la red local. Para hacer esto, necesita decirle a su enrutador que pase ciertas solicitudes a la computadora que controla el robot. Esto es un poco complejo y va mucho más allá del alcance de este Instructable. Sin embargo, si visita PortForward.com, le brindarán todo lo que necesita saber sobre la configuración de su enrutador (debe reenviar el puerto 12345 a su computadora portátil robot)
• A continuación, descubra su IP de Internet (visite WhatIsMyIP.com)
• Por último, inicie Skype, configure una videollamada y haga que la persona con la que está hablando visite "https:// (IP de Internet): 12345 / ControlPage.html".
• Escriba la IP de Internet en el cuadro "Dirección IP" en la página web de control y su robot conectado a la web será conducido desde lejos.

Paso 6: terminado

Bueno, eso es todo. Espero que te diviertas conduciendo tu robot desde lejos. Si tiene algún problema con el software o el hardware, no dude en dejar un comentario e intentaré ayudarlo. Si desea ver más proyectos interesantes, intente visitar: oomlout.com