Móvil controlado por web: 14 pasos (con imágenes)

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

Construir y jugar con robots es mi principal placer culpable en la vida. Otros juegan al golf o al esquí, pero yo construyo robots (ya que no puedo jugar al golf o esquiar:-). ¡Lo encuentro relajante y divertido! Para aprovechar al máximo mis bots, utilizo kits de chasis. El uso de kits me ayuda a hacer lo que más me gusta hacer, el software y la electrónica, y también lo convierte en un mejor chasis para mi yo de todos los pulgares.

En este Instructable, veremos qué se necesita para hacer un rover controlado por Wifi / web simple pero robusto. El chasis utilizado es el Actobotics Gooseneck. Lo elegí por su tamaño, capacidad de expansión y costo, pero puede usar cualquier otro chasis de su elección.

Para un proyecto como este, necesitaremos una buena computadora sólida de placa única y para este bot elegí usar la Raspberry Pi (RPI), una computadora basada en Linux. El RPI (y Linux) nos da muchas opciones de codificación y Python se utilizará para el lado de la codificación. Para la interfaz web utilizo Flask, un marco web ligero para Python.

Para impulsar los motores, elegí un RoboClaw 2x5a. Permite una comunicación en serie simple para controlarlo y funciona bien con el RPI y los motores del cuello de cisne.

Finalmente, tiene una cámara web para retroalimentación de video tipo POV para conducirlo de forma remota. Cubriré cada tema con más detalle más adelante.

Paso 1: Hardware necesario

• Chasis Actobotics Gooesneck o un reemplazo adecuado de su elección
• Raspberry Pi de su elección (o clon): se usa un modelo B de RPI en este bot, pero cualquiera que tenga al menos dos puertos USB funcionará
• Placa de servo estándar B x1
• Soporte de canal de ángulo único de 90 ° x1
• Controlador de motor RoboClaw 2x5a
• S3003 o servo de tamaño estándar similar
• Placa de pruebas pequeña o placa de pruebas pequeña
• Cables de puente hembra a hembra
• Cables de puente macho a hembra
• Cámara web (opcional): uso un Logitech C110 y aquí hay una lista de cámaras compatibles con el RPI
• Fuente de alimentación de 5v-6v para servoalimentación
• Batería de 7.2v-11.1v para la alimentación del motor de accionamiento
• Banco de energía USB de 5v 2600mah (o superior) para el RPI
• Adaptador Wifi USB

En mi bot, utilizo ruedas de 4 para hacerlo un poco más Todo Terreno-Interior. Para esta opción necesitarás:

• Rueda de servicio pesado de 4 "x2
• Cubo de tornillo de fijación de 4 mm (0,770 pulgadas) x2

Paso 2: Montaje del chasis

Primero ensamble el chasis siguiendo las instrucciones incluidas con el chasis o el video. Después de terminar deberías tener algo como la imagen. NOTA: Al ensamblar la parte del cuello, simplemente deje el soporte de montaje fuera.

En mi bot, elegí reemplazar las ruedas con las que venía el chasis por ruedas de 4 para trabajo pesado. Esto es opcional y no es necesario a menos que quieras hacer lo mismo.

Paso 3: Montaje de la electrónica

El Gooseneck tiene mucho espacio y opciones para montar sus dispositivos electrónicos. Te doy estas imágenes como guía, pero puedes elegir cómo te gustaría distribuirlas. Puede utilizar separadores, cinta de doble cara, velcro o cinta servo para montar la placa y las baterías.

Paso 4: agregar la cámara web

Tome el soporte de 90 grados, el concentrador de servo liviano y cuatro (4) tornillos de.3125 para este paso:

• Tome el concentrador del servo y colóquelo en un lado del soporte y asegúrelos con los tornillos de.2125 "como se muestra en la imagen.
• Luego monte el servo en el soporte del servo
• Coloque el soporte de 90 grados con la bocina del servo a la columna de los servos y use el tornillo de la bocina que viene con el servo para conectarlos.
• Ahora monte el Servo en el soporte en la parte superior del cuello de cisne con los tornillos restantes
• Monte la cámara con bridas o cinta adhesiva de doble cara en el soporte de 90 grados

