Learning Lab Environnements Connectés - Contributions de l’utilisateur [fr]

REBEQA

2025-05-25T21:06:42Z

Isabelle : /* Le mouvement est comme suit : */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Wifi

==Gestion de la motorisation des roues==

Les batteries ne générant pas de tension continue d'un moment à un autre et pour répondre au problème de glissement des roues, nous avons besoin d'asservir nos moteurs.
Pour cela nous avons chercher à visualiser des signaux des moteurs.

Voici donc les signaux du moteur en tournant les roues dans un sens:
[[Fichier:Tek001.png|375px]]

Et voici les signaux du moteurs en tournant dans l'autre sens

[[Fichier:Tek002.png|375px]]

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png|375px]]

[[Fichier:Shematic.png|375px]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg|375px]]

=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
* Exporter un fichier .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Pour exporter en .stl nous l'avons fait pour modéliser un labyrinthe en 2D. Nous l'importons ensuite sur Webots en utilisant le type transform pour pouvoir utiliser une échelle "scale" car il peut y avoir des problèmes de conversion en les unités de SolidWordks et les unités de Webots. Il n'y a plus de scale sur les types "Solid" depuis une mise à jour.
Sur le transform on ajoute une Shape puis une apparence et une géométrie. nous n'avons pas réussi à avoir les couleurs que nous avions mis sur SolidWorks.
[[Fichier:Webots_menu.png|400px|thumb|center|]]
Le modèle que nous avons modélisé sur SolidWork apparait sans les courleurs que nous avons mis sur SolidWorks
[[Fichier:labyrinth_SolidW.png|400px|thumb|center|Labyrinth 2D dans Webots]]
[[Fichier:labyrinth_Webots.png|400px|thumb|center|Labyrinth dans SolidWorks, après des modifications de l'apparence et de la forme]]
Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif|500px|center|thumb|démonstration du suivi de ligne]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===
Avec Webots, on peut tester différents stratégies de commande du robots pour voir les avantages et inconvénients de certaines stratégies. On peut décrire un modèle de robot assez fidèle à la réalité et représenter aussi son environnement.
La simulation nous a permis de développer une stratégie de commande pour les suiveurs de ligne et de l'adapter au mieux pour notre robot.
===Limites et inconvénient de Webots===
Webots demande beaucoup de temps pour l'utiliser correctement et créer un modèle qui va représenter au mieux notre robot. On peut facilement perdre du temps sur une fonctionnalité que l'on ne maîtrise pas. Pour les délais que l'on a, il est souvent plus rentable d'investir du temps dans la conception du robot finale plutôt que d'essayer d'avoir une simulation. Tout dépend de la maîtrise du logiciel

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

===Communication===
Nous avons choisis de faire une communication via Wifi pour transmettre le chemin jusqu'à l'objet d'un robot à un autre, ce qui possible grâce a l'utilisation de Raspberry Pi Pico WH pour l'échange d'information via TCP/IP. Pour cela, un des Raspberry, le "Serveur" sert d'Access Point (AP) avec un serveur TCP. Puis l'autre Raspberry, le "Client" se connecte au Wifi et en lui forçant une IP. On peut par la suite se connecter au serveur TCP et commencer à transférer des informations sous forme d'un string binaire de 0 et de 1. Par la suite, cela est traduit par le Raspberry "Serveur" pour soit tourner à droite, soit à gauche.

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
La piste est bordée de deux lignes noires. La logique de l'algorithme est comme suit :
*le capteur de ligne gauche rencontre une ligne noire -> le robot corrige est va à gauche. Matériellement c'est la roue avant qui tourne. idem pour la droite.

Problèmes rencontrés:
*Les capteurs de lignes doivent être très proches du sol pour pouvoir capter la ligne, il faut donc faire des réglages précis à adapter pour chaque robot.
*La PWM permet de régler la vitesse des moteurs, la clock de la PWM a été choisie à 5kHz part la fonction pwm_set_clkdiv_int_frac(slice_num_M1,98,0); le calcul peut être repris à avec [https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/ ce site web]
*Le robot va trop vite pour que la correction soit efficace, il y a franchissement de ligne. De plus il faut prendre en compte que la correction n'a lieu uniquement quand le capteur détecte la ligne. Nous avons donc essayé :
**De '''rajouter un délais''' pour que la correction ait lieu pendant plus longtemps, mais nous avions tout de même des problèmes de franchissement de ligne, toujours dût à la vitesse du robot.
**De '''diminuer la vitesse des roues arrières''' pendant la correction en les passant de 255 à 180. '''Cette méthode est concluante''' et permet une correction de trajectoire même avec un angle d'attaque important. Cet angle va dépendre de la manière dont tourne le robot. Il faut s'assurer qu'il tourne suffisamment pour que la correction soit possible.

Le code comprend :
Un fichier contenant le main : ''suivie_moteur.c'', qui se sert des fonctions définies dans le fichier ''fonctions'' pour initialiser les différents ports GPIO de la carte pico et lancer la boucle infinie avec la fonction de suivie de ligne principale.
Les fichiers fonctions.h et fonctions.c contiennent les éléments suivants :
*Les différentes bibliothèques nécessaires au fonctionnement du code
*Les définitions des différents ports GPIO, un par capteur de ligne et trois par moteur (2 pour le sens : IN1 et IN2 et 1 pour la PWM : ENA)
*La fonction '''setup_capt''' qui initialise les différents ports GPIO, les moteurs dont PWM
*La fonction '''pico_set_led''' qui prend en argument un booléen ''led_on'' et qui permet d'allumer la led de la board pi pico à des fins de débogage.
*La fonction '''setPWM''' qui prend en argument le pin enable d'un moteur et qui fixe la valeur de la PWM par l'argument value qui prend une valeur entre 0 et 255.
*La fonction '''commande_moteur()''' qui ne prend aucun argument et qui est l'algorithme principal de suivie de chemin.

[[Fichier : suivi_ligne.zip]]

==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter :
*'''Violet''': présence d'une intersection
*'''Rouge''' : virage à droite
*'''Bleu''' : virage à gauche
*'''Vert''' : virage à droite ou à gauche
*'''Jaune''' : impasse

Ces couleurs sont placées sur le labyrinthe comme sur l'image suivante :
[[Fichier:Image labyrinthe couleur.png|400px|thumb|center|Labyrinthe final avec les couleurs pour les intersections]]

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

[[Fichier : codes_parcours_et_controle]]

Ces fichiers sont tous necessaires au bon fonctionnement du robot. Le fichier capteur_acq initialise les différents capteurs et défini l'algorithme de détection de couleur, cette algorithme (la fonction measure_couleur) utilise la fonction ajouter du fichier Parcours. C'est dans cette fonction ajouter que sont gérer les commandes de rotation de robot, selon le prochain nœud.

====Le mouvement est comme suit :====
* La variable booléenne go est utilisée dans le main. Le robot suit le chemin (algorithme de suivi de ligne, fonction commande_moteur du fichier fonctions) si go est vraie. Si go est fausse alors le robot s'arrête (fonction stop_moteur du fichier fonctions).
* Si le robot detecte la couleur violet (P), dans la fonction ajouter du fichier Parcours, la condition couleur == 'P' est vraie, go passe à faux et le robot s'arrête. On est alors au milieu de l'intersection.
*L'algorithme de parcours du graphe donne le nœud suivant à explorer. Exemple : la couleur est verte (V) et le nœud suivant est à droite, le robot tourne à droite, la variable go repasse à true et le robot suit de nouveau la ligne jusqu'à la detection de la prochaine intersection.

'''Remarque :'''
les fonctions pour tourner sont basés sur un delay (les roues tournent pendant un certain temps). Cette méthode n'est pas fiable selon le robot, la vitesse des roues, la batterie. Asservir les moteurs serait plus efficace mais nous avons manqué de temps.

REBEQA

2025-05-25T21:03:54Z

Isabelle : /* Parcours d'un arbre */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Wifi

==Gestion de la motorisation des roues==

Les batteries ne générant pas de tension continue d'un moment à un autre et pour répondre au problème de glissement des roues, nous avons besoin d'asservir nos moteurs.
Pour cela nous avons chercher à visualiser des signaux des moteurs.

Voici donc les signaux du moteur en tournant les roues dans un sens:
[[Fichier:Tek001.png|375px]]

Et voici les signaux du moteurs en tournant dans l'autre sens

[[Fichier:Tek002.png|375px]]

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png|375px]]

