Rover controlat per web: 14 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

Construir i jugar amb robots és el meu principal plaer culpable a la vida. Altres juguen a golf o esquí, però jo construeixo robots (ja que no puc jugar a golf ni esquiar:-). Em sembla relaxant i divertit! Per fer la majoria dels meus robots, faig servir kits de xassís. L’ús de kits m’ajuda a fer allò que més m’agrada, el programari i l’electrònica, i també proporciona un millor xassís per a mi.

En aquest instructiu, analitzarem el que es necessita per fer un rover controlat per Wifi / web senzill però robust. El xassís utilitzat és l’Actobotics Gooseneck. L’he escollit per la seva mida, capacitat d’ampliació i cost, però podeu utilitzar qualsevol altre xassís que vulgueu.

Per a un projecte com aquest, necessitarem un bon ordinador de placa única sòlid i per a aquest bot vaig escollir utilitzar el Raspberry Pi (RPI) un ordinador basat en Linux. L'RPI (i Linux) ens proporciona moltes opcions de codificació i Python s'utilitzarà per al costat de codificació. Per a la interfície web faig servir Flask, un framework web lleuger per a Python.

Per conduir els motors, vaig triar un RoboClaw 2x5a. Permet una comunicació serial senzilla per comandar-lo i funciona bé amb el RPI i els motors del coll de cigne.

Finalment, té una càmera web per a comentaris de vídeo de tipus POV per conduir-lo de forma remota. Més endavant tractaré cada tema amb més detall.

Pas 1: cal fer maquinari

• Xassís Actobotics Gooesneck o un recanvi adequat que escolliu
• Raspberry Pi que trieu (o clonar): s'utilitza un model RPI B en aquest bot, però qualsevol amb almenys dos ports USB funcionarà
• Servo placa estàndard B x1
• Suport de canal d'un angle de 90 ° x1
• Controlador de motor RoboClaw 2x5a
• Servo de mida estàndard S3003 o similar
• Tauleta de menjador petita o Mini
• Filferos de pont femení a femení
• Cavalls de pont masculí a femení
• Càmera web (opcional): faig servir una Logitech C110, i aquí teniu una llista de càmeres compatibles amb el RPI
• Font d'alimentació de 5v-6v per a servoalimentació
• Bateria de 7.2v-11.1v per alimentar el motor del motor
• Banc d'alimentació USB de 5v 2600mah (o superior) per a l'RPI
• Adaptador USB Wifi

Al meu bot, faig servir rodes de 4 polzades perquè sigui una mica més tot terreny-interior. Per a aquesta opció necessitareu:

• Roda resistent de 4 "x2
• Hub de cargol de 4 mm de forat (0,770 polzades) x2

Pas 2: Muntatge del xassís

Primer, munteu el xassís seguint les instruccions incloses amb el xassís o el vídeo. Després d'acabar, hauríeu de tenir alguna cosa com la imatge. NOTA: En muntar la part del coll, només cal deixar el suport de muntatge apagat.

En el meu bot, vaig optar per substituir les rodes amb què venia el xassís per rodes de 4 de gran resistència. Això és opcional i no és necessari tret que vulgueu fer el mateix.

Pas 3: muntatge de l'electrònica

El Gooseneck té molt d'espai i opcions per muntar l'electrònica. Us dono aquestes imatges com a guia, però podeu escollir com voleu dissenyar-ho tot. Podeu utilitzar separadors, cinta de doble cara, velcro o servo-cinta per muntar la placa i les bateries.

Pas 4: Afegir la càmera web

Agafeu el suport de 90 graus, el cub servo lleuger i els quatre (4) cargols de.3125 per a aquest pas:

