Webbeheerde Rover: 14 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Die bou van en speel met robotte is my grootste plesier in die lewe. Ander speel gholf of ski, maar ek bou robotte (aangesien ek nie kan gholf of ski nie:-). Ek vind dit ontspannend en lekker! Om die meeste van my bots te maak, gebruik ek onderstelstelle. Die gebruik van kits help my om meer te doen waarvoor ek hou, die sagteware en elektronika, en sorg ook vir 'n beter onderstel vir my self-duime.

In hierdie instruksies kyk ons na wat nodig is om 'n eenvoudige maar robuuste Wifi/webbeheerde rover te maak. Die onderstel wat gebruik word, is die Actobotics Gooseneck. Ek het dit gekies vir sy grootte, uitbreidingsvermoë en koste, maar u kan enige ander onderstel van u keuse gebruik.

Vir 'n projek soos hierdie het ons 'n goeie soliede enkelbordrekenaar nodig, en vir hierdie bot het ek gekies om die Raspberry Pi (RPI) 'n Linux -gebaseerde rekenaar te gebruik. Die RPI (en Linux) gee ons baie koderingsopsies en Python sal vir die koderingskant gebruik word. Vir die webkoppelvlak gebruik ek Flask, 'n liggewig webraamwerk vir Python.

Om die motors te bestuur, het ek 'n RoboClaw 2x5a gekies. Dit maak voorsiening vir eenvoudige seriële kommunikasie om dit te beheer en werk goed met die RPI en die motors op die Gooseneck.

Uiteindelik het dit 'n webkamera vir POV -tipe video -terugvoer om dit op afstand te bestuur. Ek sal later elke onderwerp in meer besonderhede behandel.

Stap 1: hardeware benodig

• Actobotics Gooesneck -onderstel of 'n geskikte plaasvervanger van u keuse
• Framboos Pi van jou keuse (of kloon) - 'n RPI -model B word op hierdie bot gebruik, maar elkeen met ten minste twee USB -poorte werk
• Standaard servoplaat B x1
• 90 ° enkele hoek kanaalbeugel x1
• RoboClaw 2x5a motorbestuurder
• S3003 of soortgelyke standaard grootte servo
• Klein broodbord of Mini broodbord
• Trui van vroulik tot vroulik
• Trui van man tot vrou
• Webcam (opsioneel) - ek gebruik 'n Logitech C110, en hier is 'n lys van ondersteunde kamera's vir die RPI
• 5v-6v kragbron vir servokrag
• 7.2v-11.1v battery vir die aandrywing van die motor
• 5v 2600mah (of hoër) USB -kragbank vir die RPI
• USB Wifi adapter

Op my bot gebruik ek 4 wiele om dit 'n bietjie meer alles-terrein-binnenshuis te maak. Vir hierdie opsie benodig u:

• 4 "Heavy Duty -wiel x2
• 4 mm boorstel skroefnaaf (0,770 duim) x2

Stap 2: Monteer die onderstel

Monteer eers die onderstel volgens die instruksies by die onderstel of video. Nadat u klaar is, moet u iets soos die beeld hê. OPMERKING: Laat die monteerbeugel by die montering van die nekdeel.

Op my bot het ek gekies om die wiele waarmee die onderstel kom, te vervang vir 4 swaardienswiele. Dit is opsioneel en nie nodig nie, tensy u dieselfde wil doen.

Stap 3: Monteer die elektronika

Die Gooseneck het baie ruimte en opsies om u elektronika te monteer. Ek gee u hierdie foto's as 'n riglyn, maar u kan kies hoe u dit alles wil uiteensit. U kan standplate, dubbelzijdige band, klittenband of servoband gebruik om die bord en batterye te monteer.

Stap 4: Voeg die webkamera by

Neem die 90 grade hakie, ligte servo naaf en vier (4) van die.3125 skroewe vir hierdie stap:

• Neem die servo -naaf en plaas dit aan die een kant van die bracket en maak dit vas met die.2125 "skroewe soos op die foto
• Monteer dan die servo in die servo -houer
• Bevestig die 90 grade hakie met die servohoring aan die servo -ruggraat en gebruik die horingskroef wat by die servo gekom het om dit aan mekaar te koppel
• Monteer nou die Servo tussen hakies bo-op die gansnek met die oorblywende skroewe
• Monteer die kamera met ritsbande of dubbelzijdige band op die 90 grade hakie