[[Fichier:Shematic.png|375px]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg|375px]]

=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
* Exporter un fichier .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Pour exporter en .stl nous l'avons fait pour modéliser un labyrinthe en 2D. Nous l'importons ensuite sur Webots en utilisant le type transform pour pouvoir utiliser une échelle "scale" car il peut y avoir des problèmes de conversion en les unités de SolidWordks et les unités de Webots. Il n'y a plus de scale sur les types "Solid" depuis une mise à jour.
Sur le transform on ajoute une Shape puis une apparence et une géométrie. nous n'avons pas réussi à avoir les couleurs que nous avions mis sur SolidWorks.
[[Fichier:Webots_menu.png|400px|thumb|center|]]
Le modèle que nous avons modélisé sur SolidWork apparait sans les courleurs que nous avons mis sur SolidWorks
[[Fichier:labyrinth_SolidW.png|400px|thumb|center|Labyrinth 2D dans Webots]]
[[Fichier:labyrinth_Webots.png|400px|thumb|center|Labyrinth dans SolidWorks, après des modifications de l'apparence et de la forme]]
Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif|500px|center|thumb|démonstration du suivi de ligne]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===
Avec Webots, on peut tester différents stratégies de commande du robots pour voir les avantages et inconvénients de certaines stratégies. On peut décrire un modèle de robot assez fidèle à la réalité et représenter aussi son environnement.
La simulation nous a permis de développer une stratégie de commande pour les suiveurs de ligne et de l'adapter au mieux pour notre robot.
===Limites et inconvénient de Webots===
Webots demande beaucoup de temps pour l'utiliser correctement et créer un modèle qui va représenter au mieux notre robot. On peut facilement perdre du temps sur une fonctionnalité que l'on ne maîtrise pas. Pour les délais que l'on a, il est souvent plus rentable d'investir du temps dans la conception du robot finale plutôt que d'essayer d'avoir une simulation. Tout dépend de la maîtrise du logiciel

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

===Communication===
Nous avons choisis de faire une communication via Wifi pour transmettre le chemin jusqu'à l'objet d'un robot à un autre, ce qui possible grâce a l'utilisation de Raspberry Pi Pico WH pour l'échange d'information via TCP/IP. Pour cela, un des Raspberry, le "Serveur" sert d'Access Point (AP) avec un serveur TCP. Puis l'autre Raspberry, le "Client" se connecte au Wifi et en lui forçant une IP. On peut par la suite se connecter au serveur TCP et commencer à transférer des informations sous forme d'un string binaire de 0 et de 1. Par la suite, cela est traduit par le Raspberry "Serveur" pour soit tourner à droite, soit à gauche.

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
La piste est bordée de deux lignes noires. La logique de l'algorithme est comme suit :
*le capteur de ligne gauche rencontre une ligne noire -> le robot corrige est va à gauche. Matériellement c'est la roue avant qui tourne. idem pour la droite.

Problèmes rencontrés:
*Les capteurs de lignes doivent être très proches du sol pour pouvoir capter la ligne, il faut donc faire des réglages précis à adapter pour chaque robot.
*La PWM permet de régler la vitesse des moteurs, la clock de la PWM a été choisie à 5kHz part la fonction pwm_set_clkdiv_int_frac(slice_num_M1,98,0); le calcul peut être repris à avec [https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/ ce site web]
*Le robot va trop vite pour que la correction soit efficace, il y a franchissement de ligne. De plus il faut prendre en compte que la correction n'a lieu uniquement quand le capteur détecte la ligne. Nous avons donc essayé :
**De '''rajouter un délais''' pour que la correction ait lieu pendant plus longtemps, mais nous avions tout de même des problèmes de franchissement de ligne, toujours dût à la vitesse du robot.
**De '''diminuer la vitesse des roues arrières''' pendant la correction en les passant de 255 à 180. '''Cette méthode est concluante''' et permet une correction de trajectoire même avec un angle d'attaque important. Cet angle va dépendre de la manière dont tourne le robot. Il faut s'assurer qu'il tourne suffisamment pour que la correction soit possible.

Le code comprend :
Un fichier contenant le main : ''suivie_moteur.c'', qui se sert des fonctions définies dans le fichier ''fonctions'' pour initialiser les différents ports GPIO de la carte pico et lancer la boucle infinie avec la fonction de suivie de ligne principale.
Les fichiers fonctions.h et fonctions.c contiennent les éléments suivants :
*Les différentes bibliothèques nécessaires au fonctionnement du code
*Les définitions des différents ports GPIO, un par capteur de ligne et trois par moteur (2 pour le sens : IN1 et IN2 et 1 pour la PWM : ENA)
*La fonction '''setup_capt''' qui initialise les différents ports GPIO, les moteurs dont PWM
*La fonction '''pico_set_led''' qui prend en argument un booléen ''led_on'' et qui permet d'allumer la led de la board pi pico à des fins de débogage.
*La fonction '''setPWM''' qui prend en argument le pin enable d'un moteur et qui fixe la valeur de la PWM par l'argument value qui prend une valeur entre 0 et 255.
*La fonction '''commande_moteur()''' qui ne prend aucun argument et qui est l'algorithme principal de suivie de chemin.

[[Fichier : suivi_ligne.zip]]

==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter :
*'''Violet''': présence d'une intersection
*'''Rouge''' : virage à droite
*'''Bleu''' : virage à gauche
*'''Vert''' : virage à droite ou à gauche
*'''Jaune''' : impasse

Ces couleurs sont placées sur le labyrinthe comme sur l'image suivante :
[[Fichier:Image labyrinthe couleur.png|400px|thumb|center|Labyrinthe final avec les couleurs pour les intersections]]

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

[[Fichier : codes_parcours_et_controle]]

Ces fichiers sont tous necessaires au bon fonctionnement du robot. Le fichier capteur_acq initialise les différents capteurs et défini l'algorithme de détection de couleur, cette algorithme (la fonction measure_couleur) utilise la fonction ajouter du fichier Parcours. C'est dans cette fonction ajouter que sont gérer les commandes de rotation de robot, selon le prochain nœud.

====Le mouvement est comme suit :====
* La variable booléenne go est utilisée dans le main. Le robot suit le chemin (algorithme de suivi de ligne, fonction commande_moteur du fichier fonctions) si go est vraie. Si go est fausse alors le robot s'arrête (fonction stop_moteur du fichier fonctions).
* Si le robot detecte la couleur violet (P), dans la fonction ajouter du fichier Parcours, la condition couleur == 'P' est vraie, go passe à faux et le robot s'arrête. On est alors au milieu de l'intersection.
*-L'algorithme de parcours du graphe donne le nœud suivant à explorer. Exemple : la couleur est verte (V) et le nœud suivant est à droite, le robot tourne à droite, la variable go repasse à true et le robot suit de nouveau la ligne jusqu'à la detection de la prochaine intersection.

=====Remarque :=====
les fonctions pour tourner sont basés sur un delay (les roues tournent pendant un certain temps). Cette méthode n'est pas fiable selon le robot, la vitesse des roues, la batterie. Asservir les moteurs serait plus efficace mais nous avons manqué de temps.

Fichier:Suivi ligne.zip

2025-05-14T13:30:08Z

Isabelle : Projet VS code contenant le code principal du suivi de ligne et les fonctions qui lui sont nécessaires

== Description ==
Projet VS code contenant le code principal du suivi de ligne et les fonctions qui lui sont nécessaires

REBEQA

2025-05-14T13:27:15Z

Isabelle : /* Suivi de lignes */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Bluetooth

==Gestion de la motorisation des roues==

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png|375px]]

