Rover controllato dal web: 14 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Costruire e giocare con i robot è il mio principale piacere colpevole nella vita. Altri giocano a golf o a sciare, ma io costruisco robot (dato che non posso giocare a golf o sciare:-). Lo trovo rilassante e divertente! Per realizzare la maggior parte dei miei robot, utilizzo i kit telaio. L'uso dei kit mi aiuta a fare ciò che mi piace di più, il software e l'elettronica e crea anche uno chassis migliore per il mio io tutto pollice.

In questo Instructable, esamineremo ciò che serve per creare un rover controllato da Wifi/web semplice ma robusto. Il telaio utilizzato è l'Actobotics Gooseneck. L'ho scelto per le sue dimensioni, espandibilità e costo, ma puoi utilizzare qualsiasi altro chassis di tua scelta.

Per un progetto come questo, avremo bisogno di un buon computer a scheda singola solido e per questo bot ho scelto di utilizzare il Raspberry Pi (RPI) un computer basato su Linux. L'RPI (e Linux) ci offrono molte opzioni di codifica e Python verrà utilizzato per la codifica. Per l'interfaccia web utilizzo Flask, un framework web leggero per Python.

Per pilotare i motori, ho scelto un RoboClaw 2x5a. Consente una semplice comunicazione seriale per comandarlo e funziona bene con l'RPI e i motori del Gooseneck.

Infine, ha una webcam per il feedback video di tipo POV per guidarlo da remoto. Tratterò ogni argomento in modo più dettagliato in seguito.

Passaggio 1: hardware necessario

• Telaio Actobotics Gooesneck o un sostituto adatto a tua scelta
• Raspberry Pi a tua scelta (o clone): su questo bot viene utilizzato un modello RPI B, ma funzionerà qualsiasi con almeno due porte USB
• Piastra servo standard B x1
• Staffa per canale ad angolo singolo 90° x1
• Driver del motore RoboClaw 2x5a
• S3003 o servo di dimensioni standard simili
• Piccola breadboard o Mini breadboard
• Cavi di collegamento da femmina a femmina
• Ponticelli maschio-femmina
• Web cam (opzionale): utilizzo una Logitech C110 ed ecco un elenco di camme supportate per l'RPI
• Fonte di alimentazione 5v-6v per servoalimentazione
• Batteria 7.2v-11.1v per l'alimentazione del motore di azionamento
• Power bank USB 5v 2600mah (o superiore) per RPI
• Adattatore Wi-Fi USB

Sul mio robot, uso ruote da 4 per renderlo un po' più All-Terrain-Indoor. Per questa opzione avrai bisogno di:

• Ruota per impieghi gravosi da 4" x2
• Mozzo per vite di fissaggio con foro da 4 mm (0,770 pollici) x2

Passaggio 2: assemblaggio del telaio

Per prima cosa assemblare il telaio seguendo le istruzioni incluse con il telaio o il video. Dopo aver terminato dovresti avere qualcosa come l'immagine. NOTA: quando si assembla la parte del collo, lasciare la staffa di montaggio staccata.

Sul mio robot, ho scelto di sostituire le ruote fornite con il telaio per ruote per impieghi gravosi da 4 . Questo è opzionale e non è necessario a meno che tu non voglia fare lo stesso.

Passaggio 3: montaggio dell'elettronica

Il collo d'oca ha molto spazio e opzioni per montare la tua elettronica. Ti do queste immagini come linea guida, ma puoi scegliere come desideri disporre il tutto. È possibile utilizzare distanziatori, nastro biadesivo, velcro o nastro servo per montare la scheda e le batterie.

Passaggio 4: aggiunta della webcam

Prendi la staffa a 90 gradi, il mozzo del servo leggero e quattro (4) delle viti.3125 per questo passaggio:

• Prendi il mozzo del servo e posizionalo su un lato della staffa e fissali insieme con le viti da.2125 "come nella foto
• Quindi monta il servo nella staffa del servo
• Attacca la staffa a 90 gradi con la squadretta del servo alla colonna vertebrale dei servi e usa la vite della squadretta fornita con il servo per collegarli insieme
• Ora monta il Servo nella staffa sulla parte superiore del collo d'oca con le viti rimanenti
• Montare la telecamera con fascette o nastro biadesivo sulla staffa a 90 gradi

Usa le immagini per le guide, se necessario.

Passaggio 5: cablare tutto

Il cablaggio è abbastanza stretto per questo robot.

I motori:

Saldare i cavi su entrambi i motori se non lo hai già fatto

Con il robot davanti (l'estremità con il collo d'oca) rivolto lontano da te:

• Collegare i fili del motore sul motore sinistro al canale M1A e M1B
• Collegare i fili del motore sul motore destro al canale M2A e M2B

Collegamenti di terra (GND):

