Présentation du projet

Contexte

Pour notre étude, nous avons d’abord établi une analyse des besoins de notre projet. Après recherche, nous avons découvert, qu’en France, près de 68 Milliards de cigarettes étaient fumés par an. Et parmi ces 68 Milliards, on estime à 40 Milliards de mégots jetés au sol. Comme un exemple sera beaucoup plus parlant, prenons l’exemple d’un défi réalisé par 230 participants aux Champs-Elysées. Pour sensibiliser sur le nombre de mégots jetés aux Champs-Elysées, 230 bénévoles se sont mis pour défis de ramasser pendant 1h30 tous les mégots qu’ils trouvaient sur leurs chemins. Une fois ramassés, ils ont compté un total d’environ 100000 mégots. Et ça, ce n’est qu’à l'échelle des Champs-Elysées. A partir de là, on peut s’imaginer la quantité de mégots qui se trouve actuellement sur le sol de nos villes. Nous avons donc pour projet de créer un robot autonome capable de se déplacer vers le mégot et de le ramasser en le disposant dans un récipient La somme nécessaire au ramassage des mégots est de 80.000.000 euros, selon le ministère de la Transition écologique et solidaire. Lors de la première année de sa mise en œuvre, les usines de production de cigarettes ont alloué 10.000.000 euros. L’an suivant, ce montant sera doublé. La collecte de ces sommes d’argent est dans le cadre de l’application de la loi sortie en février 2020. Cette dernière stipule que le fabricant est garant de ses produits jusqu’à leur fin de vie. Toutefois, il faut attendre l’année 2023 pour que les cigarettiers financent en totalité ces ramassages de mégots. Le coût du ramassage des mégots varie suivant la superficie de la localité. Les agglomérations rurales dont la population n’excède pas les 5.000 habitants, il est de 0,50 euro. Les municipalités ne dépassant pas 50.000 habitants perçoivent 1,08 euro par personne. Tandis que dans les communes ayant une population supérieure à 50.000 habitants, ce montant est de 2,08 euros. Il s’agit de la responsabilité élargie des producteurs. Les cigarettiers doivent alors prendre leurs mesures de manière à ce que les mégots soient recyclés. Très polluantes, ces substances prennent beaucoup de temps pour se décomposer à cause de leurs composants en plastiques.

Objectifs

Notre projet consiste à concevoir et à mettre en place un système mobile autonome (volant ou roulant) permettant la collecte de déchets (initialement de mégots) sur le campus grâce à de la reconnaissance d’image. Ce dossier va vous présenter nos pistes de recherches et de développement ainsi que notre organisation pour mener à bien ce projet. Nous avons décidé de nommer notre robot : “Trashy” (en référence au mot angais Trash).

Pour mener à bien ce projet, nous avons mis en place un Google Drive pour organiser notre travail pendant la période de recherche et d’étude de ce projet. Durant ce semestre, nous avons donc consacré notre temps aux phases de pré-étude et d’étude du projet, ainsi qu’à la réalisation du cahier des charges nous permettant de mieux continuer le projet pour les semestres à venir.

Description

Nous avons donc déterminé les fonctions contraintes du robot qu’il doit pouvoir réaliser telle la détection des mégots ou encore la contrainte de devoir évoluer sur tout type de terrain. Et c’est ainsi, et après concertation avec tous les membres du projets, que nous avons écrit le cahier des charges suivants : Le robot devra rouler à une vitesse de 4km/h et devra être capable de passer sur des obstacles de 2cm maximum. De plus, lorsque le robot détecte un obstacle qu’il ne peut peut franchir, il doit s’arrêter et le contourner. Enfin, en cas d’obstacle dangereux, le robot devra émettre un son. Lorsque le robot détecte un déchet, il doit l’attraper à l’aide de ses pinces puis le mettre dans son réceptacle. Si le réservoir est plein, ou si la maximale que le robot peut transporter est atteinte, le robot devra partir vers une station de déchargement (faite par le client, hors du cadre de notre projet) pour se vider. De plus, lorsque le robot ramasse un déchet, il devra cartographier ce déchet afin de connaître les zones les plus polluées. A noter que le robot ne fait pas le tri des déchets. La position du robot doit être connue en temps réel afin d’analyser les données du parcours et le robot devra connaître son orientation à l’aide de son gyroscope. Le robot doit avoir une autonomie de 8h et doit pouvoir repartir vers la station de charge si sa batterie devient faible. Les bras du robot sont en caoutchouc pour plus d’adhérence et sa trappe (de 41L) est concave afin d’éviter que les déchets ne se coincent. Le robot doit être capable d’évoluer dans des terrains semi-accidentés et de monter un trottoir. En cas d’urgence, le robot doit immédiatement s’arrêter.