Utilice las imágenes como guías si es necesario.

Paso 5: cableado todo

El cableado es bastante estrecho para este robot.

Los motores:

Suelde los cables en ambos motores si aún no lo ha hecho

Con los robots al frente (el extremo con el cuello de ganso) de espaldas a usted:

• Conecte los cables del motor en el motor izquierdo al canal M1A y M1B
• Conecte los cables del motor en el motor derecho al canal M2A y M2B

Conexiones de tierra (GND):

• Conecte un pin de tierra en el RoboClaw a la placa de puente de tierra. La línea del pin de tierra en el RoboClaw está más cerca del centro (ver foto)
• Conecte el PIN 6 del RPI a la placa de puentes. Vea la imagen del encabezado RPI para las asignaciones de pines.
• Conecte el GND del paquete de baterías del servo a uno de los pines de la placa de puente.
• Ejecute un cable de puente desde la placa de puente hasta el cable GND de los servos.

RPI a RoboClaw:

Conecte el pin RPI GPIO14 TXD al pin RoboClaw S1

Poder:

• Conecte el cable POS de la batería del servo al cable POS de los servos
• Conecte el cable POS de la batería del motor a POS (+) del terminal de entrada de energía del motor RoboClaw. Dejaremos el terminal GND desconectado por ahora.

Paso 6: Configuración del RPI

Supongo que el usuario aquí sabe algo sobre Linux y el RPI. No cubro cómo configurar o conectarse a uno. Si necesita ayuda con eso, utilice las páginas siguientes.

Para configurar su RPI, eche un vistazo a las siguientes páginas:

• Configuración básica de RPI
• Guía de inicio rápido de RPI
• Configuración de NOOBS guilde

Para las páginas de inicio generales, la página principal de RPI y las páginas de eLinux son excelentes lugares para comenzar.

Vea este enlace para la configuración general de Wifi de RPI.

Si planea usar algún tipo de cámara o cámara web en el bot, eche un vistazo a estas páginas para obtener los archivos básicos necesarios.

• Configuración de la cámara RPI
• Configuración de la cámara eLinix RPI

Transmitiendo video:

Hay algunas formas de hacer que la transmisión de video funcione en un RPI, pero el método que prefiero es usar Motion.

Para instalarlo en su RPI, ejecute esto: sudo apt-get install motion

Este instructivo también repasa la configuración para la transmisión.

Paso 7: Configuración del puerto serie RPI

Necesitaremos deshabilitar el modo de consola de Linux para usar RX y TX ya que queremos hablar con el controlador de motor RoboClaw desde este puerto. Para hacer esto, puede utilizar este método o esta herramienta. La elección del método es suya, ya que ambos hacen lo mismo al final.

Paso 8: instalación de los módulos de Python

Necesitará python instalado en el RPI, así como el instalador del paquete python pip.

Para instalar pip, haz lo siguiente:

1. sudo apt-get install python-setuptools
2. sudo easy_install pip

Luego:

1. sudo pip instalar matraz
2. sudo pip instalar pyserial
3. sudo pip instalar RPIO

Estos serán todos los módulos necesarios para que se ejecute el código.

Paso 9: Configuración de RoboClaw

Tengo el código del robot hablando con RoboClaw en modo serial estándar a 19200 baudios.

Para configurar RoboClaw para esto, haga lo siguiente:

1. Pulsa el botón "MODO" en RoboClaw
2. Presione el botón de configuración hasta que el LED parpadee 5 (cinco) veces entre los retrasos
3. Pulsa el botón "LIPO" para almacenar
4. Luego presione el botón "SET" hasta que el LED parpadee 3 (tres) veces entre los retrasos
5. Presione el botón LIPO para almacenar

Eso es todo para configurar el controlador del motor. Consulte el pdf vinculado anteriormente para obtener más información si es necesario.

Paso 10: Instalación del programa / archivos de Rover