• Collega un pin di terra sul RoboClaw alla scheda del ponticello di terra. La linea di messa a terra sul RoboClaw è la più vicina al centro (vedi foto)
• Collegare il PIN 6 dell'RPI alla scheda jumper. Vedere l'immagine dell'intestazione RPI per l'assegnazione dei pin.
• Collegare il GND dal pacco batteria del servo a uno dei pin sulla scheda del ponticello.
• Eseguire un ponticello dalla scheda del ponticello al cavo GND dei servi.

RPI a RoboClaw:

Collega il pin RPI GPIO14 TXD al pin RoboClaw S1

Potenza:

• Collegare il cavo POS dalla batteria del servo al cavo POS del servo
• Collega il cavo POS dalla batteria del motore al POS (+) del terminale di ingresso dell'alimentazione del motore RoboClaw. Per ora lasceremo scollegato il terminale GND.

Passaggio 6: impostazione dell'RPI

Presumo che l'utente qui sappia qualcosa su Linux e l'RPI. Non spiego come configurare o connettersi a uno. Se hai bisogno di aiuto, usa le pagine qui sotto.

Per ottenere la configurazione dell'RPI, dai un'occhiata alle seguenti pagine:

• Configurazione di base RPI
• Guida rapida RPI
• Gilda di installazione di NOOBS

Per le pagine jump-off generali, la pagina principale RPI e le pagine eLinux sono ottimi punti di partenza.

Vedere questo collegamento per la configurazione Wi-Fi generale dell'RPI.

Se hai intenzione di utilizzare una sorta di fotocamera o web cam sul bot, dai un'occhiata a queste pagine per ottenere i file di base necessari.

• Configurazione della telecamera RPI
• Configurazione della camma eLinix RPI

Streaming video:

Ci sono alcuni modi per far funzionare lo streaming video su un RPI, ma il metodo che preferisco è usare Motion.

Per installarlo sul tuo RPI, esegui questo: sudo apt-get install motion

Questo instrucatable va oltre la configurazione anche per lo streaming.

Passaggio 7: configurazione della porta seriale RPI

Dovremo disabilitare la modalità console Linux per utilizzare RX e TX poiché vogliamo parlare con il controller del motore RoboClaw da questa porta. Per fare ciò, puoi utilizzare questo metodo o questo strumento. La scelta è tua sul metodo poiché entrambi fanno la stessa cosa alla fine.

Passaggio 8: installazione dei moduli Python

Avrai bisogno di python installato sull'RPI e del programma di installazione del pacchetto python pip.

Per installare pip fai:

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

Quindi:

1. sudo pip install flask
2. sudo pip install pyserial
3. sudo pip install RPIO

Questi saranno tutti i moduli necessari per l'esecuzione del codice.

Passaggio 9: configurazione del RoboClaw

Ho il codice del robot che parla con RoboClaw in modalità seriale standard a 19200 baud.

Per impostare RoboClaw per questo, fai:

1. Premi il pulsante "MODE" sul RoboClaw
2. Premi il pulsante set fino a quando il LED non lampeggia 5 (cinque) volte tra i ritardi
3. Premi il pulsante "LIPO" per memorizzare
4. Quindi premi il pulsante "SET" fino a quando il LED non lampeggia 3 (tre) volte tra i ritardi
5. Premi il pulsante LIPO per memorizzare

Questo è tutto per impostare il controller del motore. Se necessario, vedere il pdf collegato sopra per ulteriori informazioni.

Passaggio 10: installazione del programma/file Rover

Scarica e copia il file rover.zip nel tuo RPI nella directory utente pi.

Se stai usando Linux o un Mac, puoi usare "scp" per farlo:

scp ~/posizione/del/file/rover.zip pi@tuo_rpi_ip:/~

Per Windows, puoi scaricare e utilizzare pscp e quindi eseguire:

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

Una volta che il file zip è stato copiato sull'RPI, accedi come utente pi.

Ora esegui:

decomprimere rover.zip

Questo decomprimerà i file in una cartella denominata "rover" e avrà quanto segue in quella cartella:

• restrover.py (Il codice Python per il robot)
• statico (contiene i file di immagine per i pulsanti nella pagina di controllo)
• templates (contiene il file index.htlm, la pagina web di controllo)

Se stai utilizzando una web cam, modifica la riga nella parte inferiore del file index.html nella cartella del modello. Modifica l'URL nella riga IFRAME in modo che corrisponda all'URL src per il tuo flusso video.

Passaggio 11: avvio del bot

Collegare l'alimentazione USB all'RPI.

Per avviare il codice del bot, accedi come utente pi ed esegui:

• cd rover
• sudo python restrover.py

Se tutto è andato bene, dovresti vedere una schermata simile all'immagine in questo passaggio

Se riscontri errori o problemi, dovrai risolverli prima di andare avanti.

Ora, collega il filo GND (-) al terminale NEG (-) sull'ingresso di alimentazione del motore RoboClaw.