[[Fichier:Shematic.png|375px]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg|375px]]

=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
* Exporter un fichier .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Pour exporter en .stl nous l'avons fait pour modéliser un labyrinthe en 2D. Nous l'importons ensuite sur Webots en utilisant le type transform pour pouvoir utiliser une échelle "scale" car il peut y avoir des problèmes de conversion en les unités de SolidWordks et les unités de Webots. Il n'y a plus de scale sur les types "Solid" depuis une mise à jour.
Sur le transform on ajoute une Shape puis une apparence et une géométrie. nous n'avons pas réussi à avoir les couleurs que nous avions mis sur SolidWorks.
[[Fichier:Webots_menu.png|400px|thumb|center|]]
Le modèle que nous avons modélisé sur SolidWork apparait sans les courleurs que nous avons mis sur SolidWorks
[[Fichier:labyrinth_SolidW.png|400px|thumb|center|Labyrinth 2D dans Webots]]
[[Fichier:labyrinth_Webots.png|400px|thumb|center|Labyrinth dans SolidWorks, après des modifications de l'apparence et de la forme]]
Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif|500px|center|thumb|démonstration du suivi de ligne]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===

===Limites et inconvénient de Webots===

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
La piste est bordée de deux lignes noires. La logique de l'algorithme est comme suit :
*le capteur de ligne gauche rencontre une ligne noire -> le robot corrige est va à gauche. Matériellement c'est la roue avant qui tourne. idem pour la droite.

Problèmes rencontrés:
*Les capteurs de lignes doivent être très proches du sol pour pouvoir capter la ligne, il faut donc faire des réglages précis à adapter pour chaque robot.
*La PWM permet de régler la vitesse des moteurs, la clock de la PWM a été choisie à 5kHz part la fonction pwm_set_clkdiv_int_frac(slice_num_M1,98,0); le calcul peut être repris à avec [https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/ ce site web]
*Le robot va trop vite pour que la correction soit efficace, il y a franchissement de ligne. De plus il faut prendre en compte que la correction n'a lieu uniquement quand le capteur détecte la ligne. Nous avons donc essayé :
**De '''rajouter un délais''' pour que la correction ait lieu pendant plus longtemps, mais nous avions tout de même des problèmes de franchissement de ligne, toujours dût à la vitesse du robot.
**De '''diminuer la vitesse des roues arrières''' pendant la correction en les passant de 255 à 180. '''Cette méthode est concluante''' et permet une correction de trajectoire même avec un angle d'attaque important. Cet angle va dépendre de la manière dont tourne le robot. Il faut s'assurer qu'il tourne suffisamment pour que la correction soit possible.

Le code comprend :
Un fichier contenant le main : ''suivie_moteur.c'', qui se sert des fonctions définies dans le fichier ''fonctions'' pour initialiser les différents ports GPIO de la carte pico et lancer la boucle infinie avec la fonction de suivie de ligne principale.
Les fichiers fonctions.h et fonctions.c contiennent les éléments suivants :
*Les différentes bibliothèques nécessaires au fonctionnement du code
*Les définitions des différents ports GPIO, un par capteur de ligne et trois par moteur (2 pour le sens : IN1 et IN2 et 1 pour la PWM : ENA)
*La fonction '''setup_capt''' qui initialise les différents ports GPIO, les moteurs dont PWM
*La fonction '''pico_set_led''' qui prend en argument un booléen ''led_on'' et qui permet d'allumer la led de la board pi pico à des fins de débogage.
*La fonction '''setPWM''' qui prend en argument le pin enable d'un moteur et qui fixe la valeur de la PWM par l'argument value qui prend une valeur entre 0 et 255.
*La fonction '''commande_moteur()''' qui ne prend aucun argument et qui est l'algorithme principal de suivie de chemin.

[[Fichier : suivi_ligne.zip]]

==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter:
violet: présence d'une intersection
rouge: aller à droite
bleu: aller à gauche
vert: aller à droite ou à gauche
jaune: aller à droite, à gauche ou en avant
orange: impasse

Ces couleurs sont placées sur le labyrinthe comme sur la modélisation suivante:
SIMU

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

code:

REBEQA

2025-05-14T13:26:48Z

Isabelle : /* Suivi de lignes */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Bluetooth

==Gestion de la motorisation des roues==

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png|375px]]

