Rover controlat web: 14 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Construirea și jocul cu roboți este principala mea plăcere vinovată în viață. Alții joacă golf sau schi, dar eu construiesc roboți (deoarece nu pot juca golf sau schi:-). Mi se pare relaxant și distractiv! Pentru a face majoritatea roboților mei, folosesc kituri de șasiu. Folosirea de truse mă ajută să fac ceea ce îmi place mai mult, software-ul și electronica și, de asemenea, asigură un șasiu mai bun pentru mine.

În acest Instructable, vom analiza ce este nevoie pentru a face un rover controlat prin Wifi / web simplu, dar robust. Șasiul folosit este Actobotics Gooseneck. L-am ales pentru dimensiunea, capacitatea de extindere și costul său, dar puteți utiliza orice alt șasiu la alegere.

Pentru un astfel de proiect, vom avea nevoie de un computer solid solid, cu o singură placă, iar pentru acest bot am ales să folosesc Raspberry Pi (RPI) un computer bazat pe Linux. RPI (și Linux) ne oferă o mulțime de opțiuni de codare, iar Python va fi folosit pentru partea de codare. Pentru interfața web folosesc Flask, un framework web ușor pentru Python.

Pentru a conduce motoarele, am ales un RoboClaw 2x5a. Permite o comunicare serială simplă pentru comandarea acesteia și funcționează bine cu RPI și motoarele de pe gâtul de găină.

În cele din urmă, are o cameră web pentru feedback video de tip POV pentru a o conduce de la distanță. Voi acoperi fiecare subiect mai detaliat mai târziu.

Pasul 1: hardware necesar

• Șasiu Actobotics Gooesneck sau un înlocuitor adecvat la alegere
• Raspberry Pi la alegere (sau clonă) - Un RPI model B este utilizat pe acest bot, dar oricare cu cel puțin două porturi USB va funcționa
• Servo placa standard B x1
• Suport canal unghi 90 ° x1
• Driver motor RoboClaw 2x5a
• S3003 sau servo de dimensiuni standard similar
• Placă mică sau mini placă de măsurare
• Firele jumperului de la femeie la femeie
• Sârme jumper de la bărbat la feminin
• Cam web (opțional) - Folosesc un Logitech C110 și iată o listă a camelor acceptate pentru RPI
• Sursă de alimentare 5v-6v pentru servodirecție
• Baterie 7.2v-11.1v pentru alimentarea motorului de acționare
• 5v 2600mah (sau mai mare) banc de alimentare USB pentru RPI
• Adaptor USB Wifi

Pe botul meu, folosesc roți de 4 pentru a-l face mai mult All-Terrain-Indoor. Pentru această opțiune veți avea nevoie de:

• Roată rezistentă de 4 "x2
• Butuc cu șurub de 4 mm alezat (0,770 inch) x2

Pasul 2: Asamblarea șasiului

Mai întâi asamblați șasiul urmând instrucțiunile incluse cu șasiul sau video. După ce terminați, ar trebui să aveți ceva de genul imaginii. NOTĂ: La asamblarea piesei gâtului, lăsați suportul de montare oprit.

Pe botul meu, am ales să înlocuiesc roțile cu care a venit șasiul pentru roțile de 4 grele. Acest lucru este opțional și nu este necesar decât dacă doriți să faceți același lucru.

Pasul 3: Montarea dispozitivelor electronice

Gâtul de găină are mult spațiu și opțiuni pentru montarea electronice. Vă dau aceste imagini ca linie de ghidare, dar puteți alege cum doriți să le expuneți. Puteți utiliza stand-off-uri, bandă dublă, Velcro sau servo-bandă pentru a monta placa și bateriile.

Pasul 4: Adăugarea camerei web

Luați suportul de 90 de grade, butucul servo ușor și cele patru (4) șuruburi.3125 pentru acest pas:

• Luați butucul servo și plasați-l pe o parte a suportului și fixați-l împreună cu șuruburile.2125 "așa cum se arată în imagine
• Apoi montați servo-ul în consola servo
• Atașați consola de 90 de grade cu claxonul servo la coloana vertebrală a servomotorului și utilizați șurubul claxonului care a venit împreună cu servo-ul pentru a le conecta împreună
• Acum montați Servo în paranteză pe partea superioară a gâtului de gâscă cu șuruburile rămase
• Montați camera cu fermoare sau bandă dublă pe suportul de 90 de grade

Utilizați imaginile pentru ghiduri, dacă este necesar.

Pasul 5: Cablarea totul

Cablajul este destul de strâns înainte pentru acest robot.

Motoarele:

Lipirea conduce pe ambele motoare dacă nu ați făcut-o deja

Cu roboții din față (capătul cu gâtul de gâscă) îndreptat spre tine:

• Conectați firele motorului de pe motorul din stânga la canalele M1A și M1B
• Conectați firele motorului motorului din dreapta la canalele M2A și M2B

Conexiuni la sol (GND):

