Robot Car avec Raspberry Pi

Robot Car mit Raspberry Pi - AZ-Delivery

0 commentaire

Dans les blogs précédents sur la Robot Car, nous avons utilisé les micro-contrôleurs robustes compatibles Uno et Nano. Les Raspians vont maintenant s'imposer. Des contrôleurs de moteur basés sur le circuit intégré L293D et des kits de voitures robotisées pour le Raspberry Pi ont vu le jour peu après sa sortie en 2012. Avec les Pi Wars annuelles, il y a même un concours pour les modèles les plus polyvalents ; les tâches ont été très difficiles à chaque fois jusqu'à présent.

Dans ce blog, je veux utiliser l'un des avantages du Raspi et connecter un clavier sans fil au port USB. De plus, j'utilise un des rares Raspberry Pi 3A+, parfaitement adapté à nos besoins. En gros, le code ci-dessous fonctionne pour n'importe quel modèle de Raspi. Comme contrôleur de moteur j'utilise le MotoZero de ThePiHut. Comme son nom l'indique, il s'agit d'un HAT (Hardware Attached on Top) au format Pi Zero. Mais le connecteur J6 (mieux connu sous le nom de connecteur GPIO) est inchangé depuis des années pour tous les modèles.

Indispensable pour notre installation est un convertisseur DC-DC ; j'utilise le LM2596S Step-down DC-DC Buck Converter avec affichage digital à 3 chiffres, où les tensions sont affichées directement. Le passage de la tension d'entrée à la tension de sortie se fait par le petit bouton à droite de l'affichage à 3 chiffres. Comme l'alimentation se fait via la broche 5V (broche 2 ou 4), la tension d'entrée pour le Raspi doit être précisément de 5.0 à 5.1V. Les pics de tension peuvent détruire le Raspberry Pi. Cela ne m'est jamais arrivé. Mais même un redémarrage non planifié est assez ennuyeux, car le processus de démarrage prend environ une minute.

Matériel Nécessaire

Numéro	Composant
1	Raspberry Pi 3A+
	ou Raspberry Pi 3B / 3B+ ou Raspberry Pi Zero / WH Note : A la fin, nous voulons aussi utiliser le WLAN.
1	Contrôleur de moteur Moto Zero
1	LM2596S Convertisseur abaisseur DC-DC Buck avec affichage numérique à 3 chiffres
1	Clavier sans fil
1	Kit Robot Car avec deux moteurs/roues
	Compartiment de la batterie, câble de démarrage, petit matériel

J'ai vissé le convertisseur DC-DC dans la zone avant sous le châssis, le logement pour le Raspi et le compartiment de la batterie que j'ai fixé avec du velcro ou du ruban adhésif double face (moquette) comme auparavant.

Image: Robot Car vu d'en haut avec Raspberry Pi 3A+ et Pack batterie (2 batteries LiPo)

Photo du bas: 2 moteurs et convertisseur DC-DC

Quelques mots sur le Raspberry Pi 3A+ et le MotoZero : Le 3A+ est la version réduite du 3B+ avec un processeur quadricœur, 512 Mo de RAM, WLAN/Bluetooth et un port USB-A. Le 3A+ est la version réduite du 3B+. Je peux me passer d'un port LAN et d'une autre prise USB et bénéficier en contrepartie d'une consommation électrique plus faible. Avec le Pi Zero avec le simple processeur m'a gêné surtout que j'ai toujours besoin d'adaptateurs pour le câble HDMI et USB.

Le MotoZero est un simple contrôleur de moteur avec deux ICs du type L293D. Il est ainsi possible de contrôler jusqu'à quatre moteurs. L'avantage d'une HAT est que vous pouvez économiser beaucoup de connexions de câbles en la branchant sur l'en-tête J6. Le MotoZero est livré en kit et doit être soudé. Il existe ces instructions pour le faire. Conseil : au lieu de l'embase GPIO à 40 broches fournie, utilisez ce que l'on appelle une embase à empiler, dont les broches dépassent considérablement. Les contrôleurs de moteur n'utilisent pas tous les GPIO, vous pouvez donc utiliser certaines broches pour des capteurs ou d'autres extensions. Pour des raisons de construction, j'ai utilisé les connecteurs Motor 3 et 4. Et comme je l'ai découvert lors d'expériences, la tension de référence pour la modulation de largeur d'impulsion (PWM), c'est-à-dire la commande du moteur, est appliquée à la broche de validation du L293D.

Brochage