Passaggio 12: accesso alla pagina di controllo del bot

Dopo che lo script python del robot è in esecuzione, accendi RoboClaw e poi vai all'ip del tuo RPI come:

your_rpi_ip

Dovresti vedere la pagina di controllo Web apparire come nelle immagini. In caso contrario, controlla il terminale di output RPI e cerca eventuali errori e correggili.

Una volta sulla pagina, sei pronto per controllare il bot.

Il robot si avvierà nell'impostazione "Med run" e alla velocità media.

Il bot può essere controllato tramite i pulsanti sulla pagina o tramite i tasti sulla tastiera.

Le chiavi sono:

• w - avanti
• z - indietro/indietro
• a - lunga svolta a sinistra
• s - lunga svolta a destra
• q - breve svolta a sinistra
• e - breve svolta a destra
• 1 - panoramica della telecamera a sinistra
• 2 - panoramica della telecamera a destra
• 3 - pan tutto a sinistra
• 4 - pan tutto a destra
• / - telecamera domestica/centrale
• h - ferma/ferma robot

C'è un buffer di ritardo di mezzo secondo tra i comandi inviati. L'ho fatto per eliminare comandi ripetuti indesiderati. Ovviamente puoi rimuoverlo dal codice se lo desideri (in index.html)

Il resto dei controlli e controllarlo dovrebbe essere autoesplicativo.

Passaggio 13: il codice Python/Flask

Questo bot usa Python e il framework web Flask. Puoi saperne di più su Flask qui se sei interessato.

La grande differenza tra un'app Flask e un normale script Python è @app.route class/method utilizzata per gestire l'URI. A parte questo, per la maggior parte è praticamente normale Python.

#!/usr/bin/env python

# # Rover guidato da Wifi/Web # # Scritto da Scott Beasley - 2015 # # Utilizza RPIO, pyserial e Flask # import time import serial from RPIO import PWM from flask import Flask, render_template, request app = Flask (_name_, static_url_path = '') # Collegati alla porta di comunicazione per parlare con il controller del motore Roboclaw prova: # Modifica qui il baud rate se diverso da 19200 roboclaw = serial. Serial ('/dev/ttyAMA0', 19200) tranne IOError: print ("Comm port not trovato") sys.exit (0) # Variabili di controllo velocità e azionamento last_direction = -1 speed_offset = 84 turn_tm_offset = 0,166 run_time = 0,750 # Servo posizione neutra (home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Una piccola pausa per stabilizzare il tempo time.sleep (3) # # Gestori URI - tutte le azioni della pagina bot vengono eseguite qui # # Invia la pagina di controllo dei bot (home page) @app.route ("/") def index(): return render_template ('index.html', name = None) @app.route ("/forward") def forward(): global last_direction, run_ti me print "Avanti" go_forward() last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Se non è continuo, ferma dopo un ritardo se run_time > 0: last_direction = -1 halt () return "ok" @ app.route ("/backward") def indietro (): global last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Se non è continuo, ferma dopo il ritardo 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 secondo time.sleep (0.500 - turn_tm_offset) # stop halt () time.sleep (0.100) return "ok" @app.route ("/right") def right (): globale last_direction, turn_tm_offset print "Right" go_right () # sleep @1/2 secondo time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/ltforward") def ltforward (): global last_direction, turn_t m_offset print "Svolta in avanti a sinistra" go_left () # sleep @1/8 secondo time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/rtforward") def rtforward (): globale last_direction, turn_tm_offset print "Right forward turn" go_right () # sleep @1/8 di secondo tempo.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 # Aggiorna la direzione corrente per ottenere una nuova velocità 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 # Aggiorna la direzione corrente per ottenere una nuova velocità 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 globale, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Aggiorna la direzione corrente per ottenere una nuova velocità if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/continuous ") def continue(): 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 () # sleep 100ms time.sleep (0.100) return "ok" # # Funzioni di azionamento del motore # def go_forward (): speed_offset globale 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 globale 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(): speed_offset globale 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 halt(): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Se non vuoi o hai bisogno di informazioni di debug da Flask, imposta debug su 'false' nella riga app.run.

if _name_ == "_main_":

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

Puoi anche cambiare la porta su cui il server http Flask è in ascolto qui.

Passaggio 14: utilizzo di altro hardware

Se vuoi usare altro hardware, come un altro tipo di SBC (Single Board Computer) dovresti avere piccoli problemi a far funzionare Python e Flask su altre schede come Beagle Bone, PCDuino ecc… Dovrai cambiare il codice in modo che corrisponda al GPIO layout e utilizzare le capacità di pilotaggio servo della nuova scheda.

Per utilizzare un driver del motore di un altro tipo, è sufficiente modificare le funzioni go_forward, go_backward, go_left, go_right e halt per fare ciò di cui ha bisogno il driver del motore sostitutivo per far sì che il motore esegua quella particolare funzione.