22H — Thymio Truck
Par admin le mardi, février 8 2022, 12:00 - 2021–2022 - Lien permanent
Ce projet ayant pour but de simuler un camion autonome a été réalisé par Martins Piñon, Lois.
1. Introduction
Mon projet consiste à créer un robot capable de tirer une remorque et de pouvoir se mouvoir de manière autonome selon des informations qui lui ont été données et qui vont être nécessaire à la décision de son itinéraire.
L’industrie des technologies autonomes a énormément évolué ces dernières années. Certaines sociétés travaillent sur le développement de voitures autonomes, comme Tesla ou Hyundai, mais d’autres sociétés, comme Volvo avec son camion Truck Vera ou Mercedes-Benz avec le camion Future Truck 2025, ont pour objectif de développer des camions capables de se déplacer sans aide manuelle. Ces technologies sont intéressantes car elles permettraient à notre société un déplacement plus écologique et plus sûr, sans parler de la possibilité de connexions entre appareils. Bien que le contexte soit moins complexe, mon projet a pour but de simuler un système de logistique autonome de taille réduite avec le Thymio pour permettre la compréhension du fonctionnement de cette nouvelle technologie.
Source de l'image: https://www.futura-sciences.com/tech/actualites/voiture-volvo-presente-camion-autonome-cabine-60195/
Le problème à résoudre consiste donc à utiliser le Thymio afin de pouvoir déplacer la remorque d’un endroit initial à un endroit final en utilisant différentes technologies informatiques comme une caméra et un moteur.
Premièrement, le robot devrait être capable d’obtenir les informations de la remorque comme son poids ou sa hauteur et devrait ensuite être capable de s’y accrocher de manière totalement autonome. La difficulté apportée dans cette situation est que le robot ne saura pas dès son départ quel chemin il devra emprunter et devra donc être capable de faire des choix tout au long de son voyage à l’aide de panneaux routiers sous forme de codes QR présents au bord des chemins. Il continuerait en suivant une ligne et prenant des décisions sur son itinéraire à chaque fois que celui-ci se trouve à une intersection en scannant un code QR. Finalement, le robot devrait être capable de pouvoir garer la remorque et ensuite se positionner pour une nouvelle mission.
2. Matériel et méthodes
2.1 Matériel
Pour ce projet, j'ai eu besoin de:
- Un Thymio
- Une remorque en Lego
- Une caméra Raspberry Pi
- Un Raspberry Pi 3
- Une structure pour accrocher la caméra et le Raspberry Pi au Thymio
Ensuite, pour simuler le chemin que le Thymio devrait prendre, j'ai utilisé:
- Du scotch noir
- Des panneaux avec différents codes QR
- Une boîte afin de garer la remorque
Tout le matériel nécessaire au servo-moteur est présent dans le point 2.2.3 Remorquage car je n'ai malheureusement pas réussi à conclure ce projet avec cette partie mais j'ai quand même voulu vous partager mon idée.
Ensuite, il faut accrocher la caméra au Raspberry Pi, comme sur l'image:
Et finalement, on assemble le tout ensemble:
2.2 Méthode
Mon projet nécessite d'utiliser différentes techniques afin de pouvoir fonctionner, c'est pour cela que j'ai décidé de le diviser en plusieurs parties afin de pouvoir coder plus facilement chacunes d'elles et les mettre ensemble au fur et à mesure de l'évolution de mon projet.
J'ai donc divisé mon projet en 7 parties:
- Le déplacement du Thymio afin de pouvoir être en position de remorquage.
- Le remorquage.
- Le suivi de la ligne.
- La détection des codes QR ainsi que l'interprétation de leurs données.
- Le choix du chemin au fil de l'itinéraire.
- Le parcage de la remorque.
- Le déplacement du Thymio afin de pouvoir être en position de recommencer l'itinéraire suivant.
Toutes ces parties ont été assemblées au fur et à messure de manière à pouvoir corriger les erreurs et même prévoir des problèmes qui n'avaient pas été considérés. Elles m'ont aussi beaucoup aidé à fractionner ce projet et m'ont aussi permis ensuite de pouvoir diviser correctement le code en Aseba et en Python, mais je vous en parlerai dans le paragraphe suivant.
2.2.1 Installation des paquets Python
Ce projet utilise différentes technologies et différents matériaux électroniques, ce qui m'a mené a codé ceux-ci dans deux différents languages de programmation. Ayant des connaissances plus sûres en Aseba pour coder le Thymio, j'ai décidé d'utiliser ce language pour la plupart de mes étapes de manière à coder plus facilement. Ce code m'a permis de déplacer le Thymio, le faire suivre une ligne et même savoir quand il devrait s'arrêter pour scanner les codes QR. Aseba a donc été utilisé car il me permettait d'atteindre mes objectis de manière précise en utilisant les capacités du Thymio comme ses capteurs de luminosité à l'avant prox.ground.delta ou ses capteurs d'obstacles prox.horizontal... .
Il m'a donc fallu trouver une solution pour connecter mon Thymio à une autre technologie capable de scanner des codes QR ainsi que d'activer un servo-moteur. J'ai donc opté pour la solution du Raspberry Pi qui pouvait être connecté à une caméra Raspberry Pi, ainsi qu'à un Adafruit qui pourrait lui-même se connecter à mon servo-moteur.
Après avoir trouvé cette alternative, il me restait toujours un problème: Comment allais-je connecter le Thymio et le Raspberry Pi ensemble sachant que ces deux technologies devaient être codées de deux manières différentes? Le robot aurait pu être codé en Python, mais ayant des connaissances moins profondes dans ce language, j'ai donc préféré de le coder avec Aseba. Ma première solution a donc été d'utiliser une librairie nommée "tdmclient", qui permettait d'utiliser du code Aseba dans un programme codé en Python tout en utilisant une certaine nomenclature. En utilisant cette librairie, le Thymio et le Raspberry Pi pouvaient être connectés ensemble. Deuxièmement, pour utiliser la caméra ainsi que le servo-moteur, j'ai décidé d'utiliser d'autres librairies nommées "opencv-python" pour le traitement d'image et le "RPi.GPIO" pour l'utilisation du crochet de remorquage.
Pour commencer à coder mon projet, il a donc fallu que j'installe l'ensemble de ces librairies dans le terminal de mon Raspberry Pi.
Pour l'installation de Python 3.7
sudo apt-get install python3.7
Pour l'installation de tdmclient__
pip install tdmclient
Pour l'installation d'opencv-python
sudo apt-get install python3-opencv
sudo apt-get install libqt4-test python3-sip python3-pyqt5 \ \
libqtgui4 libjasper-dev libatlas-base-dev -y
pip3 install opencv-contrib-python==4.1.0.25
sudo modprobe bcm2835-v4l2
Quand tous les paquets ont été installés, il ne me fallait plus qu'à s'assurer que la caméra pouvait fonctionner. Pour cela, il faut s'assurer que certains ports soient activés. Il faut donc configurer le Raspberry Pi en le connectant à un écran de manière à accéder à l'interface Raspbian. Quand cela est fait, il suffit d'aller dans les configurations et d'activer les ports nécéssaires. J'ai personnellement tout activé afin d'avoir accès à tous les ports.
Ensuite, pour commencer correctement mon code, j'ai écrit ceci au début de mon programme, ce qui me permet de relier l'ensemble de mes fonctions à ces librairies téléchargées par moi-même juste avant.
#!/usr/bin/python from tdmclient import ClientAsync, aw import time import cv2 from distutils.log import info
Il m'a fallut connecter mon Raspberry Pi à sa caméra ainsi qu'à une batterie qui lui donnerait l'énergie nécessaire. Dans les vidéos faites pour présenter ce projet, je n'ai pas mis de batterie car la caméra n'était pas configurée et cela restait donc inutile. Mais si le projet s'était bien déroulé, j'aurais du ajouter une batterie à l'arrière de mon Thymio.
Et finalement, il me fallait aussi connecter le Thymio au Raspberry Pi. Il existe deux différentes manières:
- Le connecter avec son câble à un des ports du Raspberry Pi.
- Le connecter en utilisant le dongle. Cette technique requiert une configuration du dongle avec le Thymio. Quand ceci est fait, il suffit de se connecter au Thymio par l'interface de Thymio Suite.
2.2.2 Déplacement du Thymio jusqu'au remorquage
La première partie de mon projet consistait à coder en Aseba mon Thymio de manière à ce qu'il commence son programme depuis l’arrière de la remorque. Juste avant d'utiliser ce morceau de code, je tiens à préciser que le robot aura déjà scanné une première fois un code QR de manière à obtenir les informations de sa mission, mais je préfère développer cette étape dans le paragraphe 2.2.5 Détection des codes QR et leurs interprétations. Le principal but de ce code est que, après avoir scanné le code QR, le robot devrait être capable de contourner la boite servant de parking de manière à se positionner pour que le Thymio soit prêt à activer son code pour utiliser son crochet, comme montré dans cette vidéo:
Récupération de la remorque
Ce code utilise une grande quantité de variables status afin de permettre au robot d'agir différemment selon la position du robot par rapport à la boîte.J'ai utilise les mots bypass(1,2 ou 3) pour parler des moments où le Thymio longe le premier, deuxième ou troisième bord de la boîte. Les autres status, comme le dit leurs noms, permettent de savoir quand tourner.
var status var bypass1=1 var bypass2=2 var bypass3=3 var turn_left=4 var last_turn=5 var direction_turn=6 var towing=7 var turn_right=8 var go=9 status=bypass1
De cette manière, ces différentes variables m'ont permis d'utiliser l'événement timer de manière à chronométrer certains mouvements comme tourner à gauche ou avancer tout droit afin de pouvoir tourner. L'image ci-dessous est le code où le robot nécessite d'environ 2.3 secondes en tournant à gauche à une vitesse de -100 et à droite de 100, ainsi que celui pour négocier son contournement du virage.
Code pour tourner à gauche:
onevent prox
if status==turn_left then #virage à gauche
timer.period[0]=2300
motor.left.target=-100
motor.right.target=100
end
onevent timer0
if status==turn_left then
motor.left.target=0
motor.right.target=0
status=bypass2
timer.period[0]=0
end
Code pour tourner à droite:
onevent prox
if status==bypass1 and prox.horizontal[0]>0 then
motor.left.target=100
motor.right.target=100
end
if status==bypass1 and prox.horizontal[0]==0 then #fin du premier côté
timer.period[1]=4600
motor.left.target=100
motor.right.target=100
end
onevent timer1
if status==bypass1 then
motor.left.target=0
motor.right.target=0
status=turn_left
timer.period[1]=0
end
Comme dit antérieurement, j'ai beaucoup utilisé le capteur prox.horizontal afin de pouvoir assurer une certaine précision dans le contournement de la boîte. Comme vu dans la vidéo, à certains moments, le Thymio change de couleur et cela dépend de quand le capteur avant-gauche capte quelque chose en face de lui. Il m'a fallut répéter ce code plusieurs fois pour savoir combien de temps le robot nécéssiterait d'avancer pour ensuite avoir assez de place pour tourner et suivre un autre côté de la boîte.
Ce schéma explique simplement la technique que j'ai utilisé pour contourner correctement la boîte. Au début, le robot est toujours en train d'arriver parallèlement à la boîte et son capteur avant-droit est assez prêt du bord pour le détecter, la situation est alors prox.horizontal(0)>0. Mais à partir du moment que le Thymio se trouve dans la situation 1, son capteur avant-droite ne capte plus rien, c'est la situation prox.horizontal(0)=0. J'ai donc demandé à mon robot de se déplacer de 4.6 secondes vers l'avant afin d'arriver à la position 2, puis de tourner de 90° pour ensuite recommencer le programme comme le robot à la position 3, qui est en réalité l'équivalent de la position 1.
2.2.3 Remorquage
Malgré le fait que je n'ait pas pu avoir le temps de développer correctement mon idée de remorquage, j'ai quand même décidé de vous partager l'idée que j'avais, mais je tiens à souligner que le code présenté n'aura jamais pu être testé.
Premièrement, il aurait fallut ajouter un autre paquet de Python de manière à pouvoir exécuter le code du remorquage.
Pour l'installation de RPi.GPIO
sudo apt-get install rpi.gpio
Ensuite, il aurait fallut exécuter ce code pour que le crochet tourne de 90° afin de crocheter la remorque.
from gpiozero import AngularServo
from time import sleep
servo = AngularServo(12, min_pulse_width=0.5, max_pulse_width=0.5)
while (True):
servo.angle = 90
sleep(2)
print("Tourne")
servo.angle = 0
print("Remorque prête")
if ord("q") == True:
print("Processus arrêté")
break
Dans ce programme, le servo-moteur aurait seulement été en arrêt quand servo.angle = 90, puis aurait attendu 2 secondes pour enfin tourner de 90° avec servo.angle = 0. Ce code est assez simple car son mouvement ne nécessite pas de conditions difficiles, mais c'est sa configuration hardware qui a été personnellement plus difficile à organiser et comprendre.
2.2.4 Suivi de la ligne
Afin d'avoir un chemin défini, le Thymio a pour objectif de suivre une ligne qui nous permette de le contrôler et de lui mettre des limites. Cette ligne noire peut être considérée comme faisant office de route.
Il est possible de voir ce que j'ai obtenu grâce à cette vidéo:
Suivi de la ligne
J'ai trouvé cette partie de code sur un tutoriel pour apprendre à suivre une ligne et me suis permis de le modifier de manière à le rendre plus précis en le faisant rouler à une vitesse inférieure. Ce code utilise ces deux capteurs prox.ground.delta pour déterminer si le Thymio suit la ligne, s'il en sort et pour savoir comment doit être sa trajectoire afin de pouvoir retrouver la ligne noire.
onevent prox
p1=prox.ground.delta[0]
callsub statistics
if abs(ndev)<SIGMA and status==black_line then
preg=1*ndev/10
ireg=ireg+10*preg/30
motor.left.target=(speed-(preg+ireg))/8
motor.right.target=(speed+(preg+ireg))/8
end
if abs(ndev)>SIGMA and status==black_line then
ireg=0
motor.left.target=1*ndev/2
motor.right.target=-1*ndev/2
end
sub statistics
call math.max(maxi,maxi,p1)
call math.min(mini,mini,p1)
if maxi-mini>400 then
call math.muldiv(vari,45,maxi-mini,100)
mean=(mini+maxi)/2
call math.muldiv(ndev,SIGMA,p1-mean,vari)
end
Dans ce code, le paragraphe sub statistics permet d'analyser les résultats de chaque capteur prox.ground.delta de manière à savoir si le robot suit la ligne ou commence à en sortir. Avec ce code, le Thymio peur régler sa vitesse de manière à se remettre sur la bonne voie. Ce processus est fait en changeant constamment la vitesse de chaque moteur séparément. Si le robot remarque une variation plus importante dans ses capteurs, il comprend qu'il s'éloigne de la ligne plus rapidement et nécessite donc de plus utiliser un moteur que l'autre selon le cas. J'ai décidé de réduire la vitesse en la divisant par 8 afin que le Thymio ait plus de temps pour réagir à toute situation. Malgré un itinéraire plus long, la précision du robot semble plus importante et cela nous permet d'enlever les chances d'échecs sur le suivi de la ligne.
2.2.5 Détection des codes QR et leurs interprétations
Cette partie du code a encore été codée en Aseba et est un supplément au code suivant la ligne noire. D'une certaine manière, cette partie permet au robot de savoir quand il doit s'arrêter, et par conséquent, à quel moment et à quel endroit il doit scanner le code QR qui lui donnera les informations sur la route qu'il va emprunter par la suite.
Ce code est assez simple. Le status est toujours égal à black_line, tant que le robot reste sur la ligne noire, et avance en suivant le programme du suivi de la ligne. A partir du moment qu'il détecte quelque chose sur sa gauche avec son capteur prox.horizontal(0), celui-ci continue encore d'avancer à la même vitesse pendant 4.3 secondes avant de s'arrêter avec l'événement timer0. Le choix de cette durée de temps a plutôt été prise de manière à s'arrêter parfaitement devant le code QR, mais il est possible que selon la manière dont est présenté le code (sur un téléphone ou sur une feuille collée à un mur), l'endroit où s'arrêter change un peu. A partir de ce moment, le status devient scanner. Cela permet au robot de comprendre qu'il doit alors scanner le code QR et que le code Aseba doit s'arrêter. Il passe donc le relais au code écrit en Python qui va s'occuper de prendre les informations du code QR.
onevent prox
if prox.horizontal[0]>0 and status==black_line then
timer.period[0]=4300
motor.left.target=100
motor.right.target=100
status=scanner
end
onevent timer0
if status==scanner then
timer.period[0]=0
motor.left.target=0
motor.right.target=0
end
Ce code ainsi que celui du suivi de la ligne vont être, à chacune des 3 intersections, utilisés de manière à pouvoir répéter de manière similaire ce code exact. A chaque fois que celui-ci sera fini, le programme Python va à ce moment-là "quitter" le code Aseba pour commencer à utiliser le code en Python pour le scanner.
Passons maintenant à une autre partie assez intéressante: l'utilisation de la caméra. Je me suis aussi aidé d'Internet pour créer cette autre partie de mon code et me suis encore permis d’en faire quelques modifications. Celui-ci utilise la caméra du Raspberry Pi, qui s'active à chaque fois que le Thymio s'approche d'une intersection par le code montré juste au-dessus. Une fois activé, la caméra scanne le code QR et récupère l'information de celui-ci. Il est aussi possible de forcer le programme à s'arrêter en appuyant sur la touche "q", même si ceci n'est pas forcément utile dans mon programme, il permet de l'arrêter d'une manière assez simple.
cap = cv2.VideoCapture(0)
detector = cv2.QRCodeDetector()
while True:
_, img = cap.read()
data, bbox, _ = detector.detectAndDecode(img)
if data:
print("Valeur du panneau: ", data)
break
cv2.imshow("code detector", img)
if(cv2.waitKey(1) == ord("q")):
print("process finished")
break
cap.release()
cv2.destroyAllWindows()
Après avoir scanné, ce message est partagé:
Valeur du panneau: 0 ou 1 (selon l'information scannée)
Pour compléter mon explication sur mon système de communication d'information, j'ai décidé d'utiliser un système de conversion binaire. Le premier code QR, scanné au tout début du programme à l'arrière de la boîte de la remorque, contient l'information d'une valeur entre 0 et 7 de manière à pouvoir écrire cette valeur avec trois bites. Chacun des bites, écrit par 0 ou 1, permettront au robot de lui assimiler une caractéristique. Je n'ai pas voulu décider des caractéristiques de la remorque car ceci n'était pas très important dans mon projet, le plus important consistait à ce que le robot puisse déterminer, selon les informations obtenues, quel chemin il devrait prendre. Arrivé devant les panneaux routiers sous forme de code QR, le programme va comparer la valeur du panneau qui sera, soit 0, soit 1. Il va ensuite comparer la valeur initiale et celle scannée sur le moment. Si la valeur est la même, le robot continue tout droit, si elle est différente, le robot tourne à droite jusqu'à capter à nouveau une ligne noire et continuer sur cette route avec le programme de changement de ligne.
2.2.6 Changement de voie
Après avoir reçu son information, j'ai codé mon programme de manière à comparer les valeurs obtenues avec les codes QR.
Si le robot trouve les mêmes bites, on demande au robot de sauter l'étape du changement de voie et le robot attend seulement de reprendre le code pour suivre la ligne en écrivant "Thymio suit la ligne.".
if data1==data:
print("Thymio suit la ligne.")
client.run_async_program(follow_line)
Si le robot obtient deux valeurs différentes, il va alors activer le code de changement de ligne et écrit "Thymio change de ligne.".
if not data1==data:
print("Thymio change de ligne.")
client.run_async_program(change)
Ce programme, codé en Aseba, demande au Thymio de quiter sa ligne en tournant sur lui-même jusqu'à retrouver une autre ligne noire.
var status var running=1 var black_line=2 var turn=3 if status==black_line then status=black_line else status=turn end if status==turn then timer.period[0]=300 motor.left.target=50 motor.right.target=-50 status=running end onevent prox if status==running then motor.left.target=50 motor.right.target=-50 end if prox.ground.delta[1]<800 and status==running then motor.left.target=0 motor.right.target=0 status=black_line end
Ce code semble plus facile à faire qu'à écrire car j'utilisais deux lignes similaires. Il n'était pas possible de dire "Si tu vois une ligne noire, tu t'arrêtes." parce que la ligne vue par le Thymio aurait été la première, sa vitesse de rotation étant trop lente et avoir une vitesse plus haute n'aurait pas permis une bonne précision. J'ai donc du utiliser des status qui permettaient au robot de savoir à quelle stade de ce programme il se trouvait. Initialement, le robot commençe à tourner à droite pendant 0.3 secondes de manière à être sorti de la première ligne noire. Ensuite, on lui demande simplement de continuer de tourner à droite jusqu'au moment où son capteur avant gauche au sol détecte une ligne noir. A ce moment, le programme du choix de ligne est fini et le programme du suivi de ligne reprend.
Voici ce que je cherchais à obtenir pour cette partie de mon programme:
Changement de ligne
2.2.7 Parcage de la remorque et déplacement du Thymio pour la préparation à la prochaine mission
Pour terminer mon programme, le robot ayant fait tous ses choix au fil de son itinéraire afin d'arriver à sa destination, arrive à la fin de la ligne noir qu'il suit, où il suit un code Aseba simple qui lui demande de s'arrêter. Parquer un Thymio est une épreuve assez difficile après un parcours autant long dû à certaines imprécisions, mais parquer le Thymio avec une remorque est encore plus difficile.
J'ai décidé de positionner le Thymio et sa remorque à l'opposé de leur sens d'arrivée, en faisant tourner le robot de 180° autour de la remorque comme si la remorque était le centre d'un cercle et lui sa circonférence. De cette manière, il ne suffit plus qu'à faire reculer la remorque jusqu'à la rentrer dans sa boîte.
Parcage_1
En voyant ce morceau de code, on comprend que la précision des moteurs et du temps sont nécessaires pour le Thymio. Les trois premières parties présentes dans onevent prox, permettent au robot de se placer correctement pour tourner autour de la remorque (if status==final), de contourner la remorque (if status==final2) et de se mettre dans le sens de la marche-arrière (if status==final3). A chacun de ces blocs, j'ai rajouté la condition "if ... and prox.horizontal(2)==0" then qui permet d'assurer que le robot que le robot ne fera pas de collision frontale avec tout autre objet trouvé sur son itinéraire.
onevent prox
if status==final and prox.horizontal[2]==0 then
timer.period[0]=2300
motor.left.target=-100
motor.right.target=100
end
if status==final2 and prox.horizontal[2]==0 then
timer.period[1]=10700
motor.left.target=100
motor.right.target=200
end
if status==final3 and prox.horizontal[2]==0 then
timer.period[0]=2150
motor.left.target=100
motor.right.target=-100
end
if status==back and prox.horizontal[2]==0 then
timer.period[1]=7000
motor.left.target=-200
motor.right.target=-200
end
onevent timer0
if status==final then
motor.left.target=0
motor.right.target=0
timer.period[0]=0
status=final2
end
if status==final3 then
motor.left.target=0
motor.right.target=0
timer.period[0]=0
status=back
end
onevent timer1
if status==final2 then
motor.left.target=0
motor.right.target=0
timer.period[1]=0
status=final3
end
if status==back then
motor.left.target=0
motor.right.target=0
timer.period[1]=0
status=leave
end
Comme vu dans le quatrième bloc, si le status est back, le robot recule afin de mettre la remorque dans sa boîte et cela lui est demandé d'être fait en 7 secondes (=7'000 millisecondes), il est donc nécessaire de suivre une structure et un plan précis de comment la boîte doit être placée par rapport à la dernière ligne noire à suivre. Voici donc comment il est nécessaire de positionner la boîte:
La distance de 30 à 35 centimètres est nécéssaire au Thymio pour pouvoir se retourner et reculer. Dans mon programme, je lui demande de reculer pendant 7 secondes, il faut donc que cette longueur soit aussi respectée. Ce qui est aussi important à noter est que la ligne noire doit être orientée vers la boîte de manière à ce que quand le robot fasse un tour de 180° et recule, il se trouve correctement à l'intérieur de la boîte.
Celle-ci parquée, le code est presque similaire à celui de la partie 2.2.2 Déplacement du Thymio jusqu'au remorquage, le robot contourne à nouveau la boîte en utilisant ces capteurs frontaux pour savoir à quels moments le Thymio doit tourner pour contourner au mieux la boîte. Normalement, j'aurais dû séparer ce morceau de code pour pouvoir mettre entre deux le programme de remorquage. Pour mon projet, j'ai décidé de ne pas le diviser car je savais déjà que je ne pourrais pas finir entièrement ce projet, mais j'ai décidé de mettre un interval de 5 secondes où le robot ne bouge pas afin d'avoir le temps d'enlever manuellement le crochet de la remorque. J'ai décidé de conclure ce programme en le parquant de cette manière car celle-ci est la même que la position initiale du programme et permet donc de pouvoir répéter autant de fois le programme entier.
Parcage_2
3. Résultats
Mon projet n'a pas atteint entièrement ses objectifs car il manque beaucoup d'éléments et de parties que j'avais pensé pouvoir incorporer à mon projet. Même si celui-ci ne marche pas et n'a pas tous les éléments que je comptais mettre, j'ai quand même réussi à coder plusieurs parties de celui-ci. Le programme en lui même n'est pas capable de réussir mon objectif, mais si on regarde partie par partie ce projet, il reste beaucoup de parties qui marchent et sont capables de mouvoir mon robot d'un poit A à un point B.
Commençons par les points négatifs...
Premièrement, je n'ai pas réussi à télécharger les librairies "tdmclient" et "opencv-python" et n'ai donc pas pu connecter toutes mes parties ensembles. Au début, seul "opencv-python" était téléchargé. Je l'avais testé sur mon ordinateur avec Visual Studio Code et en utilisant la caméra de l'ordinateur. Le code marchait parfaitement et réussissais à me donner l'information du code QR. Après plusieurs difficultés, j'ai réussi à télécharger "tdmclient". J'ai donc essayé mon programme avec les librairies et celui-ci marchait mais je devais montrer les codes QR à la caméra de l'ordinateur car mon programme était lancé depuis mon ordinateur. J'ai donc essayé de le faire tourner sur l'interface Raspbian mais le programme ne s'éxécutait pas à cause d'erreurs dans le programme. Je pense qu'au point de vue du code, mon programme marche car j'ai réussi à faire éxécuter l'ensemble de ses tâches, à l'exception du remorquage, en utilisant la caméra de mon ordinateur.
Deuxièmement, mon programme ne contenait pas le code pour crocheter la remorque car je n'ai pas eu le temps de développer cette partie du projet. Je m'étais plus concentré sur mon problème de librairie qui me semblait plus important. Je m'y étais un peu intéressé avant que tout le matériel soit arrivé mais le hardware semblait demander un peu plus de connaissances dans la connexion de tous les composants, ce que je n'avais pas prévu de faire. Sans le problème de librairies, le programme est tout de même utilisable, il suffit seulement d'une aide manuelle pour enlever et mettre le crochet.
Pour résumer, mon principal point négatif de mon projet consiste en la configuration d'hardware. Connecter le Raspberry Pi avec la caméra ainsi que le servo-moteur du crochet, qui devait encore être connecté par d'autres câbles à un Adafruit.
Passons aux point positifs... La partie concernant le Thymio me semble marcher correctement, coder en Aseba était beaucoup plus simple et la connexion entre les différents capteurs du Thymio était déja faite dans le robot, contrairement au Raspberry Pi.
Le Thymio contournanit bien la boîte et se positionait correctement de manière à crocheter la remorque. L'idée de l'utilisation des capteurs prox.horizontal me semble avoir été très utile car cela a permis au robot de trouver la remorque, mais ceci-ci est encore plus pratique car il permet au Thymio d'aller crocheter une remorque présente dans une boîte de n'importe quelle dimension. Ensuite, son suivi de ligne ainsi que le changement de chemin étaient très précis. La vitesse est assez lente, mais ceci permet au robot de rester dans sa zone et d'éviter tout mouvement brusque qui le ferait sortir de la ligne et le perdre.
La partie concernant le parquage de la remorque m'a plus posé de problème car il était difficile de savoir dans quelle position le robot allait arriver en suivant la ligne, sachant que'un tout petit écart d'angle pouvait rendre la manoeuvre difficile. Dans mon propre cas, il était difficile de faire marcher la remorque car celle-ci se désorientait rapidement à cause de ces deux roues. Il fallait constamment que celles du Thymio et de la remorque aillent dans la même direction, ainsi que celle-ci soit vers la boîte. En testant cette partie de mon projet, j'ai eu beaucoup de mal à trouver le timing et l'intensité des moteurs correctes pour assurer un succès au parcage.
La capture d'image est aussi un succès dans ce programme au niveau du code car, comme expliqué antérieurement, celui-ci réussissait à capturer des informations, les traduire, ainsi que les utiliser pour en faire un choix dans leur itinéraire. La reconnaissance du code QR était très rapide et ne semblait pas avoir de problème à trouver le code ainsi que de prendre du temps à vouloir décrypter le message dissimulé.
4. Discussion
Je pense que ce projet peut être encore plus dévelopé de manière à le finir et atteindre les objectifs que je m'étais fixé au début de ce projet. Comme expliqué avant, mes deux gros problèmes étaient l'utilisation de la caméra et l'utilisation du servo-moteur. Je pense que mon projet aurait pu être amélioré si j'avais plus de temps pour programmer et configurer les composants électroniques ainsi que si je m'étais plus intéressé à la manière dont je devais assember les composants de la remorque et coder le programme.
Pour améliorer le problème de la caméra, je pense que la seule chose que j'aurais pu faire était d'installer correctement la librairie "opencv-python". Celle-ci enfin prête aurait pu fonctionner correctement comme expliqué antérieurement. Je pense que ce problème n'était pas lié au programme, ni à la connexion, mais plutôt à la configuration des librairies Python.
Ensuite, pour assurer la réussite du crochet, il faudrait que j'aie plus de temps afin de pouvoir étudier pendant plus de temps la manière dont il fallait connecter le Raspberry Pi, le servo-moteur, l'Adafruit et tous les câbles. Après, il m'aurait fallut que cette configuration fonctionne de manière à pouvoir tester le programme, que j'avais déja trouvé sur Internet.
Dans ces deux cas, on peut voir que j'ai eu des difficultés à configurer la caméra et le servo-moteur, malgré le fait que j'avais les programmes nécessaires.
Il est aussi possible de remarquer que le parquage de la remorque est une partie du programme qui pose beaucoup de problèmes dû à sa précision. Mais je ne pense pas qu'il soit possible d'améliorer cette partie du code car le Thymio et sa remorque doivent obligatoirement se tourner de 180° et ensuite reculer. Il est encore possible avec cet exemple de voir que le matériel extérieur à l'informatique ont posé beaucoup de problèmes dans mon projet.
5. Conclusion
Pour conclure, mon projet n'a pas atteint ses objectifs mais m'a permis de plus me familiariser à l'univers des projets informatiques. Dans ce projet, il est possible de conclure que l'écriture de mon programme s'est bien déroulée mais que mes connaissances dans les configurations de matériel informatique n'ont pas été nécessaires afin de permetre la réussite entière de mon projet. Je pense qu'il m'aurait fallut plus de temps afin d'agrandir mes connaissances dans la connexion des différents composants et que ce projet pourrait peut-être être une idée de projet informatique de printemps.
Ce projet m'a permis d'approfondir mes connaissances en programmation du language Aseba et Python, mais il m'a aussi permis de me rendre compte de la complexité du hardware. Grâce à ce projet, j'ai pu me rendre compte que plus le nombre de composants d'hardware est grand, plus le projet est important car la connexion entre les composants est difficile. Finalement, il m'a aussi permis de penser à un projet et de l'organiser.
Pour revenir au sujet de mon introduction qui était la conduite autonome de camions, ce projet m'a aussi permis de me rendre compte de toutes les technologies nécessaires à la création d'un camion autonome. J'ai aussi pu voir tous les éléments qui peuvent avoir un impact sur cette nouvelle technologie et la manière dont il est nécessaire de s'organiser pour en faire un nouveau moyen de transport sûr et pratique.
Pour finir, j'ai eu énormément de plaisir à créer ce projet, de la soumission de mon idée jusqu'à ce rendu final, qui m'a encore plus donné envie de m'intéresser à l'informatique et à la manière dont il faut s'organiser pour créer un projet. Je me suis rendu compte que la programmation était vraiment nécessaire pour développer une idée, mais qu'elle permettait aussi de pouvoir créer n'importe quoi, ce qui m'a apporté plus de confiance et m'a plus encouragé à chercher à comprendre la programmation, une chose qui me semblait très dure à apprendre avant le début de cette année, mais qui avait toujours suscité ma curiosité. Grâce à ce projet, je repars avec encore plus d'idées pour d'autres projets et encore plus d'envie d'apprendre à déveloper mes connaissances en informatique...
Références
Pour l'introduction sur les camions autonomes:
Les camions autonomes, avant les voitures ?
Volvo Trucks – Introducing Vera, the future of autonomous transport
Image Volvo Truck
Pour suivre une ligne:
Thymio suit un bord noir
Pour scanner le code QR:
Real Time Scanning and Storing QR Codes With Raspberry Pi and OpenCV
Pour utiliser les servo-moteur:
Controlling Standard Servos with Raspberry Pi