Rover contrôlé par le Web : 14 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Construire et jouer avec des robots est mon principal plaisir coupable dans la vie. D'autres jouent au golf ou au ski, mais je construis des robots (puisque je ne sais pas jouer au golf ou au ski:-). Je trouve ça relaxant et amusant ! Pour faire la plupart de mes bots, j'utilise des kits de châssis. L'utilisation de kits m'aide à faire ce que j'aime le plus faire, le logiciel et l'électronique, et permet également d'obtenir un meilleur châssis pour moi-même.

Dans ce Instructable, nous examinerons ce qu'il faut pour faire un rover contrôlé Wifi/web simple mais robuste. Le châssis utilisé est l'Actobotics Gooseneck. Je l'ai choisi pour sa taille, son évolutivité et son coût, mais vous pouvez utiliser n'importe quel autre châssis de votre choix.

Pour un projet comme celui-ci, nous aurons besoin d'un bon ordinateur monocarte solide et pour ce bot, j'ai choisi d'utiliser le Raspberry Pi (RPI), un ordinateur basé sur Linux. Le RPI (et Linux) nous donne beaucoup d'options de codage et Python sera utilisé pour le côté codage. Pour l'interface Web, j'utilise Flask, un framework Web léger pour Python.

Pour piloter les moteurs, j'ai choisi un RoboClaw 2x5a. Il permet une communication série simple pour le commander et fonctionne bien avec le RPI et les moteurs du col de cygne.

Enfin, il dispose d'une webcam pour les retours vidéo de type POV pour le piloter à distance. Je couvrirai chaque sujet plus en détail plus tard.

Étape 1: Matériel nécessaire

• Châssis Actobotics Gooesneck ou un remplacement approprié de votre choix
• Raspberry Pi de votre choix (ou clone) - Un modèle RPI B est utilisé sur ce bot, mais tout avec au moins deux ports USB fonctionnera
• Plaque Servo Standard B x1
• Support de canal à angle unique à 90° x1
• Pilote de moteur RoboClaw 2x5a
• Servo S3003 ou similaire de taille standard
• Petite planche à pain ou Mini planche à pain
• Cavalier femelle à femelle
• Cavaliers mâles à femelles
• Web cam (facultatif) - J'utilise un Logitech C110, et voici une liste des cams supportées pour le RPI
• Source d'alimentation 5v-6v pour la puissance d'asservissement
• Batterie 7.2v-11.1v pour l'alimentation du moteur d'entraînement
• Banque d'alimentation USB 5v 2600mah (ou supérieur) pour le RPI
• Adaptateur Wi-Fi USB

Sur mon bot, j'utilise des roues de 4 pour le rendre un peu plus All-Terrain-Indoor. Pour cette option il vous faudra:

• Roue robuste de 4" x2
• Moyeu de vis de réglage d'alésage de 4 mm (0,770 pouce) x2

Étape 2: Assemblage du châssis

Assemblez d'abord le châssis en suivant les instructions fournies avec le châssis ou la vidéo. Après avoir terminé, vous devriez avoir quelque chose comme l'image. REMARQUE: lors de l'assemblage de la partie cou, laissez simplement le support de montage retiré.

Sur mon bot, j'ai choisi de remplacer les roues fournies avec le châssis par des roues robustes de 4 . Ceci est facultatif et n'est pas nécessaire à moins que vous ne vouliez faire de même.

Étape 3: Montage de l'électronique

Le col de cygne a beaucoup d'espace et d'options pour le montage de vos appareils électroniques. Je vous donne ces images à titre indicatif, mais vous pouvez choisir comment vous souhaitez les présenter. Vous pouvez utiliser des supports, du ruban adhésif double face, du velcro ou du ruban servo pour monter la carte et les batteries.

Étape 4: Ajout de la webcam

Prenez le support à 90 degrés, le moyeu servo léger et quatre (4) des vis.3125 pour cette étape:

• Prenez le moyeu du servo et placez-le sur un côté du support et fixez-les avec les vis.2125" comme sur la photo
• Montez ensuite le servo dans le support de servo
• Fixez le support à 90 degrés avec le palonnier du servo à la colonne vertébrale du servo et utilisez la vis du palonnier fournie avec le servo pour les connecter ensemble
• Montez maintenant le Servo en support sur le dessus du col de cygne avec les vis restantes
• Montez la caméra avec des attaches ou du ruban adhésif double face sur le support à 90 degrés

Utilisez les images pour les guides si nécessaire.

Étape 5: Câblage de tout

Le câblage est assez droit vers l'avant pour ce robot.

Les moteurs:

Souder les fils sur les deux moteurs si vous ne l'avez pas déjà fait

Avec l'avant du robot (l'extrémité avec le col de cygne) tourné vers vous:

• Connectez les fils du moteur du moteur gauche aux canaux M1A et M1B
• Connectez les fils du moteur sur le moteur droit au canal M2A et M2B