• Agafeu el hub del servo i col·loqueu-lo en un costat del suport i fixeu-los junt amb els cargols de.2125 "com es mostra a la imatge
• A continuació, monteu el servo al suport del servo
• Connecteu el suport de 90 graus amb la banya del servo a la columna vertebral dels servos i utilitzeu el cargol de banya que venia amb el servo per connectar-los
• Ara munteu el Servo entre suports a la part superior del coll d’oca amb els cargols restants
• Muntar la càmera amb tirants o cinta adhesiva de doble cara al suport de 90 graus

Utilitzeu les imatges com a guies si cal.

Pas 5: cablejar-ho tot

El cablejat és força estret cap endavant per a aquest robot.

Els motors:

La soldadura condueix als dos motors si encara no ho heu fet

Amb els robots davanters (l'extrem amb el coll d'oca) cap a fora:

• Connecteu els cables del motor del motor esquerre al canal M1A i M1B
• Connecteu els cables del motor del motor dret al canal M2A i M2B

Connexions de terra (GND):

• Connecteu un passador de terra del RoboClaw a la placa de pont de terra. La línia de passadors de terra del RoboClaw és la més propera al centre (Veure foto)
• Connecteu el PIN 6 al RPI a la placa de pont. Consulteu la foto de capçalera RPI per obtenir assignacions de pins.
• Connecteu el GND del paquet de bateries servo a un dels pins de la placa de pont.
• Executeu un cable de pont des de la placa de pont al cable GND de servos.

RPI a RoboClaw:

Connecteu el pin RPI GPIO14 TXD al pin RoboClaw S1

Potència:

• Connecteu el cable TPV de la bateria del servo al cable TPV dels servos
• Connecteu el cable TPV de la bateria del motor al TPV (+) del terminal d’entrada d’alimentació del motor RoboClaw. Deixarem la terminal GND desconnectada per ara.

Pas 6: Configuració de l'RPI

Suposo que l'usuari aquí en sap algunes coses sobre Linux i l'RPI. No explico com configurar-lo ni connectar-me-hi. Si necessiteu ajuda, utilitzeu les pàgines següents.

Per configurar el vostre RPI, consulteu les pàgines següents:

• Configuració bàsica de RPI
• RPI Guia d'inici ràpid
• Guilde de configuració de NOOBS

Per a les pàgines generals de salt, la pàgina principal de RPI i les pàgines eLinux són un lloc ideal per començar.

Consulteu aquest enllaç per obtenir la configuració general de Wifi de RPI.

Si teniu previst utilitzar algun tipus de càmera o càmera web al bot, mireu aquestes pàgines per obtenir els fitxers bàsics necessaris.

• Configuració de la càmera RPI
• Configuració de la càmera eLinix RPI

Reproducció de vídeo:

Hi ha algunes maneres de fer que la transmissió de vídeo funcioni en un RPI, però el mètode que prefereixo és utilitzar Motion.

Per instal·lar-lo al vostre RPI, executeu això: sudo apt-get install motion

Aquest instrucatable passa per configurar-lo per a la transmissió també.

Pas 7: Configuració del port sèrie RPI

Haurem de desactivar el mode de consola Linux per utilitzar RX i TX, ja que volem parlar amb el controlador del motor RoboClaw des d’aquest port. Per fer-ho, podeu utilitzar aquest mètode o aquesta eina. L’elecció correspon al mètode, ja que tots dos fan el mateix al final.

Pas 8: Instal·lació dels mòduls Python

Necessitareu instal·lar python a l'RPI, així com el pip instal·lador de paquets python.

Per instal·lar pip do:

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

Després:

1. matràs d'instal·lació sudo pip
2. sudo pip instal·lar pyserial
3. sudo pip instal·la RPIO

Aquests seran tots els mòduls necessaris perquè el codi s’executi.

Pas 9: Configuració del RoboClaw

Tinc el codi del robot parlant amb el RoboClaw en mode sèrie estàndard a 19200 bauds.

Per configurar el RoboClaw per a això, feu el següent:

1. Feu clic al botó "MODE" del RoboClaw
2. Premeu el botó de configuració fins que el LED parpellegi 5 (cinc) vegades entre els retards
3. Feu clic al botó "LIPO" per emmagatzemar-lo
4. A continuació, premeu el botó "SET" fins que el LED parpellegi 3 (tres) vegades entre els retards
5. Feu clic al botó LIPO per emmagatzemar-lo

Això és tot per configurar el controlador del motor. Consulteu el pdf enllaçat anteriorment per obtenir més informació si cal.

Pas 10: Instal·lació del programa / fitxers Rover

Baixeu-vos i copieu el fitxer rover.zip al vostre RPI al directori d’usuaris pi.

Si utilitzeu Linux o un Mac, podeu utilitzar 'scp' per fer-ho:

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

Per a Windows, podeu baixar i utilitzar pscp i fer:

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

Un cop copiat el fitxer zip a l'RPI, inicieu la sessió com a usuari pi.

Ara executeu:

descomprimir rover.zip

Això descomprimirà els fitxers a una carpeta anomenada "rover" i tindrà el següent a aquesta carpeta:

• restrover.py (El codi python del robot)
• estàtic (conté els fitxers d'imatge dels botons de la pàgina de control)
• plantilles (conté el fitxer index.htlm, la pàgina web de control)

Si feu servir una càmera web, modifiqueu la línia a la part inferior del fitxer index.html de la carpeta de plantilles. Canvieu l'URL de la línia IFRAME perquè coincideixi amb l'URL src del vostre flux de vídeo.

Pas 11: Inici del bot cap amunt

Connecteu l'alimentació USB a l'RPI.

Per iniciar el codi bot, inicieu la sessió com a usuari pi i executeu:

• cd rover
• sudo python restrover.py

Si tot estava bé, hauríeu de veure una pantalla similar a la imatge en aquest pas

Si veieu algun error o problema, haureu de solucionar-los abans de continuar.

Ara, connecteu el cable GND (-) al terminal NEG (-) de l’entrada d’alimentació del motor RoboClaw.

Pas 12: accediu a la pàgina de control de bot

Un cop s'executi l'script python del robot, engegueu el RoboClaw i, a continuació, aneu a la vostra IP de RPI com:

your_rpi_ip

Hauríeu de veure com apareix la pàgina de control web com a les imatges. Si no, comproveu el terminal de sortida RPI i busqueu errors i corregiu-los.

Un cop a la pàgina, ja podeu controlar el bot.

El robot s'iniciarà a la configuració "Med run" ia la velocitat mitjana.

El bot es pot controlar mitjançant els botons de la pàgina o mitjançant les tecles del teclat.

Les claus són:

• w - endavant
• z - invers / enrere
• un - llarg gir a l'esquerra
• s - llarg gir a la dreta
• q: gir curt a l'esquerra
• e - gir curt a la dreta
• 1 - Es queda càmera panoràmica
• 2 - càmera panoràmica dreta
• 3 - paella a l'esquerra
• 4 - paella a la dreta
• / - càmera domèstica / central
• h - parar / aturar el robot

Hi ha un buffer de retard de mig segon entre les ordres enviades. Ho vaig fer per eliminar ordres repetides no desitjades. Per descomptat, podeu eliminar-ho del codi si voleu (a index.html)

La resta de controls i el seu control haurien d’explicar-se per si mateixos.

Pas 13: el codi Python / Flask

Aquest bot fa servir Python i el framework web Flask. Podeu obtenir més informació sobre Flask aquí si us interessa.

La gran diferència d’una aplicació Flask i un script Python normal és la classe / mètode @ app.route que s’utilitza per fer el maneig de l’URI. A part d'això, és pràcticament normal Python.

Python #! / usr / bin / env

# # Wifi / Web driven Rover # # Escrit per Scott Beasley - 2015 # # Utilitza RPIO, pyserial i Flask # importació en temps d'importació de sèrie des de RPIO importació PWM des de flask import Flask, render_template, request app = Flask (_name_, static_url_path = ") # Connecteu-vos al port de comunicació per parlar amb el controlador del motor de Roboclaw. Intenteu: # Canvieu la velocitat de transmissió aquí si és diferent de 19200 roboclaw = serial. Serial ('/ dev / ttyAMA0', 19200) excepte IOError: print ("Port de comunicació no trobat ") sys.exit (0) # Variables de control de velocitat i transmissió last_direction = -1 speed_offset = 84 turn_tm_offset = 0,166 run_time = 0,750 # Servo neutral position (home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Una petita estada per establir el temps time.sleep (3) # # Gestors d'URI: totes les accions de la pàgina de bot es fan aquí # # Envia la pàgina de control de bots (pàgina d'inici) @ app.route ("/") def index (): return render_template ('index.html', name = None) @ app.route ("/ forward") def forward (): last_direction global, run_ti imprimeixo "Endavant" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time time) # Si no és continu, atura després del retard si run_time> 0: last_direction = -1 halt () torna "ok" @ app.route ("/ backward") def backward (): last_direction global, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Si no és continu, atureu-vos després del retard 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 segons time.sleep (0.500 - turn_tm_offset) # stop stop () time.sleep (0.100) retorna "ok" @ app.route ("/ right") def right (): last_direction global, turn_tm_offset print "Right" go_right () # sleep @ 1/2 segon time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop stop () time.sleep (0.100) return "ok" @ app.route ("/ ltforward") def ltforward (): última_direcció global, turn_t m_offset print "Left forward turn" go_left () # sleep @ 1/8 second time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop stop () time.sleep (0.100) return "ok" @app.route ("/ rtforward") def rtforward (): last_direction global, turn_tm_offset print "Right forward turn" go_right () # sleep @ 1/8 second time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop stop () time.sleep (0.100) return "ok" @ app.route ("/ stop") def stop (): global last_direction print "Stop" stop () last_direction = -1 # sleep 100ms time.sleep (0.100) torna "ok" @ app.route ("/ panlt") def panlf (): servo_pos global 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 (): servo_pos global 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 (): servo_pos global 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 (): speed_offset global, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0.001 # Actualitzeu la direcció actual per obtenir nova velocitat si 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 (): speed_offset global, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Actualitza la direcció actual per obtenir nova velocitat si last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) torna "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 # Actualitza la direcció actual per obtenir nova velocitat si last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ continu ") def continue (): run_time global print" Run continu "run_time = 0 # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / mid_run ") def mid_run (): run_time global print" Mid run "run_time = 0.750 stop () # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / short_time ") def short_time (): run_time global print" Short run "run_time = 0.300 stop () # dorm 100ms time.sleep (0.100) torna "ok" # # Funcions de la unitat de motor # def go_forward (): speed_offset global si 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 (): speed_offset global si 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 si speed_offset! = 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_right (): speed_offset 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 stop (): roboclaw.write (chr (0)) si _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, depuració = True)

Si no voleu o necessiteu informació de depuració de Flask, configureu la depuració com a "falsa" a la línia app.run.

si _name_ == "_principal_":

app.run (host = '0.0.0.0', port = 80, depuració = False)

També podeu canviar el port on escolta el servidor http de Flask.

Pas 14: utilitzar un altre maquinari

Si voleu utilitzar un altre maquinari, com un altre tipus de SBC (Single Board Computer), hauríeu de tenir problemes per fer funcionar Python i Flask en altres taulers com el Beagle Bone, PCDuino, etc. Haureu de canviar el codi perquè coincideixi amb el GPIO dissenyar i utilitzar les funcions de servoconducció de la nova placa.

Per utilitzar un altre tipus de controlador de motor, només heu de modificar les funcions go_forward, go_backward, go_left, go_right i stop per fer el que el controlador de motor de reemplaçament necessiti perquè el motor faci aquesta funció en particular.