Descargue y copie el archivo rover.zip a su RPI en su directorio de usuario pi.

Si está ejecutando Linux o Mac, puede usar 'scp' para hacerlo:

scp ~ / ubicación / del / el / archivo / rover.zip pi @ your_rpi_ip: / ~

Para Windows, puede descargar y usar pscp y luego hacer:

pscp /location/of/the/file/rover.zip pi @ your_rpi_ip: / ~

Una vez que el archivo zip se haya copiado en el RPI, inicie sesión como usuario pi.

Ahora ejecuta:

descomprimir rover.zip

Esto descomprimirá los archivos en una carpeta llamada 'rover' y tendrá lo siguiente en esa carpeta:

• restrover.py (El código Python para el robot)
• estático (contiene los archivos de imagen para los botones en la página de control)
• plantillas (contiene el archivo index.htlm, la página web de control)

Si está utilizando una cámara web, modifique la línea cerca de la parte inferior del archivo index.html en la carpeta de la plantilla. Cambie la URL en la línea IFRAME para que coincida con la URL src de su transmisión de video.

Paso 11: Poner en marcha el bot

Conecte la alimentación USB al RPI.

Para iniciar el código del bot, inicie sesión como usuario pi y ejecute:

• cd rover
• sudo python restrover.py

Si todo estuvo bien, debería ver una pantalla similar a la imagen en este paso

Si ve algún error o problema, deberá solucionarlo antes de seguir adelante.

Ahora, conecte el cable GND (-) al terminal NEG (-) en la entrada de energía del motor RoboClaw.

Paso 12: Acceder a la página de control de bots

Una vez que se esté ejecutando el script de Python del robot, encienda el RoboClaw y luego navegue hasta la IP de su RPI como:

your_rpi_ip

Debería ver aparecer la página de control web como en las imágenes. Si no es así, verifique su terminal de salida RPI y busque errores y corríjalos.

Una vez en la página, estará listo para controlar el bot.

El robot se pondrá en marcha en la configuración "Ejecución media" y en la velocidad media.

El bot se puede controlar mediante los botones de la página o mediante las teclas del teclado.

Las claves son:

• w - adelante
• z - atrás / atrás
• un - giro largo a la izquierda
• s - giro largo a la derecha
• q - giro corto a la izquierda
• e - giro corto a la derecha
• 1 - cámara panorámica a la izquierda
• 2 - cámara panorámica a la derecha
• 3 - pan completo a la izquierda
• 4 - pan completo a la derecha
• / - cámara de inicio / centro
• h - detener / detener robot

Hay un búfer de retardo de medio segundo entre los comandos enviados. Hice esto para eliminar los comandos repetidos no deseados. Por supuesto, puede eliminar esto del código si lo desea (en index.html)

El resto de los controles y su control deben explicarse por sí mismos.

Paso 13: El código Python / Flask

Este bot usa Python y el marco web Flask. Puede obtener más información sobre Flask aquí si está interesado.

La gran diferencia con una aplicación Flask y un script Python normal es la clase / método @ app.route que se usa para manejar el URI. Aparte de eso, es Python bastante normal en su mayor parte.

#! / usr / bin / env python