Connexions à la terre (GND):

• Connectez une broche de masse du RoboClaw à la carte de cavalier de masse. La ligne de broche de terre sur le RoboClaw est la plus proche du centre (voir photo)
• Connectez la broche 6 du RPI à la carte de cavalier. Voir la photo d'en-tête RPI pour les affectations de broches.
• Connectez le GND de la batterie d'asservissement à l'une des broches de la carte de cavalier.
• Faites passer un cavalier entre la carte de cavalier et le fil GND des servos.

RPI vers RoboClaw:

Connectez la broche RPI GPIO14 TXD à la broche RoboClaw S1

Puissance:

• Connectez le fil POS de la batterie du servo au fil POS des servos
• Connectez le fil POS de la batterie du moteur au POS (+) de la borne d'entrée d'alimentation du moteur RoboClaw. Nous allons laisser la borne GND déconnectée pour le moment.

Étape 6: Configuration du RPI

Je suppose que l'utilisateur ici connaît Linux et le RPI. Je ne couvre pas comment configurer ou se connecter à un. Si vous avez besoin d'aide pour cela, utilisez les pages ci-dessous.

Pour obtenir votre configuration RPI, consultez les pages suivantes:

• Configuration de base RPI
• RPI Guide de démarrage rapide
• Guilde d'installation de NOOBS

Pour les pages de démarrage générales, la page principale RPI et les pages eLinux sont d'excellents points de départ.

Voir ce lien pour la configuration Wifi générale de RPI.

Si vous envisagez d'utiliser une sorte de caméra ou de webcam sur le bot, consultez ces pages pour obtenir les fichiers de base nécessaires.

• Configuration de la caméra RPI
• Configuration de la caméra eLinix RPI

Vidéo en streaming:

Il existe plusieurs façons de faire fonctionner le streaming vidéo sur un RPI, mais la méthode que je préfère consiste à utiliser Motion.

Pour l'installer sur votre RPI, exécutez ceci: sudo apt-get install motion

Cette instructable va au-dessus de la configuration pour la diffusion en continu également.

Étape 7: Configuration du port série RPI

Nous devrons désactiver le mode console Linux pour utiliser le RX et le TX car nous voulons parler au contrôleur de moteur RoboClaw à partir de ce port. Pour ce faire, vous pouvez utiliser cette méthode ou cet outil. Le choix vous appartient sur la méthode car ils font tous les deux la même chose à la fin.

Étape 8: Installation des modules Python

Vous aurez besoin de python installé sur le RPI ainsi que du pip d'installation du package python.

Pour installer pip, procédez comme suit:

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

Puis:

1. flacon d'installation sudo pip
2. sudo pip installer pyserial
3. sudo pip installer RPIO

Ce seront tous les modules nécessaires à l'exécution du code.

Étape 9: Configuration du RoboClaw

J'ai le code du robot qui parle au RoboClaw en mode série standard à 19 200 bauds.

Pour configurer le RoboClaw pour cela, procédez comme suit:

1. Appuyez sur le bouton "MODE" sur le RoboClaw
2. Appuyez sur le bouton de réglage jusqu'à ce que la LED clignote 5 (cinq) fois entre les délais
3. Appuyez sur le bouton "LIPO" pour stocker
4. Appuyez ensuite sur le bouton "SET" jusqu'à ce que la LED clignote 3 (trois) fois entre les délais
5. Appuyez sur le bouton LIPO pour stocker

Voilà pour la configuration du contrôleur de moteur. Voir le pdf lié ci-dessus pour plus d'informations si nécessaire.

Étape 10: Installation du programme/des fichiers Rover

Téléchargez et copiez le fichier rover.zip sur votre RPI dans votre répertoire utilisateur pi.

Si vous utilisez Linux ou un Mac, vous pouvez utiliser 'scp' pour le faire:

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

Pour Windows, vous pouvez télécharger et utiliser pscp puis faire:

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

Une fois le fichier zip copié dans le RPI, connectez-vous en tant qu'utilisateur pi.

Exécutez maintenant:

décompresser rover.zip

Cela décompressera les fichiers dans un dossier nommé « rover » et aura les éléments suivants sous ce dossier:

• restrover.py (Le code python pour le robot)
• statique (contient les fichiers image des boutons de la page de contrôle)
• templates (contient le fichier index.html, la page Web de contrôle)

Si vous utilisez une webcam, modifiez la ligne située en bas du fichier index.html dans le dossier des modèles. Modifiez l'URL dans la ligne IFRAME pour qu'elle corresponde à l'URL src de votre flux vidéo.

Étape 11: Démarrer le Bot

Connectez l'alimentation USB au RPI.

Pour démarrer le code du bot, connectez-vous en tant qu'utilisateur pi et exécutez:

• cd rover
• sudo python restrover.py

Si tout allait bien, vous devriez voir un écran similaire à l'image de cette étape

Si vous voyez des erreurs ou des problèmes, vous devrez les corriger avant de continuer.