[[Fichier:Shematic.png|375px]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg|375px]]

=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
* Exporter un fichier .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Pour exporter en .stl nous l'avons fait pour modéliser un labyrinthe en 2D. Nous l'importons ensuite sur Webots en utilisant le type transform pour pouvoir utiliser une échelle "scale" car il peut y avoir des problèmes de conversion en les unités de SolidWordks et les unités de Webots. Il n'y a plus de scale sur les types "Solid" depuis une mise à jour.
Sur le transform on ajoute une Shape puis une apparence et une géométrie. nous n'avons pas réussi à avoir les couleurs que nous avions mis sur SolidWorks.
[[Fichier:Webots_menu.png|400px|thumb|center|]]
Le modèle que nous avons modélisé sur SolidWork apparait sans les courleurs que nous avons mis sur SolidWorks
[[Fichier:labyrinth_SolidW.png|400px|thumb|center|Labyrinth 2D dans Webots]]
[[Fichier:labyrinth_Webots.png|400px|thumb|center|Labyrinth dans SolidWorks, après des modifications de l'apparence et de la forme]]
Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif|500px|center|thumb|démonstration du suivi de ligne]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===

===Limites et inconvénient de Webots===

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
La piste est bordée de deux lignes noires. La logique de l'algorithme est comme suit :
*le capteur de ligne gauche rencontre une ligne noire -> le robot corrige est va à gauche. Matériellement c'est la roue avant qui tourne. idem pour la droite.

Problèmes rencontrés:
*Les capteurs de lignes doivent être très proches du sol pour pouvoir capter la ligne, il faut donc faire des réglages précis à adapter pour chaque robot.
*La PWM permet de régler la vitesse des moteurs, la clock de la PWM a été choisie à 5kHz part la fonction pwm_set_clkdiv_int_frac(slice_num_M1,98,0); le calcul peut être repris à avec [https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/ ce site web]
*Le robot va trop vite pour que la correction soit efficace, il y a franchissement de ligne. De plus il faut prendre en compte que la correction n'a lieu uniquement quand le capteur détecte la ligne. Nous avons donc essayé :
**De '''rajouter un délais''' pour que la correction ait lieu pendant plus longtemps, mais nous avions tout de même des problèmes de franchissement de ligne, toujours dût à la vitesse du robot.
**De '''diminuer la vitesse des roues arrières''' pendant la correction en les passant de 255 à 180. '''Cette méthode est concluante''' et permet une correction de trajectoire même avec un angle d'attaque important. Cet angle va dépendre de la manière dont tourne le robot. Il faut s'assurer qu'il tourne suffisamment pour que la correction soit possible.

Le code comprend :
Un fichier contenant le main : ''suivie_moteur.c'', qui se sert des fonctions définies dans le fichier ''fonctions'' pour initialiser les différents ports GPIO de la carte pico et lancer la boucle infinie avec la fonction de suivie de ligne principale.
Les fichiers fonctions.h et fonctions.c contiennent les éléments suivants :
*Les différentes bibliothèques nécessaires au fonctionnement du code
*Les définitions des différents ports GPIO, un par capteur de ligne et trois par moteur (2 pour le sens : IN1 et IN2 et 1 pour la PWM : ENA)
*La fonction '''setup_capt''' qui initialise les différents ports GPIO, les moteurs dont PWM
*La fonction '''pico_set_led''' qui prend en argument un booléen ''led_on'' et qui permet d'allumer la led de la board pi pico à des fins de débogage.
*La fonction '''setPWM''' qui prend en argument le pin enable d'un moteur et qui fixe la valeur de la PWM par l'argument value qui prend une valeur entre 0 et 255.
*La fonction '''commande_moteur()''' qui ne prend aucun argument et qui est l'algorithme principal de suivie de chemin.

[[Fichier :]]

==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter:
violet: présence d'une intersection
rouge: aller à droite
bleu: aller à gauche
vert: aller à droite ou à gauche
jaune: aller à droite, à gauche ou en avant
orange: impasse

Ces couleurs sont placées sur le labyrinthe comme sur la modélisation suivante:
SIMU

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

code:

REBEQA

2025-05-14T12:59:56Z

Isabelle : /* Suivi de lignes */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Bluetooth

==Gestion de la motorisation des roues==

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png|375px]]