Gebruik die prente as gidse indien nodig.

Stap 5: Bedraad alles

Die bedrading is redelik stewig vorentoe vir hierdie robot.

Die motors:

Soldeerslange op beide motors as u dit nog nie gedoen het nie

Met die robotte voor (die einde met die gansnek) van u af weggedraai:

• Koppel die motordrade aan die linkermotor aan die kanaal M1A en M1B
• Koppel die motordrade op die regtermotor aan die kanaal M2A en M2B

Aardverbindings (GND):

• Koppel een grondpen op die RoboClaw aan die grondtrekbord. Die grondpenlyn op die RoboClaw is die naaste aan die middel (sien foto)
• Koppel PIN 6 op die RPI aan die springbord. Sien die prent van die RPI -opskrif vir penopdragte.
• Koppel die GND van die servobattery aan een van die penne op die springbord.
• Draai 'n jumperdraad van die jumper board na die servos GND draad.

RPI aan RoboClaw:

Koppel die RPI GPIO14 TXD -pen aan die RoboClaw S1 -pen

Krag:

• Koppel die POS -draad van die servobattery aan die servos POS -kabel
• Koppel die POS -draad van die motorbattery aan die POS (+) van die RoboClaw -motor se ingangsklem. Ons laat die GND -terminale vir eers ontkoppel.

Stap 6: Die opstel van die RPI

Ek neem aan dat die gebruiker hier iets weet van Linux en die RPI. Ek bespreek nie hoe om dit op te stel of daaraan te koppel nie. Gebruik die bladsye hieronder as u hulp nodig het.

Kyk na die volgende bladsye om u RPI -opstelling te kry:

• RPI Basiese opstelling
• RPI -kitsgids
• NOOBS opstelgilde

Vir algemene wegspringbladsye, is die RPI-hoofblad en die eLinux-bladsye uitstekende plekke om te begin.

Sien hierdie skakel vir die algemene WPI -opstelling van RPI.

As u van plan is om 'n kamera of webkamera op die bot te gebruik, kyk dan na hierdie bladsye om die basiese lêers te kry.

• Opstelling van RPI -kamera
• eLinix RPI -kamera -opstelling

Stroomvideo:

Daar is 'n paar maniere om videostroom op 'n RPI te laat werk, maar die metode wat ek verkies, is om Motion te gebruik.

Om dit op u RPI te installeer, voer hierdie uit: sudo apt-get install motion

Hierdie instruksies gaan ook oor die opstel van dit vir streaming.

Stap 7: Stel die RPI -seriële poort op

Ons sal die Linux -konsolemodus moet deaktiveer vir die gebruik van die RX en TX, aangesien ons met die RoboClaw -motorbeheerder vanuit hierdie poort wil praat. Om dit te kan doen, kan u hierdie metode of hierdie instrument gebruik. Die keuse is u eie op die metode, aangesien hulle altwee dieselfde doen.

Stap 8: Die installering van die Python -modules

U benodig python op die RPI sowel as die python -pakket installeerder pip.

Om pip te installeer, doen:

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

Dan:

1. sudo pip installeer fles
2. sudo pip installeer pyserial
3. sudo pip installeer RPIO

Dit is al die modules wat nodig is om die kode te laat loop.

Stap 9: Die opstel van die RoboClaw

Ek het die robotkode wat in 19200 baud met die RoboClaw in die standaardreeksmodus praat.

Om die RoboClaw hiervoor in te stel, doen:

1. Druk die "MODE" -knoppie op die RoboClaw
2. Druk die stelknoppie totdat die LED 5 (vyf) keer tussen die vertragings flikker
3. Druk die "LIPO" knoppie om op te slaan
4. Druk dan op die "SET" -knoppie totdat die LED 3 (drie) keer tussen die vertragings flikker
5. Druk die LIPO -knoppie om te stoor

Dit is dit vir die opstel van die motorbeheerder. Sien die pdf hierbo gekoppel vir meer inligting indien nodig.

Stap 10: Die installering van die Rover -program/lêers