C’est ainsi qu’après réflexions et brainstorming entre les membres du groupe, nous avons trouvé les premières solutions et design de Trashy. Ainsi, nous allons concevoir une carte mère adaptée au robot permettant toutes les fonctionnalités décrites ci-dessus. Nous allons donc avoir recours à un processeur ATMEGA 2560 en communication avec une Raspberry PI. La Raspberry est là pour les traitements des capteurs plus gourmands (dont l’analyse d’image de la caméra) que l’arduino ne peut faire.

Réalisation et résultats

Matériel à disposition

Base du Robot
Pince du Robot
Raspberry

Pour pouvoir mettre en œuvre notre projet, nous avons à disposition une plateforme mobile avec 4 roues omnidirectionnelle et contrôlé par une Raspberry PI 3 model B+ ainsi qu'une Arduino Mega 2560. Nous disposons aussi d'un kit de robot Pince. Afin de pouvoir gérer efficacement la partie intelligence artificielle, Mr Othman Lakhal nous a prêté une Nvidia Jetson Nano

Principe de fonctionnement de Trashy

Interconnexions entres les différents éléments

Afin de mieux nous organiser durant ce projet, nous avons établis le schéma d'interconnexions et la fonctions de chacun des composants que l'on dispose. Ainsi :

Nvidia Jetson Nano : Gère la reconnaissance des mégots de cigarette et envoie à la Raspberry, via liaison série, les coordonnées du mégot de cigarette sur l'image
Raspberry PI3 Model B+ : Asservis en position le robot pour que le mégot de cigarette soit au centre de l'image et demande, via une liaison série avec l'arduino, l'activation de la pince
Arduino Mega 2560 : Gère le contrôle de la pince

Mise en place des mouvements de la pince

Pour cette partie, nous utilisons la bibliothèque <Servo.h> permettant de contrôler les servo-moteurs de notre pince. Nous en disposons de 4 que nous déclarons avec les lignes de codes ci-dessous :

 Servo base, claw, up_down, front_back;

 void setup() {
   up_down.attach(22);
   base.attach(24);
   claw.attach(26);
   front_back.attach(28);
   init_servo();  
   Serial.begin(9600);
 }

Pour les contrôler, nous avons une fonction générique qui prend en paramètre le servo-moteur à actionner ainsi que l'angle de départ et l'angle d'arriver :

 void to_move(Servo obj, int start_angle, int stop_angle){
   /* Ce programme permet de contrôler les servo-moteurs de la pince de Trashy
    *  
    * Liste des paramètres :
    * :Servo obj: Servo-moteur à actionner
    * :int start_angle: Angle de départ
    * :int stop_angle: Angle d'arrivée
    * 
    * CU : Avoir les servo-moteurs branché aux bons ports
    *  claw prend des angles de 0 à 95°
    *  Les autres de 0 à 180°
    * 
    * Exemple
    *  to_move(claw,0,95); pour ouvrir la pince
    *  to_move(claw,95,0); pour fermer la pince
    *  to_move(front_back,180,0); pour rculr la pince
    *  to_move(front_back,0,180); pour avancer la pince
    *  to_move(up_down,180,0); pour baisser la pince
    *  to_move(up_down,0,180); pour monter la pince
    *  to_move(base,0,180); pour emmener la pince vers le depos
    *  to_move(base,180,0); pour ramener la pince devant
    */
   if(start_angle < stop_angle){
     for(angle = start_angle; angle < stop_angle; angle += 1){
       obj.write(angle);
       delay(step_time); //step_time = 15
     }
   }else{
     for(angle = start_angle; angle >= stop_angle; angle -= 1){
       obj.write(angle);
       delay(step_time); //step_time = 15
     }
   }
   delay(100);
 }