Moteur	1	2	3	4
Broche de l'activateur	5	17	12	25
Borne Positive ( + )	24	6	23	13
Négatif ( - ) Terminal	27	22	16	18

Software

Comme dans les précédents articles du blog sur le Raspberry Pi et Python, je m'extasie cette fois-ci sur le module de programme gpiozero de Ben Nuttall et al, qui est pour moi un excellent exemple de programmation orientée objet. Bien entendu, toutes les fonctions de commande des moteurs, mais aussi d'évaluation des capteurs, sont implémentées.

Comme nous utilisons les mêmes moteurs qu'auparavant, j'ai décidé d'utiliser à nouveau le système avec les cinq pas de vitesse par direction. Pour rappel : si la tension est trop faible, les moteurs ne font que vrombir, mais ne démarrent pas. Et selon l'alimentation en tension, la tension doit également être régulée vers le haut. Par conséquent, la liste speedLevel avec les 11 éléments peut être différente pour vous. Avec gpiozero les valeurs doivent se trouver entre -1 et +1 ; donc la division par 1000 a lieu avec l'attribution des valeurs. Par ailleurs je reçois de cette manière la possibilité d'équiper les télécommandes développées par moi-même avec HC-12 et nRF24L01.

Script Python

#! /usr/bin/python3
# Code for driving a robot car with MotoZero
# Motors attached to M3 and M4
# For motor control, use keybord w,a,s,y or arrow keys
# By Bernd54Albrecht for AZ-Delivery

from gpiozero import Robot, Motor, OutputDevice, LED
from signal import pause
import _thread
import sys
import termios
import tty

robot = Robot(left=(16,23), right=(13,18))
motor1_enable = OutputDevice(12, initial_value=1)
motor2_enable = OutputDevice(25, initial_value=1)

led = LED(4)
led.on()
code = 505
inkey_buffer = 1

def inkey():
fd=sys.stdin.fileno()
remember_attributes=termios.tcgetattr(fd)
tty.setraw(sys.stdin.fileno())
character=sys.stdin.read(inkey_buffer)
termios.tcsetattr(fd,termios.TCSADRAIN, remember_attributes)
return character

def readkey():
k1 = inkey()
if ord(k1) != 0x1b:
return k1
k2 = inkey()
if ord(k2) != 0x5b:
return k1
k3 = inkey()
return chr(0x10 + ord(k3) - 65) # 16=Up, 17=Down, 18=Right, 19=Left arrows

def getCode():
global code
key = readkey()
print("key = ",key,"ord(key)",ord(key))
if (key=='w' or ord(key) == 16) and code<1000:
code = code + 100
elif (key=='y' or ord(key) == 17) and code>100:
code = code-100
elif (key=='s' or ord(key) == 18) and code%100<10:
code = code+1
elif (key=='a' or ord(key) == 19) and code%100>0:
code = code-1
elif key == ' ':
code = 505
elif ord(key) == 3:
code=505
led.off()
exit()

print(code)
return

def motor(y,x):
print("y = ",y, " x = ", x)
speedLevel = [-600,-500,-400,-320,-250,0,250,320,400,500,600]
speed = speedLevel[y]

if x==10:
left = min(speed+250,600)
right = max(speed-250,-600)

elif x==9:
left = min(speed+200,600)
right = max(speed-200,-600)

elif x==8:
left = min(speed+150,600)
right = max(speed-150,-600)

elif x==7:
left = min(speed+100,600)
right = max(speed-100,-600)

elif x==6:
left = min(speed+50,600)
right = max(speed-50,-600)

elif x==4:
right = min(speed+50,600)
left = max(speed-50,-600)

elif x==3:
right = min(speed+100,600)
left = max(speed-100,-600)

elif x==2:
right = min(speed+150,600)
left = max(speed-150,-600)

elif x==1:
right = min(speed+200,600)
left = max(speed-200,-600)

elif x==0:
right = min(speed+250,600)
left = max(speed-250,-600)

else:
left = speed
right = speed

robot.value = (left/1000, right/1000)

while True:
getCode()
y = int(code/100)
x = code - 100*y
_thread.start_new_thread(motor,(y,x))

Avec ce programme, j'utilise un module de programme qui me permet d'interroger une seule touche, même sans touche de retour. Cependant, ce module nécessite d'être lancé dans le terminal. Sinon, vous obtenez le message d'erreur suivant :

Image: Message d'erreur, si le programme n'est pas lancé dans le terminal