• Conectați un știft de masă de pe RoboClaw la placa jumperului de masă. Linia de pini de la sol de pe RoboClaw este cea mai apropiată de centru (Vezi imaginea)
• Conectați PIN-ul 6 de pe RPI la placa jumper. Consultați imaginea antetului RPI pentru atribuirea pinilor.
• Conectați GND de la pachetul de baterii servo la unul dintre pinii de pe placa jumper.
• Rulați un cablu jumper de la placa jumper la firul GND servos.

RPI către RoboClaw:

Conectați pinul RPI GPIO14 TXD la pinul RoboClaw S1

Putere:

• Conectați firul POS de la servo baterie la cablul POS servos
• Conectați firul POS de la bateria motorului la POS (+) al terminalului de intrare a puterii motorului RoboClaw. Vom lăsa terminalul GND deconectat pentru moment.

Pasul 6: Configurarea RPI

Presupun că utilizatorul de aici știe ceva despre Linux și RPI. Nu acoper cum să configurez sau să mă conectez la unul. Dacă aveți nevoie de ajutor, utilizați paginile de mai jos.

Pentru a vă configura RPI, aruncați o privire la următoarele pagini:

• Configurare de bază RPI
• RPI Ghid de pornire rapidă
• NOOBS setup guilde

Pentru paginile generale salt, pagina principală RPI și paginile eLinux sunt locuri excelente pentru a începe.

Consultați acest link pentru configurarea generală a RPI Wifi.

Dacă intenționați să utilizați un fel de cameră sau web cam pe bot, aruncați o privire la aceste pagini pentru a obține fișierele de bază necesare.

• Configurarea camului RPI
• Configurare cam eLinix RPI

Streaming video:

Există câteva modalități de a face streaming video să funcționeze pe un RPI, dar metoda pe care o prefer este folosirea Motion.

Pentru a-l instala pe RPI, executați acest lucru: sudo apt-get install motion

Acest instrucatabil trece peste configurarea acestuia și pentru streaming.

Pasul 7: Configurarea portului serial RPI

Va trebui să dezactivăm modul consolă Linux pentru utilizarea RX și TX deoarece vrem să vorbim cu controlerul motor RoboClaw de la acest port. Pentru a face acest lucru, puteți utiliza această metodă sau acest instrument. Alegerea este a ta cu privire la metodă, deoarece ambii fac același lucru în cele din urmă.

Pasul 8: Instalarea modulelor Python

Veți avea nevoie de python instalat pe RPI, precum și de instalatorul de pachete python pip.

Pentru a instala pip do:

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

Atunci:

1. sudo pip instalare balon
2. sudo pip instalează pyserial
3. sudo pip instalează RPIO

Acestea vor fi toate modulele necesare pentru a rula codul.

Pasul 9: Configurarea RoboClaw

Am codul robotului vorbind cu RoboClaw în modul Serial Standard la 19200 baud.

Pentru a seta RoboClaw pentru acest lucru, faceți:

1. Apăsați butonul „MODE” de pe RoboClaw
2. Apăsați butonul de setare până când LED-ul clipește de 5 (cinci) ori între întârzieri
3. Apăsați butonul „LIPO” pentru a stoca
4. Apoi apăsați butonul „SET” până când LED-ul clipește de 3 (trei) ori între întârzieri
5. Apăsați butonul LIPO pentru a stoca

Asta este pentru configurarea controlerului motorului. Consultați pdf-ul legat mai sus pentru mai multe informații, dacă este necesar.

Pasul 10: Instalarea programului / fișierelor Rover

Descărcați și copiați fișierul rover.zip în RPI în directorul dvs. de utilizator pi.

Dacă rulați Linux sau un Mac, puteți utiliza „scp” pentru a face acest lucru:

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

Pentru Windows, puteți descărca și utiliza pscp și apoi faceți:

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

Odată ce fișierul zip este copiat în RPI, conectați-vă ca utilizator pi.

Acum rulați:

dezarhivați rover.zip

Aceasta va dezarhiva fișierele într-un folder numit „rover” și va avea următoarele sub acel folder:

• restrover.py (Codul python pentru robot)
• static (deține fișierele de imagine pentru butoanele de pe pagina de control)
• șabloane (deține fișierul index.htlm, pagina web de control)

Dacă utilizați o cameră web, modificați linia în partea de jos a fișierului index.html din folderul șablon. Schimbați adresa URL din linia IFRAME pentru a se potrivi cu adresa URL src pentru fluxul dvs. video.

Pasul 11: Pornirea Bot Up

Conectați alimentarea USB la RPI.

Pentru a porni codul bot, conectați-vă ca utilizator pi și rulați:

• cd rover
• sudo python restrover.py

Dacă totul a fost în regulă, ar trebui să vedeți un ecran similar cu imaginea din acest pas

Dacă vedeți erori sau probleme, va trebui să le remediați înainte de a merge mai departe.

Acum, conectați firul GND (-) la terminalul NEG (-) de la intrarea de putere a motorului RoboClaw.

Pasul 12: Accesarea paginii de control Bot

După ce scriptul python al robotului rulează, porniți RoboClaw și apoi navigați la adresa IP a RPI, cum ar fi:

your_rpi_ip

Ar trebui să vedeți că pagina de control Web apare ca în imagini. Dacă nu, verificați terminalul de ieșire RPI și căutați orice erori și corectați-le.

Odată ajuns pe pagină, sunteți gata să controlați botul.

Robotul va porni în setarea „Med run” și la viteza medie.

Botul poate fi controlat prin butoanele de pe pagină sau prin tastele de pe tastatură.

Cheile sunt:

• w - înainte
• z - invers / înapoi
• a - viraj lung la stânga
• s - viraj lung la dreapta
• q - viraj scurt la stânga
• e - viraj scurt la dreapta
• 1 - camera panoramică la stânga
• 2 - panoramare dreapta
• 3 - tigaie complet la stânga
• 4 - panoramare complet dreapta
• / - cameră de acasă / centru
• h - opri / oprește robotul

Există un buffer de întârziere de jumătate de secundă între comenzile trimise. Am făcut acest lucru pentru a elimina comenzile repetate nedorite. Desigur, puteți elimina acest lucru din cod dacă doriți (în index.html)

Restul controalelor și controlul acestuia ar trebui să se explice de la sine.

Pasul 13: Codul Python / Flask

Acest bot folosește Python și cadrul web Flask. Puteți afla mai multe despre Flask aici dacă sunteți interesat.

Diferența mare față de o aplicație Flask și un script Python normal este clasa / metoda @ app.route folosită pentru a face manipularea URI. În afară de asta, Python este destul de normal în cea mai mare parte.

#! / usr / bin / env python

# # Wifi / Web driven Rover # # Scris de Scott Beasley - 2015 # # Folosește RPIO, pyserial și Flask # import timp import serie de la RPIO import PWM din import flask Flask, render_template, request app = Flask (_name_, static_url_path = ") # Conectați-vă la portul de comunicare pentru a vorbi cu controlerul motor Roboclaw încercați: # Modificați rata de transmisie aici dacă este diferită de 19200 roboclaw = serial. Serial ('/ dev / ttyAMA0', 19200) cu excepția IOError: print ("Portul de comunicare nu găsit ") sys.exit (0) # Variabile de control al vitezei și al acționării 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) # O mică stațiune pentru stabilirea timpului time.sleep (3) # # Handlerele URI - toate acțiunile din pagina de bot sunt efectuate aici # # Trimiteți pagina de control a roboților (pagina de pornire) @ app.route ("/") def index (): return render_template ('index.html', name = None) @ app.route ("/ forward") def forward (): last_direction global, run_ti printez "Forward" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time time) # Dacă nu este continuu, atunci opriți după întârziere dacă run_time> 0: last_direction = -1 stop () returnează "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) # Dacă nu este continuu, opriți după întârziere 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 second time.sleep (0.500 - turn_tm_offset) # stop halt () time.sleep (0.100) returnează „ok” @ app.route („/ right”) def right (): global last_direction, turn_tm_offset print „Right” go_right () # sleep @ 1/2 second time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop stop () time.sleep (0.100) returnează "ok" @ app.route ("/ ltforward") def ltforward (): ultima_direcție globală, turn_t m_offset print "Întoarcere spre stânga" 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) returnează "ok" @ app.route ("/ stop") def stop (): global last_direction print "Stop" stop () last_direction = -1 # sleep 100ms time.sleep (0.100) returnează "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 (): servo_pos global print "Pan full l eft "servo_pos = 500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) returnează" 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) returnează "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ți direcția curentă pentru a obține o nouă viteză dacă last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return 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 # Actualizați direcția curentă pentru a obține viteză nouă dacă last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) returnează „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ți direcția curentă pentru a obține o viteză nouă dacă last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) returnează "ok" @ app.route ("/ continuu ") def continuous (): run_time global print" Run continuu "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 halt () # 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 halt () # dorm 100ms time.sleep (0.100) returnează „ok” # # Funcții ale motorului # 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 (): global speed_offset if 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 (): global speed_offset if 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)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Dacă nu doriți sau nu aveți nevoie de informații de depanare din Flask, setați depanarea la „fals” pe linia app.run.

dacă _name_ == "_main_":

app.run (gazdă = '0.0.0.0', port = 80, depanare = fals)

De asemenea, puteți modifica portul pe care îl ascultă serverul Flask http aici.

Pasul 14: Utilizarea altui hardware

Dacă doriți să utilizați alt hardware, cum ar fi un alt tip de computer SBC (Single Board Computer), ar trebui să aveți mici probleme când Python și Flask rulează pe alte plăci precum Beagle Bone, PCDuino etc … Va trebui să schimbați codul pentru a se potrivi cu GPIO dispuneți și utilizați capacitățile de servodirecție ale noii plăci.

Pentru a utiliza un alt tip de driver de motor, trebuie doar să modificați funcțiile go_forward, go_backward, go_left, go_right și stop pentru a face tot ce are nevoie driverul de înlocuire pentru ca motorul să îndeplinească acea funcție specială.