# # Wifi / Rover impulsado por la Web # # Escrito por Scott Beasley - 2015 # # Utiliza RPIO, pyserial y Flask # tiempo de importación importar serial desde RPIO importar PWM desde flask import Flask, render_template, request app = Flask (_name_, static_url_path = '') # Conéctese al puerto de comunicaciones para hablar con el controlador del motor Roboclaw intente: # Cambie la velocidad en baudios aquí si es diferente a 19200 roboclaw = serial. Serial ('/ dev / ttyAMA0', 19200) excepto IOError: print ("El puerto de comunicaciones no found ") sys.exit (0) # Variables de control de velocidad y accionamiento last_direction = -1 speed_offset = 84 turn_tm_offset = 0.166 run_time = 0.750 # Posición neutra del servo (inicio) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Una pequeña pausa para establecer el tiempo time.sleep (3) # # Controladores URI: todas las acciones de la página de bots se realizan aquí # # Envíe la página de control de bots (página de inicio) @ app.route ("/") def index (): return render_template ('index.html', name = None) @ app.route ("/ forward") def forward (): global last_direction, run_ti me print "Adelante" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Si no es continuo, deténgase después de la demora si run_time> 0: last_direction = -1 halt () return "ok" @ app.route ("/ backward") def backward (): global last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Si no es continuo, deténgase después de la demora if run_time> 0: last_direction = -1 halt () return "ok" @ app.route ("/ left") def left (): global last_direction, turn_tm_offset print "Left" go_left () last_direction = -1 # sleep @ 1 / 2 segundos time.sleep (0.500 - turn_tm_offset) # stop halt () time.sleep (0.100) return "ok" @ app.route ("/ right") def right (): global last_direction, turn_tm_offset print "Right" go_right () # dormir @ 1/2 segundo time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @ app.route ("/ ltforward") def ltforward (): última dirección global, turn_t m_offset print "Giro hacia adelante a la izquierda" go_left () # sleep @ 1/8 second time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/ rtforward") def rtforward (): last_direction global, turn_tm_offset print "Giro hacia adelante a la derecha" go_right () # sleep @ 1/8 second time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @ app.route ("/ stop") def stop (): global last_direction print "Stop" halt () last_direction = -1 # sleep 100ms time.sleep (0.100) return "ok" @ app.route ("/ panlt") def panlf (): global servo_pos print "Panlt" servo_pos - = 100 if servo_pos 2500: servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time. sleep (0.150) return "ok" @ app.route ("/ home") def home (): global servo_pos print "Home" servo_pos = 1250 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ panfull_lt") def panfull_lt (): global servo_pos print "Pan full l eft "servo_pos = 500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return" ok "@ app.route (" / panfull_rt ") def panfull_rt (): global servo_pos print" Pan full right "servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ speed_low") def speed_low (): global speed_offset, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0.001 # Actualiza la dirección actual para obtener una nueva velocidad if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ speed_mid") def speed_mid (): global speed_offset, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Actualiza la dirección actual para obtener una nueva velocidad if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ speed_hi") def speed_hi (): speed_offset global, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Actualiza la dirección actual para obtener una nueva velocidad if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ continuo ") def continuo (): global run_time print" Ejecución continua "run_time = 0 # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / mid_run ") def mid_run (): global run_time print" Mid run "run_time = 0.750 halt () # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / short_time ") def short_time (): global run_time print" Short run "run_time = 0.300 halt () # sleep 100ms time.sleep (0.100) return "ok" # # Funciones de accionamiento del motor # def go_forward (): speed_offset global if speed_offset! = 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_backward (): global speed_offset if speed_offset! = 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.wri te (chr (255 - speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) def go_left (): speed_offset global if speed_offset! = 42: roboclaw.write (chr (127 - desplazamiento_velocidad)) roboclaw.write (chr (128 + desplazamiento_velocidad)) else: roboclaw.write (chr (1 + desplazamiento_velocidad)) roboclaw.write (chr (255 - desplazamiento_velocidad)) def go_right (): desplazamiento_velocidad global si speed_offset! = 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) def halt (): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Si no desea o necesita información de depuración de Flask, configure debug en 'false' en la línea app.run.

if _name_ == "_main_":

app.run (host = '0.0.0.0', puerto = 80, debug = False)

También puede cambiar el puerto en el que escucha el servidor http de Flask aquí.

Paso 14: uso de otro hardware

Si desea utilizar otro hardware, como otro tipo de SBC (computadora de placa única), debería tener pequeños problemas para que Python y Flask se ejecuten en otras placas como Beagle Bone, PCDuino, etc. Tendrá que cambiar el código para que coincida con el GPIO Diseño y uso de las capacidades de conducción servo de la nueva placa.

Para usar otro tipo de controlador de motor, solo necesita modificar las funciones go_forward, go_backward, go_left, go_right y detener para hacer lo que necesite el controlador de motor de reemplazo para que el motor haga esa función en particular.