Laai die rover.zip -lêer af en kopieer dit na u RPI in u pi -gebruikersgids.

As u Linux of 'n Mac gebruik, kan u 'scp' gebruik om dit te doen:

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

Vir Windows kan u pscp aflaai en gebruik en dan doen:

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

Sodra die zip -lêer na die RPI gekopieer is, meld u aan as die pi -gebruiker.

Begin nou:

pak rover.zip uit

Dit sal die lêers uitpak na 'n gids met die naam 'rover' en die volgende onder die gids hê:

• restrover.py (Die luislangkode vir die robot)
• staties (hou die beeldlêers vir die knoppies op die bedieningsbladsy in)
• sjablone (bevat die index.htlm -lêer, die beheerwebblad)

As u 'n webkamera gebruik, verander die reël naby die onderkant van die index.html -lêer in die sjabloonmap. Verander die URL in die IFRAME -reël sodat dit ooreenstem met die src -URL vir u videostroom.

Stap 11: Begin die Bot Up

Koppel die USB -krag aan die RPI.

As u die bot -kode wil begin, meld u aan as die pi -gebruiker en voer uit:

• cd rover
• sudo python restrover.py

As alles in orde was, moet u 'n skerm soortgelyk aan die prent in hierdie stap sien

As u foute of probleme sien, moet u dit regmaak voordat u verder gaan.

Sluit nou die GND (-) draad aan op die NEG (-) aansluiting op die RoboClaw motor se ingang.

Stap 12: Toegang tot die botbeheerbladsy

Nadat die python -script van die robot uitgevoer is, skakel die RoboClaw aan en navigeer dan na die IP van u RPI soos:

jou_rpi_ip

U moet sien dat die webbeheerbladsy verskyn soos in die beelde. Indien nie, gaan na u RPI -uitgangsterminal en kyk of daar foute is en stel dit reg.

Sodra u op die bladsy is, is u gereed om die bot te beheer.

Die robot sal begin in die "Med run" -instelling en teen die medium spoed.

Die bot kan beheer word via die knoppies op die bladsy of deur sleutels op die sleutelbord.

Die sleutels is:

• w - vorentoe
• z - agteruit/agteruit
• a - lang draai links
• s - lang regs draai
• q - kort draai links
• e - kort regs draai
• 1 - pan kamera oor
• 2 - pan kamera regs
• 3 - pan vol links
• 4 - pan vol regs
• / - huis/ middel kamera
• h - stop/stop robot

Daar is 'n halwe sekonde vertragingsbuffer tussen opdragte wat gestuur word. Ek het dit gedoen om ongewenste herhaalde opdragte uit te skakel. U kan dit natuurlik uit die kode verwyder (in index.html)

Die res van die kontroles en die beheer daarvan behoort vanselfsprekend te wees.

Stap 13: Die Python/Flask -kode

Hierdie bot gebruik Python en die Flask -webraamwerk. U kan meer hier oor Flask leer as u belangstel.

Die groot verskil van 'n Flask -app en 'n normale Python -script is @app.route klas/metode wat gebruik word om die URI -hantering te doen. Anders as dit, is dit meestal 'n normale Python.

#!/usr/bin/env python