Algorithme du bac

 int lightPin = 0;  
 int ledPin1 = 9; 
 int ledPin2 = 10;
 int bref =0;
 int loong=0;
 void setup(){
     pinMode (ledPin1, OUTPUT);
     pinMode (ledPin2, OUTPUT);
     Serial.begin(9600);
 } 
 void loop(){
     int seuil = 850;   
     bref=(analogRead(lightPin)< seuil) ;
     delay(20);
     loong=(analogRead(lightPin)< seuil);
     if(bref==1 && loong==1){
         digitalWrite(ledPin1, HIGH);
         delay(1000);
     }else if(bref==1 && loong==0){
         digitalWrite(ledPin2, HIGH); 
         delay(1000);
     }else{
       digitalWrite(ledPin2, LOW);
       digitalWrite(ledPin1, LOW);  
     }
 }

Algorithme de détection de mégots de cigarette

Pour l'algorithme de détection de mégots de cigarette, nous avons à notre disposition une Nvidia Jetson Nano. Afin de mieux comprendre comment tout ceci marche, nous nous sommes inspirés des vidéos ci-dessous (toute provenant de la chaine youtube Nvidia Developper) :

Real-Time Object Detection in 10 Lines of Python Code on Jetson Nano : https://www.youtube.com/watch?v=bcM5AQSAzUY
Jetson AI Fundamentals Playlist : https://www.youtube.com/playlist?list=PL5B692fm6--uQRRDTPsJDp4o0xbzkoyf8
Training our own model : https://www.youtube.com/watch?v=sN6aT9TpltU&list=PL5B692fm6--uQRRDTPsJDp4o0xbzkoyf8&index=11 (19:07)

Nous nous inspirons aussi du dépôt git associé : https://github.com/dusty-nv/jetson-inference

Nous allons donc créer un modèle permettant à la Nvidia de détecter les mégots de cigarette et les cigarettes. Pour ceci, nous allons avoir besoin de données répertoriés dans 3 dossier :

train : Ce sont les données qui vont entrainer notre modèle
test : Ce sont les données qui vont tester notre modèle
val : Ce sont les données qui vont valider notre modèle

Afin d'entrainer notre modèle, nous allons simplement parcourir l'ensemble des données. 1 parcours de toute les données est appelé un epoch. Pour avoir un modèle fiable à 80% (avec 5000 données), il est conseillé d'utiliser entre 30 et 60 epochs.

Rapport d'avancement 1 (25/01/2023)

Le premier obstacle rencontré dans la réalisation de l'IA est la connexion à internet de la Nvidia Jetson Nano pour pouvoir cloner le dépôt git nous permettant de créer nos premiers IA. Nous avons donc procédé à différentes solutions pour combler à cette obstacle :

Solution 1 : Utilisation d'une clé WiFi relié en USB à la carte. Mr Lakhal (notre tuteur de projet) nous avait prêtés une clé Wifi mais malheureusement, le logiciel permettant la configuration n'est pas compatible sous Linux (OS de la Nvidia). Une solution possible était de passer par Wine qui permet sous Linux d'exécuter un .exe mais sans Internet, impossible de l'installer. Nous sommes donc en train d'essayer avec d'autres clé WiFi
Solution 2 : Téléchargement des fichiers du Git sur un PC personnelle que l'on va transférer ensuite à la carte. Le problème de cette solution est que les programmes disponibles sur le dépôt Git ont besoin d'Internet pour fonctionner

Nous allons donc commencer à développer l'IA sur un PC personnelle puis migré le tout lorsque nous aurons trouvé une solution pour relier la Nvidia à Internet.

Nous commençons donc par cloner le git associé sur notre PC :

jasondelannoy@Zeus : /trashy/Image_recognition/IA/jetson-inference$ git clone https://github.com/dusty-nv/jetson-inference.git

Ensuite, nous installons les modèles et fichiers nécessaire dans le dossier créer suite au clonage et démarrons le conteneur docker avec la commande :

jasondelannoy@Zeus : /trashy/Image_recognition/IA/jetson-inference$ docker/run.sh

Un autre obstacle rencontré est l'incapacité de WSL 2 (le client Ubuntu de chez Windows) d'accéder aux ports USB et donc à la caméra branché. Les principaux tests ne peuvent donc pas être fait via WSL sur notre machine personnelle. Une première solution pour régler ce problème serait de passer par une machine virtuel. Pour tester, nous utilisons une machine virtuelle sous Ubuntu 22.04 grâce à VirtualBox mais après configuration, la VM a bien accès à mes ports USB cependant lorsque nous voulons connecter la caméra à la VM, une erreur apparait et il est impossible de l'utiliser dans la VM. Nous devons donc rapidement résoudre le problème d'internet de la Nvidia Une solution trouvé mais à tester serait de branché la Nvidia via Ethernet à ma box internet et de me SSH depuis Polytech pour bosser sur la Nvidia depuis mon PC personnel.