[[Fichier:Shematic.png|375px]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg|375px]]

=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
* Exporter un fichier .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Pour exporter en .stl nous l'avons fait pour modéliser un labyrinthe en 2D. Nous l'importons ensuite sur Webots en utilisant le type transform pour pouvoir utiliser une échelle "scale" car il peut y avoir des problèmes de conversion en les unités de SolidWordks et les unités de Webots. Il n'y a plus de scale sur les types "Solid" depuis une mise à jour.
Sur le transform on ajoute une Shape puis une apparence et une géométrie. nous n'avons pas réussi à avoir les couleurs que nous avions mis sur SolidWorks.
[[Fichier:Webots_menu.png|400px|thumb|center|]]
Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif|400px|center]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===

===Limites et inconvénient de Webots===

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
La piste est bordée de deux lignes noires. La logique de l'algorithme est comme suit :
*le capteur de ligne gauche rencontre une ligne noire -> le robot corrige est va à gauche. Matériellement c'est la roue avant qui tourne. idem pour la droite.

Problèmes rencontrés:
*Les capteurs de lignes doivent être très proches du sol pour pouvoir capter la ligne, il faut donc faire des réglages précis à adapter pour chaque robot.
*La PWM permet de régler la vitesse des moteurs, la clock de la PWM a été choisie à 5kHz part la fonction pwm_set_clkdiv_int_frac(slice_num_M1,98,0); le calcul peut être repris à avec [https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/ ce site web]
*Le robot va trop vite pour que la correction soit efficace, il y a franchissement de ligne. De plus il faut prendre en compte que la correction n'a lieu uniquement quand le capteur détecte la ligne. Nous avons donc essayé :
**De '''rajouter un délais''' pour que la correction ait lieu pendant plus longtemps, mais nous avions tout de même des problèmes de franchissement de ligne, toujours dût à la vitesse du robot.
**De '''diminuer la vitesse des roues arrières''' pendant la correction en les passant de 255 à 180. '''Cette méthode est concluante''' et permet une correction de trajectoire même avec un angle d'attaque important. Cet angle va dépendre de la manière dont tourne le robot. Il faut s'assurer qu'il tourne suffisamment pour que la correction soit possible.

Le code comprend :
Un fichier contenant le main : ''suivie_moteur.c'', qui se sert des fonctions définies dans le fichier ''fonctions'' pour initialiser les différents ports GPIO de la carte pico et lancer la boucle infinie avec la fonction de suivie de ligne principale.
Les fichiers fonctions.h et fonctions.c contiennent les éléments suivants :
*Les différentes bibliothèques nécessaires au fonctionnement du code
*Les définitions des différents ports GPIO, un par capteur de ligne et trois par moteur (2 pour le sens : IN1 et IN2 et 1 pour la PWM : ENA)
*La fonction '''setup_capt''' qui initialise les différents ports GPIO, les moteurs dont PWM
*La fonction '''pico_set_led''' qui prend en argument un booléen ''led_on'' et qui permet d'allumer la led de la board pi pico à des fins de débogage.
*La fonction '''setPWM''' qui prend en argument le pin enable d'un moteur et qui set la valeur de la PWM par l'argument value qui prend une valeur entre 0 et 255

==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter:
violet: présence d'une intersection
rouge: aller à droite
bleu: aller à gauche
vert: aller à droite ou à gauche
jaune: aller à droite, à gauche ou en avant
orange: impasse

Ces couleurs sont placées sur le labyrinthe comme sur la modélisation suivante:
SIMU

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

code:

REBEQA

2025-05-14T11:58:50Z

Isabelle : /* Algorithmes */

=Présentation du sujet=

==Mission générale==
Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin
#D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
#Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
#Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
#Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

==Détail du labyrinthe et des robots==
::- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).
Dimension du labyrinthe à ajouter et de la largeur du chemin
::- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.
::- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth
::- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

=Matériel utilisé=
::- 3 cartes R-Pi Picow
::- 2 capteurs ultrasons : HC-SR04
::- 6 suiveurs de lignes
::- 3 capteurs couleurs RGB
::- 3 batteries
::- 2 pinces dont une avec un détecteur d'objets métallique
::- 2 Module Bluetooth
::- 9 roues
::- 1 objet métallique et 2 objets en bois de couleur

==Pince==
Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

===Servo Moteur===
Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : [[Fichier:Moteur_pince.zip]]

=== Identification de l'objet ===
On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur.
A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

==Capteurs==