# # Wifi/Webgedrewe Rover # # Geskryf deur Scott Beasley - 2015 # # Gebruik RPIO, pyserial en Flask # invoertyd invoer reeks van RPIO invoer PWM van fles invoerfles, render_template, versoek app = Flask (_name_, static_url_path = '') # Koppel aan die comm -poort om met die motorbeheerder van Roboclaw te praat: # Verander die baud -tempo hier as dit anders is as 19200 roboclaw = serial. Serial ('/dev/ttyAMA0', 19200) behalwe IOError: print ("Comm port not gevind ") sys.exit (0) # Spoed- en ritbeheerveranderlikes last_direction = -1 speed_offset = 84 turn_tm_offset = 0.166 run_time = 0.750 # Servo neutrale posisie (tuis) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # 'n Bietjie stilstaan om die tyd vas te stel. Slaap (3) # # URI -hanteerders - al die botbladsy -aksies word hier uitgevoer # # Stuur die bots -kontrolebladsy (tuisblad) @app.route ("/") def index (): return render_template ('index.html', name = None) @app.route ("/forward") def forward (): global last_direction, run_ti ek druk "Vorentoe" go_forward () last_direction = 0 # slaap 100ms + run_time time.sleep (0.100 + run_time) # As dit nie deurlopend is nie, stop dan na vertraging as run_time> 0: last_direction = -1 stop () gee "ok" @ terug 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) # As dit nie aaneenlopend is nie, stop dan na vertraging as 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 tweede keer.slaap (0.500 - turn_tm_offset) # stop halt () time.sleep (0.100) keer terug "ok" @app.route ("/regs") def regs (): global last_direction, turn_tm_offset print "Right" go_right () # slaap @1/2 tweede keer. slaap (0.500 - turn_tm_offset) last_direction = -1 # stop stop () time.sleep (0.100) keer "ok" terug @app.route ("/ltforward") def ltforward (): globale laaste_rigting, draai_t m_offset druk "Links vorentoe draai" go_left () # slaap @1/8 tweede keer. slaap (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) keer terug "ok" @app.route ("/rtforward") def rtforward (): global last_direction, 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 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) stuur "ok" @app.route ("/panlt") def panlf (): globale servo_pos druk "Panlt" servo_pos -= 100 as servo_pos 2500: servo_pos = 2500 servo.set_servo (18, servo_pos) # slaap 150 ms tyd. slaap (0.150) gee terug "ok" @app.route ("/huis") def home (): globale servo_pos druk "Home" servo_pos = 1250 servo.set_servo (18, servo_pos) # slaap 150ms time.sleep (0.150) terug "ok" @app.route ("/panfull_lt") def panfull_lt (): globale servo_pos druk "Pan vol l eft "servo_pos = 500 servo.set_servo (18, servo_pos) # slaap 150ms time.sleep (0.150) gee terug" ok " @app.route ("/panfull_rt ") def panfull_rt (): globale servo_pos druk" Pan vol regs "servo_pos = 2500 servo.set_servo (18, servo_pos) # slaap 150ms time.sleep (0.150) gee terug "ok" @app.route ("/speed_low") def speed_low (): global speed_offset, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0.001 # Werk die huidige rigting op om nuwe spoed te kry as last_direction == 0: go_forward () as last_direction == 1: go_backward () # slaap 150ms time.sleep (0.150) terugkeer "ok" @app.route ("/speed_mid") def speed_mid (): globale speed_offset, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Werk huidige rigting op om nuwe spoed te kry as last_direction == 0: go_forward () as last_direction == 1: go_backward () # slaap 150ms tyd. slaap (0.150) gee "ok" terug by app.route ("/speed_hi") def speed_hi (): globale speed_offset, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Werk huidige rigting op om nuwe spoed te kry as last_direction == 0: go_forward () as last_direction == 1: go_backward () # slaap 150ms time.sleep (0.150) gee terug "ok" @app.route ("/deurlopend) ") def continu (): global run_time print" Continuous run "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 () # slaap 100 ms time.sleep (0.100) keer "ok" terug # # Motoraandrywing funksies # def go_forward (): globale speed_offset as 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)) anders: 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)) anders: 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)) anders: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) def halt (): roboclaw.write (chr (0)) as _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

As u nie ontfoutingsinligting van Flask wil hê of benodig nie, stel ontfouting op 'onwaar' op die app.run -lyn.

as _naam_ == "_hoof_":

app.run (gasheer = '0.0.0.0', poort = 80, ontfouting = onwaar)

U kan ook die poort verander waarop die Flask http -bediener ook hier luister.

Stap 14: Gebruik ander hardeware

As u ander hardeware wil gebruik, soos 'n ander tipe SBC (enkelbordrekenaar), moet u min probleme ondervind om Python en Flask op ander borde te laat werk, soos die Beagle Bone, PCDuino, ens … U moet die kode verander om by die GPIO te pas. uitleg en gebruik die servo -ry -vermoëns van die nuwe bord.

Om 'n ander motorbestuurder te gebruik, hoef u net die funksies go_forward, go_backward, go_left, go_right en stop te verander om te doen wat die vervangende motorbestuurder ooit nodig het om die motor daardie spesifieke funksie te laat verrig.