Du à une impossibilité de se connecter en Ethernet à l'école, le développement de l'IA se fera depuis chez Jason sur son temps libre

Rapport d'avancement 2 (08/02/2023)

Lors de cette séance, nous avons d'abord continuer de travailler sur la Nvidia Jetson Nano. Nous commençons donc par cloner le git associé sur notre PC :

dlinano@dlinano : /trashy/Image_recognition/IA$ git clone https://github.com/dusty-nv/jetson-inference.git

Et une fois le dépôt git cloné sur notre PC, nous commençons l'installation du docker via la commande :

dlinano@dlinano : /trashy/Image_recognition/IA/jetson-inference$ docker/run.sh

Cependant, l'installation ne marche pas sur la Nvidia Jetson Nano. Après quelques recherches et lecture sur le git associé, nous avons remarqué que la Nvidia Jetson Nano que nous possédons n'est pas sur le bon OS. Le problème pourrait être réglé en changeant l'OS mais comme la carte est celle personnelle du prof, nous attendons son accord pour le faire.

Pendant ce temps, nous avons travaillé sur des alternatives pour pouvoir produire une première version pour notre preuve de conception. Nous d'abord essayé une version où l'ordinateur reconnaitrait les objets orange afin de mieux voir les mégots de cigarette. Nous avons ensuite continué nos recherches pour trouver d'autres alternatives

Alternative 1

La première alternative est de mettre en valeur les objets oranges reconnue par la caméra. Pour ça, nous utilisons la librairie OpenCV de Python. Tout d'abord, nous récupérons les images de la caméra puis nous créons un masque pour récupérer seulement les objets oranges. Puis nous comparons l'image initiale avec le masque. Voici le code :

# capture.py
import numpy as np
import cv2

# Capture video from camera
cap = cv2.VideoCapture(0)



while(cap.isOpened()):
    # Capture frame-by-frame
    ret, frame = cap.read()

    # Our operations on the frame come here
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    light_orange = (0,90,200)
    dark_orange = (18,255,255)  

    #Creation of the mask to separate the orange object
    mask = cv2.inRange(hsv, light_orange, dark_orange)

    #Creation of the image by comparing the initial frame with the mask
    res = cv2.bitwise_and(frame,frame, mask= mask)


    # Display the resulting frame
    cv2.imshow('frame',frame)
    cv2.imshow('mask',mask)
    cv2.imshow('res',res)
    k = cv2.waitKey(5) & 0xFF
    if k == 27:
        break

# When everything done, release the capture
cap.release()

cv2.destroyAllWindows()