===Capteur couleur TCS3200===
:: - lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande
<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.
::- Utilisation d'une carte Arduino UNO pour les tests.
::- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).
::- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).
::- La sortie renvoyée est sous format RGB avec le code choisi
::- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).
::- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.
Code C++ : [[Fichier:capteur_couleur_C.zip]]
===Capteur ultrasons HC-SR04===
::- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée
::- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).
Code Arduino : [[Fichier:capteur_US.zip]]
Code C++ : [[Fichier:capteur_US_C.zip]]
===Capteurs suivi de ligne===
Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf
https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : [[Fichier:Suivi_lignes.zip]]

===Détecteur d'objet métallique===
::- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

===Capteur Optique===

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : [[Fichier:capteuropt.zip]]

===Ensemble des capteurs===

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : [[Fichier:Robot3.zip]]

==Communication==
::-Communication Bluetooth

==Gestion de la motorisation des roues==

==Batteries==

=Fabrication=
==Nouvelle base==

Nous avons fabriquer une nouvelle base holonome en bois en forme de triangle afin d'avoir trois robots similaire. Il en existait déjà deux de cette forme en plexiglas.
Nous n'avons pas trouvé de moteur équivalent aux deux bases en plexiglas (9V), nous avons donc récupéré des moteurs d'un autre robot qui sont en 6V.
Nous avons fabriqué des équerres en métal pour attacher les moteurs.

==Carte Électronique==

Nous avions deux cartes électroniques fonctionnelles sur trois donc nous avons décidé d'en fabriquer une nouvelle afin d'en avoir trois uniforme. De plus, dans le dernier wiki, il nous était conseillé de les refaire car elles commençaient à se faire vieille. Ainsi, nous avons fabriqué une nouvelle carte électronique permettant de contrôler une base holonome pour trois roues ainsi que les différents capteur et actionneurs nous permettant de réaliser nos actions.

La contrainte principale de cette carte a été d'utiliser la carte Raspberry Pico W.

La carte comporte:
::- La carte RaspberryPI Pico W, elle devra piloter les pont en H ainsi que les capteurs et actionneurs.
::- Un TRACO TEN 3-1211N pour convertir la tension d'alimentation de nos batteries (9-18V) en une tension d’alimentation pour la Pico W (5V).
::- Des ponts en H L293D pour contrôler les moteurs, le design est plus compacte que les L298N, cela prendra moins de place sur la PCB.
::- Le module complet permettant d'utiliser le capteur optique (AOP TLC271ACP) qui a été développé lors de l'année précédente.
::- Les sorties pour chacun des capteurs et actionneurs du projet.
::- Un cavalier pour choisir la tension d'alimentation des moteurs (Batterie ou 5V).

Pour chacun des capteurs et actionneurs, on trouve les noms pour les brancher sur la PCB.

De plus, comme nous manquions de pin disponible, le deuxième capteur couleur doit être paramétré manuellement et ne détecte qu'une couleur prédéfini. Il faut sélectionner S0, S1, S2 et S3 (Label : Couleur2_Sel1 sur la PCB) avec les headers de 3.3V et GND qui se trouvent au dessus (Label : 3.3Sel1 et GNDSel1). Par exemple, pour définir S0 à 1, il faut brancher le premier pin de "Couleur2_Sel1" à 3.3V.

Pour réaliser la PCB nous avons réaliser le shématique et le routage sur le logiciel KiCad, voici les fichiers : [[Fichier:Projet_robotique_PCB.zip]]

[[Fichier:Pcb.png]]

[[Fichier:Shematic.png]]

Photo de la carte réalisé et de son prototype de test :

[[Fichier:Prototype_pcb.jpg]]
=Simulation=