Si vous ne voulez pas cela, vous pouvez vous passer du module et travailler avec la commande d'entrée. Ensuite, cependant, chaque entrée doit être complétée par la touche retour.

Dans ma configuration, le programme Python est lancé dans le terminal de toute façon, parce que j'ai écrit le démarrage du programme dans le fichier autostart. Ainsi, je peux démarrer le Raspi sans moniteur et avoir mon Robot Car prêt à fonctionner après le démarrage. Il existe plusieurs méthodes de démarrage automatique, et pour ne rien arranger, elles ont changé au cours des dernières années. J'utilise la méthode qui est officiellement appelée "méthode système". Pour ce faire, ouvrez le fichier ci-dessus avec :

Sudo Nano / etc / xdg / lxsession / lxde PI / autostart

Parmi les lignes suivantes, vous trouverez déjà les trois premières dans le fichier autostart :

Lxde panel - section lxde Pi
Pcmanfm - Bureau - profil lxde Pi
Xscreensaver - pas d'éclaboussure
Terminal lxe - python3 / Path / USScript.py

Avec la quatrième ligne, je lance le terminal et y exécute notre programme Python3. Il est important que le programme soit spécifié avec le chemin complet, dans mon cas

Terminal lxe - python3 / home / PI / robot car / robot car motozero3 4U Code 505.py

Pour indiquer que le démarrage du système et du programme est terminé, j'ai connecté une LED à la broche 4. Ainsi, lorsque la lumière s'allume, la petite voiture robot est prête à partir et attend les commandes clavier w, a, s, f, les touches fléchées ou la barre d'espace pour s'arrêter rapidement. Avec Ctrl+C, le programme est terminé.

Si vous ne disposez pas d'un clavier sans fil, vous pouvez bien sûr aussi lancer le programme dans un programme terminal sur le PC, par exemple Putty.

Image : Configuration et démarrage de Putty

Après s'être connecté, passez dans le bon répertoire, dans mon cas

CD roboka

et lancez le programme Python avec

Python 3

Cependant, une nouvelle instance du terminal et du programme Python est lancée. Ainsi, si votre RobotCar a des secousses pendant la conduite, le programme ouvert avec le démarrage automatique est toujours en cours d'exécution en parallèle. Il doit d'abord être terminé et retiré du démarrage automatique si nécessaire.

Image : Connexion Putty et démarrage du programme

Quittez le programme avec Ctrl+C ; et si vous voulez arrêter le Raspi de manière ordonnée, tapez ce qui suit :
sudo shutdown - h now

Enfin l'opposé de l'autostart, l'arrêt automatique sans écran et sans clavier. Un outil d'Adafruit, mais incompréhensible sans l'explication de Michael Horne (https://www.recantha.co.uk/blog/), que je traduis ici en allemand.

Le tout fonctionne en court-circuitant les deux dernières broches (carte #39=Masse et #40=GPIO21), que ce soit avec une fiche de court-circuitage ou un trombone.

Vous avez besoin du programme git, qui est préinstallé dans le système d'exploitation du Raspberry Pi de nos jours. Si vous ne l'avez pas encore, commencez par (après la mise à jour et la mise à niveau obligatoires)

Sudo APT get install git

En utilisant git clone, le script Adafruit est ensuite téléchargé :
Clone gitHttps: / / github.com / adafruit / adafruit - GPIO - Halt
Ou Clone gitGIT http: / / github.com / adafruit / adafruit - GPIO - Halt
Le clonage signifie que le répertoire a maintenant été copié sur notre Raspi. Nous nous rendons dans ce répertoire avec

Disque adafruitGPIO. Stop

Là, nous entrons les commandes suivantes l'une après l'autre :

Mari

Installation de sudo make

Ceci va installer le script dans le répertoire /usr/local/bin/gpio-halt

Pour exécuter ce script en tant que "service", nous créons le fichier requis avec :

Sudo Nano / LIB / systemd / System / GPIOArrête ça.

Entrez le code suivant dans nano :

[unité]
Description = raccourcir la broche 21 et le sol pour fermer Pi
Après = plusieursUtilisateurs. Objectifs

[services]
Type = inactif
Execstart = / usr / local / bin / GPIO pause 21

[installation]
Tu en veux?Utilisateurs. Objectifs

Dans nano, le script est enregistré avec Ctrl+o et okay, puis on quitte nano avec Ctrl+x.

Nous sommes de retour dans le terminal sur la ligne de commande. Ici, le programme est rendu exécutable avec :