Nous obtenons les résultat suivant (le premier avec un T-Shirt orange et le 2eme avec un bouchon d'oreille orange) :

Alternative 2

En parallèle, nous avons continué nos recherches sur d'autres alternatives d'IA pour reconnaitre les mégots de cigarette et nous avons trouvé un dataset complet comportant 2300 images pour entraîner notre modèles ainsi qu'un blog comportant le travail ainsi que les résultats d'une personnes ayant fait un IA de reconnaissance de mégot de cigarette :

Nous allons donc pouvoir utiliser ce blog pour confectionner notre modèle.

Carte Driver Moteur

Etant donné qu'un des composants de la carte du robot d'origine à brulé suite à une erreur de câblage, nous avons reçu du groupe : Coupe de France de Robotique, une carte driver moteur qui sert à alimenter les moteurs en puissance car la carte Raspberry ne pourrait pas fournir à elle seule suffisamment de courant. La carte présentait un défaut de conception et grâce aux conseils avisés de son créateur (Albin Mouton), nous avons soudé une résistance entre les pins de deux autres résistances de la carte.

Nous avons ensuite mis les moteurs sur les pins de la carte en ayant serti les câbles au préalable.

Nous avons ensuite téléversé le code fourni par Albin Mouton sur la carte afin de la programmer par défaut (localisation des moteurs, valeurs des PIDs...) grâce au logiciel STM32 Cube IDE

Programmation de la Raspberry Pi 4

Nous avons débuté par l'installation de ROS. ROS n'est supporté que par des OS Ubuntu. Pour pouvoir déterminer quelle est la distribution de notre OS, nous utilisons la commande cat /etc/os-release. Nous avons donc dû changer l'OS de notre Raspberry pour Ubuntu MATE 22.04.

Malheureusement ROS1 n'étant pas supporté par la version 22.04, nous avons décidé de télécharger ROS2 à la place. Pour se faire, nous avons suivi à la lettre le guide suivant : https://docs.ros.org/en/humble/Installation/Ubuntu-Install-Debians.html

Nous souhaitons utiliser ROS afin de pouvoir transmettre des messages entre l'IA et les moteurs/la pince. Nous avons donc créer un nœud ROS afin de pouvoir définir la vitesse de chaque moteur depuis un message.

Bilan

Dans cette partie, vous retrouverez nos rapports de projet pour chaque semestre :

Semestre 6 : Fichier:Rapport Trashy S6.pdf
Semestre 7 : Fichier:Rapport Trashy S7.pdf
Semestre 8 : File Loading

Gestion de projet

Semestre 7

Diagramme de Gantt prévisionnelle du Semestre 7

Lorsque nous avons commencé le semestre 7, nous avons fait le point sur les tâches à faire et nous les avons répartie entre nous et dans le temps. Ainsi, nous devions faire les tâches suivantes :

Modélisation du bac de récupération :

       * Prévu par : Gabriel
       * Fait par : Jason
       * Etat : Fini (au 28/12/2022)

Déplacement de la pince :

       * Prévu par : Gabriel
       * Fait par : Gabriel
       * Etat : Fini (au 28/12/2022)

Capteur du bac :

       * Prévu par : Vianney
       * Fait par : Vianney
       * Etat : Fini (au 28/12/2022)

IA de reconnaissance de mégots :

       * Prévu par : Jason
       * Fait par : Jason
       * Etat : En cours (au 28/12/2022)

Contrôle moteur du robot :

       * Prévu par : Vianney et Jason
       * Fait par : Vianney et Gabriel
       * Etat : En cours (au 28/12/2022)

Liaison de tout les programmes :

       * Prévu par : Tout le monde
       * Etat : Pas commencé (au 28/12/2022)
       * Raison : Retard sur l'IA et le contrôle moteur

Préparation de la soutenance :

       * Prévu par : Tout le monde
       * Fait par : Tout le monde
       * Etat : En cours (au 28/12/2022)

Semestre 8

Diagramme de Gantt prévisionnelle du Semestre 8

Nous avons ensuite organisé le travail pour le semestre 8 en réalisant le diagramme de Gantt ci-contre. Ainsi, nous devions faire les tâches suivantes :

Contrôle moteur :

       * Prévu par : Gabriel + Vianney
       * Fait par : Gabriel + Vianney
       * Etat : En cours

Liaison entre moteur et pince :

       * Prévu par : Gabriel + Vianney
       * Fait par : 
       * Etat :

IA de reconnaissance de mégots :

       * Prévu par : Jason
       * Fait par : Jason
       * Etat : En cours

Liaison entre moteur et IA :

       * Prévu par : Jason
       * Fait par : 
       * Etat :

Liaison de tout les programmes :

       * Prévu par : Tout le monde
       * Etat :
       * Raison :

Réglage des derniers paramètres :

       * Prévu par : Tout le monde
       * Etat :
       * Raison :

Préparation de la soutenance :

       * Prévu par : Tout le monde
       * Fait par : 
       * Etat :

Chronologie et rapport de scéances

Semestre S6

Mars

Mardi 1er Mars 2022 :

Découverte du cahier des charges
Définition du sujet
Mis en place des outils pour faciliter le travail de groupe
Commencement de la réalisation de l’analyse fonctionnelle (diagramme bête à corne et diagramme des interacteurs)
Etude de marché
Recherche des premières solutions
Problématique : Faisabilité niveau loi (les normes à respecter/ ce qu’on peut faire et peut pas faire)

Mardi 8 Mars 2022 :

Etude de faisabilité
Commencement de l’étude d’opportunité (diagramme SWOT)
Définition des premières idées pour la conception du robot
Commencement de l’analyse des risques
Problématique : Difficulté pour faire l’analyse des risques financiers

Mardi 15 Mars 2022 :

Définir l’organisation du projet
Cahier des charges fonctionnel/technique a définir
Brainstorming sur l’analyse SWOT et la solution du robot suite à un entretien avec notre prof d’économie
Finition de l’analyse SWOT
Finition de l’étude d’opportunité
Analyse des risques technologiques

Mardi 22 Mars 2022 :

Commencement du cahier des charges fonctionnelles et techniques
Diagramme fonctionnelle
Recherche des premiers composants
Définition des caractéristiques du robot

Mardi 29 Mars 2022 :

Définitions des risques techniques et des solutions envisagés
Dimensionnement des principaux moteurs
Commencement des recherches pour la carte mère
Recherche des premiers composants
Recherche d'un modèle de diagramme de Gantt pour l’organisation du projet

Avril

Mardi 5 Avril 2022 :

Commencement du diagramme Gantt
Etude de marché
Finitions des études en cours

Mardi 26 Avril 2022 :

Commencement et avancée du diapo de présentation
Commencement de l'écriture du script de la vidéo de présentation
Concertation en groupe sur le design et l'aspect technique du robot

Mai

Mardi 3 Mai 2022 :

Commencement de la carte mère du robot
Poursuite de l’écriture de la vidéo “Ma thèse en 180s”
Finalisation des derniers détails pour certaines parties
Création d’un doc sur les questions fréquemment posées (jury)
Choix d’un logo
Design sur papier du robot avec mesures

Semestre S7

Octobre

Lundi 10 octobre 2022: Personnes présentes : Gabriel - Vianney - Jason

Mise en place du wiki
Réception du robot et des pinces sur lequel nous allons travailler
Organisation du Semestre et des tâches à faire

Vendredi 21 octobre 2022: Personnes présentes : Gabriel - Vianney - Jason

Commencement de l'algorithme de détection d'objet
Recherche de solution pour optimiser la détection d'objet
Construction et débat sur le bac de remplissage

Vendredi 28 octobre 2022: Personnes présentes : Gabriel - Vianney - Jason

Modélisation du support pour la pince et le bac de remplissage
Lancement de son impression
Programmation des mouvements de la pince

Novembre

Vendredi 18 Novembre 2022: Personnes présentes : Gabriel - Vianney - Jason

Réparation des servomoteurs de la pince
Finition de l'algorithme de contrôle de la pince
Recherche sur l'IA
Installation du laser et de la photo résistance

Lundi 21 Novembre 2022: Personnes présentes : Gabriel - Vianney - Jason

Finition sur l'algorithme de contrôle de pince
Commencent des programmes de contrôle moteur
Continuation sur l'IA
Création d'un Git pour le projet

Vendredi 25 Novembre 2022: Personnes présentes : Gabriel - Vianney - Jason

Continuation des programmes de contrôle moteur
Contrôle de la Raspberry
Continuation sur l'IA

Lundi 28 Novembre 2022: Personnes présentes : Gabriel - Vianney - Jason

Schéma d'interconnexion et des tâches de chaque module du robot
Mise à jour du Wiki et du Git
Connexion de la Raspberry

Décembre

Jeudi 8 Décembre 2022: Personnes présentes : Gabriel - Vianney - Jason

Programmation et gestion des capteurs
Paramétrage des Raspberry
Collecte de mégot de cigarette pour la base d'image pour l'IA
Commencement des soutenances et présentation

Jeudi 15 Décembre 2022: Personnes présentes : Gabriel - Vianney - Jason(depuis chez lui)

Programmation de l'IA
Téléchargements et appropriations des librairies
Démarrage de l'algorithme de commande des moteurs

https://github.com/3sigma?tab=repositories

Semestre S8

Janvier

Mercredi 18 Janvier 2023: Personnes présentes : Gabriel - Vianney - Jason

Reprogrammation de l'algorithme de la pince
Continuation sur le contrôle moteur

Problème rencontré : Le robot a cramé

Mercredi 25 Janvier 2023: Personnes présentes : Gabriel - Vianney - Jason

Connexion de la Nvidia à Internet
Changement de la carte pour le robot
Réparation de la carte

Février

Mercredi 1 Février 2023: Personnes présentes : Gabriel - Vianney - Jason

Adaptation des moteurs disponibles à la carte de contrôle moteur prêtée par Albin
Routage d'une carte de remplacement pour le robot
Continuation sur la partie Software du contrôle moteur (Raspberry et ROS)

Mercredi 8 Février 2023: Personnes présentes : Gabriel - Vianney - Jason (de chez lui)

Continuation de l'IA
Programmation d'alternative à l'IA
Découverte d'un blog contenant un dataset pour une IA de reconnaissance de mégot de cigarette
Mise en place des moteurs sur la carte d'Albin
Remontage du robot d'origine
Installation d'un nouvel OS sur la Raspberry
Installation de ROS 2

IMA3/IMA4 2021/2023 P6

Sommaire