==Tutoriels==
===Liens utiles===
*[https://cyberbotics.com/doc/guide/introduction-to-webots Documentation officielle Webots (en anglais)]
*[https://cyberbotics.com/doc/guide/samples-howto#omni_wheels-wbt Le fichier Webots du robot omni_wheels se trouve]
*[https://github.com/KajalGada/Youtube-Tutorial-Download-Material/tree/main/Line%20Follower%20Webots%20Tutorial Un tutoriel pour faire suivre une ligne au robot]
*[https://www.youtube.com/watch?v=D0jhvFZJ5Ok Le tutoriel vidéo en python]
*[https://www.youtube.com/watch?v=KGePGSKZu4w&t=13s en C++]
*[https://cyberbotics.com/doc/reference/menu Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles]

===Installation de Webots===

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

====Pour WSL====

modification à faire dans Windows :

[https://www.youtube.com/watch?v=8wNqOpRRZho INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]]

commande à taper :

[https://learn.microsoft.com/fr-fr/windows/wsl/install Installer WSL 2 | Microsoft Learn]

Installer Webots :

[https://cyberbotics.com/doc/guide/installation-procedure Webots documentation: Installation Procedure]

===Webots===

Une simulation Webots contient au moins ces deux composants :
*Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est ''VRML97''.
*Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en ''C/C++/Java/Python/MATLAB''. Nous utiliserons ''C++''.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le '''controller''' (procédure à refaire à chaque changement de code) :
*Dans le dossier du controller on tape les lignes de commandes
**Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
**make
*Dans webots recharger le monde (CTRL+SHIFT+R)
*Lancer la simulation

Modification d'un '''proto''' :
Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes :
#* Exporter en fichier .wrl et recupérer les coordonnées des points du solide
#* Export un .stl ou un .obj et récupérer directement la forme de notre modèle 3D

===Créer un solide avec des formes originales===
On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide.
Sur Webots, on obtient le code suivant :
<pre>
Solid {
rotation 1 0 0 0
children [
Shape {
appearance PBRAppearance {
baseColor 0 0.8 0
baseColorMap ImageTexture {
}
roughness 0.5
metalness 0
}
geometry IndexedFaceSet {
coord Coordinate {
point [
-0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
]
}
coordIndex [
7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
8, 4, 10, -1, 10, 4, 6, -1
]

}
}
]
}

</pre>

Code pour contrôler notre robot [[Fichier:omnic_cmd.zip]]
Vidéo simulation du suivie de ligne par le robot:
[[Fichier:Test_2_robot capteur infra à l'avant.gif]]

==Conclusion sur la simulation ==
=== Plus valus de la simulation ===

===Limites et inconvénient de Webots===

=Tâches effectuées=
#Réalisation d'un robot complet
#*Fabrication des cartes de commande
#*Fabrication de la base
#Contrôle du fonctionnement des pièces existantes
#* Capteurs
#* 2 robots déjà existants
#Simulation sur Webots
#*
#Réalisation de la pince avec imprimante avec détecteur de métal
#*
==Pi-Pico==
[[Fichier:Tuto_Installation_VSCODIUM.odt]]

==Mécanique==
===Objet===
Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur.
L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement.
Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

===Pince===
Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu.
La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

[[fichier : test]]

===Roue===
Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 .
On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes :
- Hauteur de roue : 40 mm
- Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

=Algorithmes=
==Suivi de lignes==
==Parcours du labyrinthe ==
=== Direction en fonction des couleurs ===
Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter:
violet: présence d'une intersection
rouge: aller à droite
bleu: aller à gauche
vert: aller à droite ou à gauche
jaune: aller à droite, à gauche ou en avant
orange: impasse

Ces couleurs sont placées sur le labyrinthe comme sur la modélisation suivante:
SIMU

=== Parcours d'un arbre ===
Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

code:

Fichier:Omnic cmd.zip

2025-05-12T13:41:20Z

Isabelle : Isabelle a téléversé une nouvelle version de Fichier:Omnic cmd.zip

== Description ==
Code pour la simulation sur webots

REBEQA

2025-05-12T13:36:21Z

Isabelle : /* Webots */

REBEQA

2025-05-12T08:30:14Z

Isabelle : Première semaine de webots

Pilulier connecté

2024-04-05T14:22:14Z

Isabelle :

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
Source : [https://linote.fr/blog/pilulier-connecte/#memobox]
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre proposition==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone. Il sera branché ou sur batterie rechargeable.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Indicateur de charge (bip différencié et affichage d'un message pour mettre en charge l'appareil s'il fonctionne sur batterie)

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier. Alerte batterie faible.
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

==Choix techniques et design==

Deux architectures différentes ont été en débat pour le pilulier :
-Une première, basée sur un pilulier à cases fixes disposées en grille rectangulaire
-Une autre, imaginée comme un distributeur à cases rotatives

=Besoins en matériel=
* Carte électronique (Arduino ?)
* Moteur pas à pas (Pour faire tourner la base du pilulier)
* De quoi quoi détecter quand l'appareil est retourné
* De quoi connecter la carte en Bluetooth
* Ecran, LED, haut-parleurs devront être intégrés au pilulier

==Séance 1==

Présentation orale de l'état de l'art.

==Séance 2==
* Mise à jour de notre schéma de fonctions
* Découverte du matériel Maker Pi pico
* Code pour allumer le led RGB

==Séance 3==
*Discussions sur les différentes manières de réaliser le pilulier:
*Pilulier rectangle ou circulaire ( assez accessible ? )
*Capteurs à chaque cellule ou accéléromètre ( coût )
*Gobelets ou couvercle tournant ?
*Moteur pas a pas : roue de Genève plutôt qu'électronique
* Code pour faire sonner le buzzer
* Choix d'utiliser un accéléromètre -> lecture de la datasheet de l'accéléromètre

==Séance 4==
* Code pour faire fonctionner l'accéléromètre
*Importer les librairies nécessaires
*Coder afin d'obtenir les positions et l'accélération
*Coder pour faire sonner le buzzer lorsque l'accéléromètre est à l'envers.

Pilulier connecté

2024-03-09T16:18:07Z

Isabelle : /* L'application compagnon */

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
Source : [https://linote.fr/blog/pilulier-connecte/#memobox]
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre solution==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone. Il sera branché ou sur batterie rechargeable.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Indicateur de charge (bip différencié et affichage d'un message pour mettre en charge l'appareil s'il fonctionne sur batterie)

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier. Alerte batterie faible.
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

=Besoins en matériel=
* Carte électronique (Arduino ?)
* Moteur pas à pas (Pour faire tourner la base du pilulier)
* De quoi quoi détecter quand l'appareil est retourné
* De quoi connecter la carte en Bluetooth
* Ecran, LED, haut-parleurs devront être intégrés au pilulier

Pilulier connecté

2024-03-09T16:17:43Z

Isabelle : /* Le pilulier */

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
Source : [https://linote.fr/blog/pilulier-connecte/#memobox]
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre solution==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone. Il sera branché ou sur batterie rechargeable.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Indicateur de charge (bip différencié et affichage d'un message pour mettre en charge l'appareil s'il fonctionne sur batterie)

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

=Besoins en matériel=
* Carte électronique (Arduino ?)
* Moteur pas à pas (Pour faire tourner la base du pilulier)
* De quoi quoi détecter quand l'appareil est retourné
* De quoi connecter la carte en Bluetooth
* Ecran, LED, haut-parleurs devront être intégrés au pilulier

Pilulier connecté

2024-03-09T16:16:17Z

Isabelle : /* Notre solution */

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
Source : [https://linote.fr/blog/pilulier-connecte/#memobox]
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre solution==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone. Il sera branché ou sur batterie rechargeable.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Alimentation ?

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

=Besoins en matériel=
* Carte électronique (Arduino ?)
* Moteur pas à pas (Pour faire tourner la base du pilulier)
* De quoi quoi détecter quand l'appareil est retourné
* De quoi connecter la carte en Bluetooth
* Ecran, LED, haut-parleurs devront être intégrés au pilulier

Pilulier connecté

2024-03-09T16:14:12Z

Isabelle : /* Besoins en matériel */

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
Source : [https://linote.fr/blog/pilulier-connecte/#memobox]
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre solution==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Alimentation ?

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

=Besoins en matériel=
* Carte électronique (Arduino ?)
* Moteur pas à pas (Pour faire tourner la base du pilulier)
* De quoi quoi détecter quand l'appareil est retourné
* De quoi connecter la carte en Bluetooth
* Ecran, LED, haut-parleurs devront être intégrés au pilulier

Pilulier connecté

2024-03-09T16:00:21Z

Isabelle :

Objectif du projet : le projet de pilulier connecté rejoint un précédent projet d'étudiants de [[Pharmalog|boite à pharmacie connectée]]. Les solutions techniques et fonctionnalités de Pharmalog peuvent largement inspirer le projet de pilulier. En outre, il est important de réfléchir à une interface utilisateur simple, adaptée au grand public, y compris aux personnes en situation de handicap.
=État de l'art=

L'observance thérapeutique est définie comme la capacité à prendre correctement son traitement (i.e : comme prescrit par le médecin). Dans les pays développés, seuls 50% des personnes atteintes de maladies chroniques respecteraient leur traitement selon l’Organisation Mondiale de la Santé (1). C’est là qu'intervient le projet de pilulier connecté, afin d’aider à la bonne prise de traitements.

==Quelques chiffres==
Chaque année, la non-observance thérapeutique a un coût socio-économique de 9 milliards d'euros par an et est aussi à l’origine de 12 000 décès(2). C’est 1 million de journées d’hospitalisation en raison d’une mauvaise prise de traitement(3).
(1)World Health Organization. Adherence to long-term therapies : Evidence for action. Genève ; WHO : 2003. 211 p.
(2)IMS Health France et le Cercle de réflexion de l'industrie pharmaceutique publiée en 2014
(3)L’observance des traitements : un défi aux politiques de santé. Livre Blanc de la Fondation Concorde, mars 2014

==Piluliers déjà existants==
* '''LiNote''' : permet d’enregistrer des messages qui s’enverront aux horaires définis en se connectant à son compte LiNote à distance afin de rappeler aux personnes âgées de prendre leur médicament. A l’horaire prévu LiNote sonne pour prévenir la personne âgée, la présence de cette dernière sera détectée et ses messages lui seront lu. Il est également possible de s’assurer que la personne a bien lu les messages.
* '''DO-Pill''' : pilulier de 28 compartiments comportant chacun une puce enregistrant les informations sur la prise de médicaments et les transmet à la personne en charge. Le pilulier émet une signal sonore ET lumineux pour attirer l’attention de la personne âgée. Doit généralement être prescrit par un médecin et peut être acheté pour 339€ ou loué pour 15€ par semaine ( services inclus ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine et doit être rechargé ( autonomie de 7 jours ).
* '''Imedipac''' : Pilulier comportant 28 compartiments chacun capable de s’éclairer ainsi qu'émettre un signal sonore en plus d’un message SMS ou appel si désirer afin de prévenir la personne âgée. Il est également possible pour les proches de savoir si les médicaments ont été pris. Peut être acheté pour 299€ ou loué à 29.90€ par mois ( boîtier + système d’alarme ). Ce pilulier est cher et n’est pas remboursé par la Sécurité sociale, doit être rempli par un pharmacien chaque semaine. Vidéo démonstration
* '''Hestec''' : Possède 7 boîtiers pour chaque jour de la semaine, chacun de couleur différente pour aider à les identifier plus facilement et munis de 4 compartiments chacun. Emet un signal sonore lorsqu’il faut prendre les médicaments. Un boîtier tient facilement dans un sac. Ce pilulier est peu cher ( 24,99€ ) et n’est pas remboursé par la Sécurité sociale; doit être rempli par un pharmacien chaque semaine. La sonnerie n’est pas que de 80 dB, dérangeant pour les personnes malentendantes. Les proches ne peuvent pas savoir si les médicaments ont été pris. Les piles s’usent rapidement et le grand nombre de boutons sont petits , inconvénients pour les personnes âgées.
* '''Memobox classique''' : Pilulier équipé de capteurs reliés à une application mobile. Les proches peut suivre la prise de médicaments de la personne âgée et définir le nombre de rappels via l’application. Les rappels font clignoter et/ou sonner le pilulier. Il est également possible de faire sonner le téléphone de la personne âgée. Capable de bloquer certains compartiments pour éviter que le même médicament soit pris 2 fois. Possibilité de personnaliser la prise de médicaments jour après jour grâce à des boîtiers interchangeables pouvant être composés de 2 ou 4 compartiments. Peut être acheté pour 79.85€ et n’est pas remboursé par la Sécurité sociale. Doit être rechargé.

==Notre solution==
Pilulier circulaire connecté en Bluetooth à une appli sur smartphone.

===Le pilulier===
*Couvercle sécurisé (ne doit pas être ouvert par accident) pour déposer les médicaments.
*21 alvéoles (une semaine de prise matin midi et soir), labels au fond/sur les bords pour indiquer le jour et le temps de la prise
*Alerter (de manière et sonore et visuelle) quand il est l’heure de prendre les médicaments
*La pièce compartiment (voir schéma) tourne pour placer l’alvéole qui contient les médicaments sous l’ouverture dans le couvercle
*Doit être renversé pour “détecter” la prise (bip de confirmation)
*Ecran affichant l'heure / un message (exemple : "prise du midi" etc...)
*Alimentation ?

===L'application compagnon===
*Envoyer un message d’alerte sur le téléphone (notification, mail, sms ?) après un certain temps de non prise (à l’utilisateur et/ou à sa personne aidante). Peut être doublé d'une alerte intermédiaire : alerte plus insistante sur le pilulier
*Configurer les heures de prises
*Rentrer les contacts des personnes à alerter
*Informations sur les médicaments contenus dans le pilulier

=Besoins en matériel=
* Carte Arduino
* Moteur pas à pas