Maintenant, connectez le fil GND (-) à la borne NEG (-) sur l'entrée d'alimentation du moteur RoboClaw.

Étape 12: Accéder à la page de contrôle des robots

Une fois le script python du robot en cours d'exécution, allumez le RoboClaw, puis accédez à l'adresse IP de votre RPI comme:

votre_rpi_ip

Vous devriez voir la page de contrôle Web apparaître comme dans les images. Sinon, vérifiez votre terminal de sortie RPI et recherchez les erreurs et corrigez-les.

Une fois sur la page, vous êtes prêt à contrôler le bot.

Le robot démarrera dans le réglage "Med run" et à la vitesse Medium.

Le bot peut être contrôlé via les boutons de la page ou par les touches du clavier.

Les clés sont:

• w - en avant
• z - marche arrière/arrière
• a - grand virage à gauche
• s - long virage à droite
• q - petit virage à gauche
• e - virage court à droite
• 1 - caméra panoramique à gauche
• 2 - caméra panoramique à droite
• 3 - panoramique complètement à gauche
• 4 - panoramique complètement à droite
• / - home/caméra centrale
• h - arrêter/arrêter le robot

Il y a un tampon de retard d'une demi-seconde entre les commandes envoyées. J'ai fait cela pour éliminer les commandes répétées indésirables. Vous pouvez bien sûr supprimer cela du code si vous le souhaitez (dans index.html)

Le reste des commandes et leur contrôle devraient être explicites.

Étape 13: Le code Python/Flask

Ce bot utilise Python et le framework Web Flask. Vous pouvez en savoir plus sur Flask ici si vous êtes intéressé.

La grande différence entre une application Flask et un script Python normal est la classe/méthode @app.route utilisée pour gérer l'URI. A part ça, c'est à peu près Python normal pour la plupart.

#!/usr/bin/env python

# # Rover piloté par Wifi/Web # # Écrit par Scott Beasley - 2015 # # Utilise RPIO, pyserial et Flask # import time import serial from RPIO import PWM from flask import Flask, render_template, request app = Flask (_name_, static_url_path = '') # Connectez-vous au port de communication pour parler au contrôleur de moteur Roboclaw essayez: # Modifiez le débit en bauds ici s'il est différent de 19200 roboclaw = serial. Serial ('/dev/ttyAMA0', 19200) sauf IOError: print ("Comm port not found") sys.exit (0) # Variables de contrôle de vitesse et d'entraînement last_direction = -1 speed_offset = 84 turn_tm_offset = 0.166 run_time = 0.750 # Servo position neutre (home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Une petite pause pour régler le temps d'attente time.sleep (3) # # Gestionnaires d'URI - toutes les actions de la page de bot sont effectuées ici # # Envoyez la page de contrôle des bots (page d'accueil) @app.route ("/") def index (): return render_template ('index.html', name = None) @app.route ("/forward") def forward (): global last_direction, run_ti me print "Forward" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Si ce n'est pas continu, alors s'arrêter après un délai si run_time > 0: last_direction = -1 halt () return "ok" @ app.route ("/backward") def back (): global last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Si non continu, arrêt après délai 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 seconde 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 () # sleep @1/2 seconde 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 "virage avant gauche" go_left () # sleep @1/8 seconde time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/rtforward") def rtforward (): global last_direction, turn_tm_offset print " Right forward turn " go_right () # sleep @1/8 seconde 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 # Mettre à jour la direction actuelle pour obtenir une nouvelle vitesse 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 # Mettre à jour la direction actuelle pour obtenir une nouvelle vitesse 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 (): global speed_offset, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Mettre à jour la direction actuelle pour obtenir une nouvelle vitesse if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/continuous ") def Continuous (): 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 "Court run" run_time = 0.300 halt () # sleep 100ms time.sleep (0.100) return "ok" # # Motor drive functions # def go_forward (): global speed_offset 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 halt (): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Si vous ne souhaitez pas ou n'avez pas besoin d'informations de débogage de Flask, définissez debug sur « false » sur la ligne app.run.

if _name_ == "_main_":

app.run (hôte = '0.0.0.0', port = 80, débogage = False)

Vous pouvez également modifier le port sur lequel le serveur http Flask écoute également ici.

Étape 14: Utilisation d'un autre matériel

Si vous souhaitez utiliser un autre matériel, comme un autre type de SBC (Single Board Computer), vous devriez avoir peu de problèmes pour faire fonctionner Python et Flask sur d'autres cartes comme le Beagle Bone, PCDuino etc… Vous devrez changer le code pour qu'il corresponde au GPIO disposition et utiliser les capacités de servocommande de la nouvelle carte.

Pour utiliser un autre type de pilote de moteur, il vous suffit de modifier les fonctions go_forward, go_backward, go_left, go_right et halt pour faire tout ce dont le pilote de moteur de remplacement a besoin pour que le moteur remplisse cette fonction particulière.