IMA3/IMA4 2020/2022 P7 : Différence entre versions

De Wiki de Projets IMA
(→‎Gestion de l'énergie (Panneau Solaire))
(→‎Amélioration du modèle de mangeoire)
 
(12 révisions intermédiaires par le même utilisateur non affichées)
Ligne 153 : Ligne 153 :
  
 
C’était la première fois que nous apprenions à faire du deep learning. Nous avons tout d’abord fait des recherches afin de comprendre comment cela fonctionne et comment apprendre à notre modèle à faire de la reconnaissance aviaire. Pour réaliser l’entraînement de IA nous avons codé un programme en python avec les librairies TensorFlow et keras. Ci-dessous notre programme qui s’inspire d’un code existant provenant de la chaîne youtube TensorFlow. Nous allons maintenant l’expliquer.
 
C’était la première fois que nous apprenions à faire du deep learning. Nous avons tout d’abord fait des recherches afin de comprendre comment cela fonctionne et comment apprendre à notre modèle à faire de la reconnaissance aviaire. Pour réaliser l’entraînement de IA nous avons codé un programme en python avec les librairies TensorFlow et keras. Ci-dessous notre programme qui s’inspire d’un code existant provenant de la chaîne youtube TensorFlow. Nous allons maintenant l’expliquer.
 +
 +
Nous allons créer des images pour l’apprentissage et la validation à partir de la dataset téléchargées. Puis nous créons des générateurs d’entraînement et de validation qui permettent de créer des données d’apprentissage et de validation.
 +
 +
Ensuite, nous définissons nos réseaux neuronaux.  Comme nous avons des images complexes et volumineuses, nous avons plusieurs couches de neurones afin de bien traiter les images et d’obtenir de meilleurs résultats lors de la reconnaissance des oiseaux. Nous utilisons pour l’entraînement des images de 150 par 150. et nous avons à une sortie de 65 neurones correspondant aux 65 espèces apprises par le modèle. Nous pouvons voir dans le sequencial que nous avons 4 couches de convolution. Nous lui fournissons une image en entrée et lui demandons de créer 65 et 128 filtres pour chaque image. Puis, à chaque entraînement il va déterminer les meilleurs filtres pour associer au mieux les images aux étiquettes voulues. Ces couches de convolutions étant empiler les unes sur les autres permettent d’améliorer l'apprentissage des caractéristiques de chaque espèce. Nous allons ensuite compiler ce modèle et lui faire effectuer 200 entraînements afin d’avoir un taux de réussite élevé.
 +
 +
Pour l’instant notre modèle n’est pas encore implémenté dans le programme de la mangeoire connecté. Nous voulons d'abord obtenir le meilleur modèle possible. Afin de tester notre modèle, nous utilisons un programme dont une partie sera utilisée dans le programme de la mangeoire.
 +
 +
Nous appelons notre modèle, ainsi que l’image que nous voulons tester. Puis nous utilisons la fonction predict() de notre modèle et nous affichons le résultat. Nous devrons ensuite parcourir ce tableau afin de trouver l’espèce prédit pour récupérer son nom.
 +
 +
== Amélioration du modèle de mangeoire ==
 +
 +
Après avoir bien analysé notre besoin, nous avons décidé de modifier plusieurs choses dans la conception de notre mangeoire connectée.
 +
Premièrement la disposition des capteurs :  nous avons décidé de mettre le capteur de présence IR dans le toit de notre mangeoire car ce sera plus simple pour détecter tout oiseau entrant au niveau de l’avant de la mangeoire. Les capteurs de force situés sous le réservoir de graines, ainsi que celui permettant de peser les oiseaux ont été enlevés de la maquette par simplification de fonctionnement et de réalisation.
 +
Maquette 3D sur Fusion 360
 +
Nous avons décidé de modifier la taille de notre mangeoire car elle était bien trop grande par rapport aux oiseaux typiques de notre région. De plus, nous avons également repensé le toit de notre mangeoire pour pouvoir y insérer un panneau solaire nous avons donc un côté du toit beaucoup plus grand que l’autre pour pouvoir y poser un panneau solaire.
 +
Dans la partie réservée aux composants, nous allons réaliser des fixations pour que chaque carte (Arduino et Raspberry) ainsi que la batterie, pour qu’elles aient leur place respective pour simplifier les branchements.
 +
En ce qui concerne les verseurs de nourriture et d’eau nous avons gardé le même principe (jsp ce qu’on dit vu qu’on ne l’a pas fait)
 +
 +
 +
Pour ce faire, nous avons réalisé une nouvelle modélisation 3D sur le logiciel « FUSION 360 » en faisant toujours attention à l’emplacement des capteurs et des réservoirs de nourriture.
 +
 +
 +
1. Dimensionnement
 +
 +
Comme dit précédemment, nous avons décidé de réduire très largement la taille de la mangeoire. En effet, nous sommes passés d’une base mesurant 50 cm x 40 cm à une base mesurant 30 cm x 25 cm. De même, en ce qui concerne la hauteur qui n’est plus de 33 cm mais de 21 cm sans la hauteur du toit et 26 cm en considérant le toit.
 +
Le toit à également dû être modifié mais lui a été agrandi. Nous avons pris la décision de réaliser un pan qui mesure précisément la taille du panneau solaire qui permettra d’alimenter tous nos composants. Ce panneau solaire mesure 35.5 cm x 26 cm.
 +
Ces réductions de dimensions ne changent que l’espace de stockage des graines et de l’eau car nous avions calculé l’espace nécessaire pour le rangement de nos composants à l’arrière de la mangeoire.
 +
 +
2. Réalisation d’une maquette en carton à taille réelle
 +
 +
L’utilisation de bois et de plexiglas nous permettra de réaliser la mangeoire finale. Pour réaliser le prototype, nous avons choisi d’utiliser du carton, diminuant les frais.
 +
Contrairement à l’année passée, nous avons utilisé le logiciel InkScape pour réaliser des modèles 2D de chacune des planches constituant notre mangeoire. Ce logiciel nous a permis d’envoyer directement les schémas sur l’imprimante laser. Les découpes sont donc plus nettes et nous avons également utilisé le principe d’encoches pour fixer les planches entre elles. L’utilisation de scotch a été nécessaire pour assurer la fixation et le maintien.
 +
 +
Nous avons donc réalisé deux “feuilles” InkScape, l’une nous permettant de découper le toit en trois parties et une autre pour découper toutes les parties du cube principal
 +
Pour la découpeuse laser, nous avons utilisé un système de couleur (bleu et vert) permettant de donner l’ordre à la découpeuse de d’abord découper la couleur bleu (les contours) avant de découper les encoches (en vert).
 +
 +
Par la suite, nous avons rassemblé toutes les parties en respectant un ordre et un sens bien précis nous permettant de fixer au fur et à mesure. L’assemblage s’est réalisé correctement car les dimensions ont été respectées et les encoches correspondaient parfaitement.
 +
Seul souci concernant certaines planches pour lesquelles nous avions pris en compte l’épaisseur d’une planche de bois (environ 1 cm d’épaisseur) pour au final utiliser du carton (3 mm d’épaisseur).
 +
 +
=Travail effectué au S8=
 +
 +
==Autonomie de la mangeoire avec Arduino==
 +
 +
Gestion de l’énergie
 +
 +
L’une des plus grosses problématiques de notre projet est la gestion d'énergie,
 +
c’est pourquoi nous sommes passés sur un Arduino nano car l’Arduino nano consomme
 +
moins d'énergie, elle est également plus petite et moins chère. Nous avons donc
 +
comparé l'impact de nos programmes sur la consommation de l’Arduino.
 +
Dans un premier temps, nous avons testé notre programme du semestre
 +
précédent avec une boucle loop qui teste si un oiseau est arrivé toutes les secondes.
 +
Pour mesurer la consommation nous avons tout d’abord acheter un mini
 +
multimètre USB mais qui malheureusement ne fonctionne pas sur les Arduino nano car
 +
la consommation est trop faible.
 +
 +
Nous avons donc placé une résistance entre le 5v de sortie du RaspBerry et le
 +
Vin d’entrée de l’Arduino avec la loi d’Ohm U=RI et une résistance de 102 ohms. On
 +
obtient une tension à ces bornes de 1.430 V soit un courant I =0.0137A et une puissance
 +
P=0.0685W. Avec le code précédent en mode « sleep » on obtient 1.1V soit I=0.010
 +
P=0.05W/h.
 +
 +
Nous avons aussi eu l’idée, pour réduire au maximum la consommation, d’utiliser
 +
un transistor pour couper l’alimentation des différents modules sauf le PIR, car il
 +
consomme toujours le même courant. Cette fois-ci, en mode « sleep », en coupant leurs
 +
alimentations on obtient une tension de 0.9V, soit 0.00882 A et donc P= 0.04W/h.
 +
Grâce à ces tests avec le « sleep » mode que nous avons implémenté, nous
 +
arrivons à diminuer de presque 30% notre consommation (voir de 42 % avec un
 +
transistor Mosfet contrôler par une broche digitale en guise d'interrupteur).
 +
Ainsi on remarque rapidement l'intérêt d'être passé sur un Arduino nano et d’avoir
 +
optimiser le code. En effet, lors de notre précédent montage on obtient une
 +
consommation de 0.04A soit une puissance de 0.2 W. On a donc dans le meilleur des
 +
cas avec le transistor, une diminution de notre consommation par 20.
 +
Lors des tests sur le RaspBerry, on est au minimum à une consommation de 1.1
 +
W en veille avec des tensions de 2.5V à 5V en fonctionnement. Pour consommer moins
 +
de courant, on pourrait tout d'abord améliorer le facteur de puissance en ajoutant des
 +
capacités à l'entrée de notre alimentation pour qu’on obtienne un retard faible pour que
 +
les courants soient en phase ou alors réussir à passer la RaspBerry en mode veille et la
 +
réveiller par interruption de l’Arduino.
 +
 +
Finalement, nous avons une batterie totale de 21A pour 73.5W composé de 6
 +
cellules de 3.6V et d’une capacité.
 +
La RaspBerry et l’Arduino consomme, dans le meilleur des cas, 1.1W et 0.04W
 +
ce qui implique avec une batterie de 73W, 64,4 heures d’autonomie (contre 56.53 sans
 +
l’optimisation Arduino), dans le pire des cas 5W et 0.04A soit 14h sachant qu’en réalité,
 +
nous serions aux alentours des 2W+0.04 soit 36.02h (contre 33h sans l’optimisation
 +
Arduino).
 +
Avec un panneau solaire de 4W en moyenne sur l’année par journée de 12h, on
 +
peut charger, dans le meilleur des cas, 36W par jour dans la batterie. Et, dans le cas
 +
moyen, être stable. Dans le pire des cas, on perd 24W par jour.
 +
 +
==Conception du PCB (remplacement de l’Arduino)==
 +
 +
Pour optimiser au maximum l’espace de stockage des cartes dans la mangeoire
 +
et optimiser les pins que nous utilisons en enlevant les pins inutiles, nous avons réalisé
 +
un PCB qui se plug directement sur la Raspberry.
 +
Pour ce faire nous avons réalisé des rails qui comportent chacun une partie,
 +
comme par exemple le rail d’alimentation qui permet d’alimenter les cartes et les
 +
différents capteurs (5V et 3.3V). Il y a également les headers des cartes qui sont des
 +
deux côtés du PCB (avec des via) reliés à un autre rail qui lui reprend toutes les pins
 +
pour se retrouver facilement dans les branchements.
 +
 +
[[Fichier:Pcb numerique.PNG|500px|center|thumb|"Schéma et routage PCB"]]
 +
 +
En ce qui concerne la communication entre les deux cartes nous avons router les
 +
ports Tx et Rx sur les deux cartes mais nous n’avons besoins que du port Tx de l’Arduino
 +
et du port Rx de la RaspBerry car notre communication n’est pas bilatérale, l’Arduino
 +
transmet seulement ses données à la RaspBerry.
 +
Néanmoins notre PCB est donc double face, nous pensions dans un premier temps que
 +
nous ne pouvions pas imprimer ce genre de PCB et les via à Polytech et nous l’avons appris
 +
trop tard pour pouvoir le faire. Nous avons donc réalisé notre propre PCB à la main en soudant
 +
les pistes et les headers à la main. Celui-ci est au final semblable au PCB que nous aurions pu
 +
réaliser.
 +
 +
[[Fichier:Shield mangeoire.PNG|500px|center|thumb|"Shield physique remplaçant l'Arduino"]]
 +
 +
==Conception Informatique==
 +
 +
1) Reconnaissance des oiseaux
 +
 +
Tests d’améliorations
 +
 +
Augmenter le nombre de couches cachées dans la partie dense
 +
Notre réseau contient 4 couches de réseau de neurones de convolutions. Ces 4
 +
couches permettent de créer les filtres qui vont reconnaitre les oiseaux. Une fois ces
 +
filtres créés, ils sont introduits dans une couche dense contenant un nombre de couches
 +
cachés que nous allons régler. Cette couche dense sera notre modèle final contenant
 +
tous les filtres de chaque oiseau. Le premier modèle avait un nombre de 512 couches
 +
cachées. Le deuxième modèle a eu 4096 couches cachées et cela lui a permis
 +
d’atteindre 86 % de réussite.
 +
 +
Augmenter la taille des images
 +
 +
Des images de taille 150x150 pixels étaient fournies au premier modèle pour son
 +
entraînement. Pour notre troisième modèle, nous avons gardé une résolution de 4096
 +
couches cachées mais nous avons fourni des images de taille 256x256. Cependant, ce
 +
modèle a échoué et atteint un taux de 74% de réussite.
 +
 +
Augmenter le batch size
 +
 +
Le batch size est le dernier test que nous allons faire. Il s’agit du nombre itération
 +
que le modèle va faire sur chaque image lors de son apprentissage pour chaque
 +
entraînement. Le premier modèle avait un batch size de 64. Pour notre modèle final,
 +
nous avons gardé les 4096 couches cachées dans la partie dense du modèle et nous
 +
somme revenu à des tailles d’images de 150x150. Nous avons augmenté le batch size
 +
à 150 ce qui nous a permis d’atteindre les 90% de réussite.
 +
 +
Conclusion de l’IA
 +
 +
Des tests plus poussés ont été essayés. Cependant, par manque de puissance
 +
niveau ordinateur, nous n’avons pas pu les réaliser. Notre modèle final ayant un taux de
 +
90% de réussite, ne fait que 2 erreurs sur 10 oiseaux.
 +
 +
De plus, nous avons maintenant un dictionnaire (Annexe 3) contenant les noms de
 +
chaque oiseau. Nous parcourons le tableau que nous retourne le modèle afin de trouver
 +
l'indice de la prédiction la plus haute. Une fois trouvé, nous retournons le nom de
 +
l’oiseau.
 +
 +
2) RaspBerry Pi
 +
 +
Nous avons changé la transmission des données entre la RaspBerry Pi et l’Arduino.
 +
Nous sommes passés de la liaison USB à l’utilisation des pins TxD et RxD. Le code n’a
 +
pas changé car il s’agit toujours d’une liaison série. Nous avons fait des tests et nous
 +
recevons bien les données de l’Arduino.
 +
 +
Nous avons essayé d’implémenter notre modèle de reconnaissance d'oiseaux dans
 +
le programme de la RaspBerry Pi. Cependant, le programme n’arrive pas à ouvrir le
 +
modèle et à l’utiliser. Il n’est donc pas implémenté sur la RaspBerry Pi.
 +
 +
3) Arduino
 +
 +
Les gros changements dans le code lors de ce semestre sont les suivants : l’ajout
 +
d’interruption et d’un mode « sleep » permettant de ralentir le fonctionnement de
 +
l’Arduino ainsi que la communication en série via les broches RX et TX de l’Arduino et
 +
de la RaspBerry qui seront expliquée par la suite.
 +
Pour l’ajout de l'interruption il nous a suffi de réaliser la fonction « attachInterrupt »
 +
déjà implémentée dans le code Arduino.
 +
Le mode « sleep » quant à lui nous à poser pas mal de difficulté, en effet il existe
 +
une bibliothèque s’appelant « AVR sleep » permettant de mettre en veille les
 +
processeurs de la marque AVR notamment les Atmega néanmoins nous n’avons jamais
 +
réussi à nous servir de cette bibliothèque avec une interruption.
 +
 +
C’est pourquoi après quelques heures nous nous sommes penchés dans la
 +
datasheet de l’Atmega 328p processeur de l’Arduino nano. Pour ce faire et pour
 +
naviguer efficacement dans les 300 pages de datasheet nous avons tout d’abord
 +
rechercher le mot clef « sleep ».
 +
Ce qui nous a permis de tomber sur la partie system clock and clock options
 +
représentent tout d’abord l’ensemble du microcontrôleur et ses différents modules.
 +
 +
Puis en analysant ce système nous nous sommes ensuite intéressés à la partie
 +
Power management and « sleep modes ».
 +
 +
Ce mode de fonctionnement correspond à nos attentes. La partie qui nous
 +
intéresse le plus est la partie « 9.5 power-down mode » qui nous permet d'éteindre le
 +
microprocesseur.
 +
Pour ce faire nous devons modifier les bits SM que nous avions vu dans le « sleep
 +
MODE » et qui appartiennent au registre SMCR.
 +
 +
Il nous faut donc trouver le fonctionnement de ce registre dans la datasheet.
 +
 +
On choisit donc selon la datasheet SM2...SM1 =010 pour « power-down ».
 +
Et SE = 1 pour activer le « sleep mode ». Une fois la veille activée il faut attendre une
 +
interruption pour réveiller le microcontrôleur.
 +
Mais comment faire pour le réveiller efficacement ?
 +
En effet, lorsque l'on coupe le « power » de la manière dont on le fait, nous
 +
pouvons couper et modifier des bits permettant le bon fonctionnement des différents
 +
modules. N'étant pas expert dans le fonctionnement des Atmega, le moyen le plus
 +
efficace est de réinitialiser le pointeur de programme pour forcer un “reboot logiciel” de
 +
l’Arduino.
 +
 +
Nous mettons un « Delay » avant le « dodo () » pour être sûr que les données
 +
aient été transmises avant l'arrêt dans le code final. En effet, les registres d'émission sur
 +
le port série USART, par exemple, fonctionne indépendamment du programme principal
 +
alors que l'exécution power down pourrait arriver au milieu d’une émission d’un paquet.
 +
Pour la communication entre l’Arduino et le RaspBerry il suffit de se brancher au
 +
port TXd et RXd entre l’Arduino et le port GPIO.
 +
 +
==Amélioration du modèle de mangeoire==
 +
 +
Après avoir bien analysé notre besoin, nous avons décidé de modifier plusieurs
 +
choses dans la conception de notre mangeoire connectée.
 +
 +
1) Optimisation du système de distribution d’eau
 +
 +
Pour la modélisation de notre réservoir à eau nous avons pensés à un système
 +
classique pour la majorité des versoirs pour animaux utilisant le principe de pascal et
 +
la théorie de l’hydrostatique (Dans un liquide en équilibre de masse volumique
 +
uniforme, la différence des pressions en deux points est égale au poids de la colonne
 +
de liquide ayant pour section l'unité de surface et pour hauteur la différence de niveau
 +
des deux points. Toute pression exercée sur un liquide se transmet par lui
 +
intégralement et dans toutes les directions). En retournant la bouteille munie d’un
 +
bouchon possédant un petit orifice avec une membrane qui lors ce qu'elle sera percée
 +
par un pic permettra l’écoulement de l’eau. Les dimensions de notre bouteille sont de
 +
190 mm en hauteur et 60 mm de rayon grâce à cela nous avons calculé la quantité
 +
d'eau contenu.
 +
 +
𝐴 = 𝜋 𝑥 𝑟² = 3,14 𝑥 3² = 28,26 𝑐𝑚²
 +
𝑉 = 𝐴 𝑥 ℎ = 28.26 𝑥 19 = 536.94 𝑐𝑚3
 +
 +
Pour ce faire, nous avons réalisé une nouvelle modélisation 3D sur le logiciel «
 +
FUSION 360 » en faisant toujours attention à l’emplacement des capteurs et des
 +
réservoirs de nourriture.
 +
 +
Puis nous avons pensé à un nouveau design ce semestre qui a été pensé pour
 +
faciliter le remplissage de la bouteille. Pour ce faire, nous avons mis en place un système
 +
de vis qui nous permet d'accéder par le dessus ce qui permet aussi de remplacer
 +
facilement la membrane permettant la bonne étanchéité et le bon fonctionnement.
 +
Pour le plateau qui va supporter la bouteille, l’idée reste la même avec le principe
 +
de Pascal et la théorie de l’hydrostatique. Nous avons également modifié le plateau pour
 +
que le capteur de niveau d’eau puisse recevoir de l’eau sans avoir besoin d'être dans la
 +
bouteille.
 +
[[Fichier:Reservoir eau.jpg|500px|center|thumb|"Réservoir d'eau"]]
 +
 +
L’une des grandes difficultés sur cette partie était de bien paramétrer les
 +
imprimantes 3D pour obtenir une bonne précision pour permettre le vissage et le
 +
dévissage ainsi que l’emboitement des pièces et jouer avec les supports d’impressions.
 +
Puis, pour le bac à graines, nous avons gardé le même modèle que l’année dernière
 +
avec une pente permettant de verser les graines.
 +
 +
2) Réalisation d’une maquette en bois
 +
 +
Pour la réalisation de notre mangeoire finale, nous avons utilisé du bois (du
 +
contreplaqué de 10mm d’épaisseur) ce qui permet d’obtenir une structure très solide
 +
permettant de résister aux vents violents. En ce qui concerne les intempéries
 +
pluviales, ce prototype en bois n’est pas optimal car il n’y a pas de joints étanches.
 +
En ce qui concerne l’impression, nous avons réalisé un fichier InkScape comme
 +
pour la précédente maquette en carton. Nous avons donc utilisé les mêmes fichiers
 +
mais avons modifié les dimensions afin de prendre en compte l’épaisseur de la
 +
planche. Nous avons également modifié les dimensions des encoches.
 +
 +
Une fois les mesures prises et les schémas InkScape réalisés, il nous a suffi
 +
d’envoyer les fichiers vers la découpeuse laser et de surveiller que notre planche ne
 +
prenne pas feu pendant la découpe. L’utilisation de scotch a été nécessaire pour
 +
assurer la fixation et le maintien, car nous avons pu observer que le système
 +
d’encoches se doit d’être extrêmement précis pour s’auto-suffire.
 +
 +
Nous avons donc réalisé deux “feuilles” InkScape, l’une nous permettant de
 +
découper le toit en trois parties et une autre pour découper toutes les parties du cube
 +
principal.
 +
 +
Pour la découpeuse laser, nous avons utilisé un système de couleur (bleu et
 +
vert) permettant de donner l’ordre à la découpeuse de d’abord découper la couleur
 +
bleu (les contours) avant de découper les encoches (en vert).
 +
 +
[[Fichier:Maquette numerique.PNG|500px|center|thumb|"Fichier de Design de la mangeoire sous InkScape"]]
 +
 +
Une fois toutes les planches découpées, nous nous sommes attaqués au
 +
découpage des emplacements des capteurs et de la caméra. Nous avons également
 +
anticipé en perçant les trous nécessaires au passage des fils vers l’espace réservé
 +
aux composants.
 +
Nous avons décidé de fixer le toit avec des vis pour maximiser la solidité, et
 +
nous avons collé la plupart des autres parties entre elles avec de la colle à bois.
 +
Nous avons également utilisé la découpeuse laser afin de réaliser les planches
 +
de plexiglas au niveau du toit mais également en façade permettant de voir le niveau
 +
de graines.
 +
 +
[[Fichier:Maquette mangeoire.PNG|500px|center|thumb|"Mangeoire finale en bois"]]

Version actuelle datée du 6 mai 2022 à 10:43

Présentation générale

Introduction

Notre projet de mangeoire connectée s’insère dans une optique d’observation et d’étude de la faune aviaire. Une mangeoire classique permet simplement d’observer à un moment précis les animaux, par le biais de nourriture qui permet de les attirer. Notre projet de mangeoire connectée, permettra à ses utilisateurs de visualiser en continu, l’activité extérieure et journalière de ces petits mammifères locaux. Elle permettra également de récolter des données afin d’en apprendre plus sur le mode de vie des animaux sauvages.

Ce projet se déroule pendant les deux premières années de notre cycle ingénieur en Systèmes Embarqués. Il nous permettra de mieux appréhender les travaux de groupes à venir lors de notre stage, ou encore lors de notre carrière professionnelle.

Notre projet se découpe en 2 axes distincts. Premièrement, la partie conception et réalisation de la mangeoire, en prévoyant des espaces de stockage conséquents pour l’eau, la nourriture ainsi que les composants. Deuxièmement, une partie informatique qui regroupe la réalisation d’une IA qui permettra de reconnaître les oiseaux qui se présenteront via leurs aspects physiques, ainsi qu’une partie programmation de cartes électroniques (Arduino et Raspberry Pi) qui commanderont les capteurs.

Contexte

Réalisation d’une mangeoire connectée pour un particulier, capable de fournir des photos et des enregistrements sonores des oiseaux, ainsi que des statistiques de la mangeoire et une détection des niveaux d'eau et de nourriture restants. Ce projet rentre dans le cadre de nos études de par le fait de la partie programmation et réalisation. De plus, la partie supplémentaire concerne l’installation de panneaux solaires permettant de rendre autonome la mangeoire. Ce projet nous permet de nous investir dans de nombreux domaines qui sont : la programmation informatique, l’organisation d’un projet de groupe, l’étude des oiseaux dans leur milieu naturel, la réalisation de différents prototypes, l’étude de différentes solutions.

Description des fonctionnalirés

 - Prise de photos et de vidéos  (caméra infrarouge 180° pour RaspBerry Pi)
 - Enregistrement des chants d’oiseaux (micro pour RaspBerry Pi)
 - Détection du niveau d’eau (sonde de niveau) et de nourriture dans la mangeoire (capteur laser)
 - Pesée des oiseaux pour évaluer leur état de santé et de potentiellement permettre de différencier les individus (capteur de poids arduino)
 - Température et humidité (capteur de température et d’humidité)
 - Utilisation de panneaux solaires pour alimenter les éléments (panneaux solaires)
 - Reconnaissance des espèces d’oiseaux

Les données seront récupérées au travers d’un réseau wifi puis stockées dans une base de données accessible via le web ou peut être une application. La base du projet sera sur une Raspberry pi.

Matériel

"Capteur de température"
  • Un capteur de température qui permettra de recevoir la température ainsi que le niveau d’humidité. Il fonctionne en 3.3V ou 5V et il nécessite une pin de DATA pour transmettre l’information à l'arduino et il fonctionne à l'aide d’un programme coder en C.
"Arduino"
  • La carte arduino est un des composants majeurs pour notre projet car elle permet grâce à ses ports et son microprocesseur de faire fonctionner les capteurs à l'aide d’un programme codé en C plus précisément en langage arduino. Les fonctionnalités de l’arduino nous permettront d’utiliser les capteurs spécifiques à arduino comme le capteur de pression, les capteurs infrarouge,...
"Caméra infrarouge"
  • Une caméra infra-rouge qui fonctionne avec une raspberry. Elle possède une résolution HD. Cette caméra de vision nocturne Raspberry Pi est capable d’obtenir des images statiques de 2592 x 1944 pixels, et prend également en charge l’enregistrement vidéo 1080p 30 images par seconde, 720p 60 images par seconde et 640x480p.
"Capteur infrarouge"
  • Des capteurs infrarouge qui permettent de détecter des objets ou des obstacles quand ils passent devant les capteurs. Il fonctionne en envoyant un rayon grâce au transmetteur, renvoyé quand il est confronté à un obstacle vers un récepteur. En fonction du temps d’attente pour recevoir le rayon on peut calculer la distance.
"Capteur de mouvement"
  • Un capteur de mouvement PIR qui nous permettra de détecter les mouvements et ce bloque pendant 15 secondes une fois un objet détecté.
"Capteur de niveau d'eau"
  • Un capteur de niveau d’eau qui permet lorsqu’il est en contact de l’eau d'envoyer un signal qui mesure l'humidité ainsi que la température ce qui nous permettra de savoir s’il y a de l’eau dans le réservoir. Le capteur fonctionne avec arduino et nécessite une pin analogique.
"Raspberry Pi"
  • La carte Raspberry Pi est également un élément majeur du projet car elle va avoir la même utilité que la carte arduino mais elle utilisera elle d’autres capteurs propre à raspberry, et servira également à la reconnaissance faciale des oiseaux avec une IA.

Travail effectué au S6

Conception informatique

1. Calibrage des différents capteurs sur Arduino

Notre arduino et son code comportent pour le moment 5 capteurs dont deux principaux. Un capteur PIR détecteur de mouvement et un capteur de proximité. Nous avons pour le moment décider de travailler par scrutation. Nous avons essayé de travailler par interruption et avec une fonction d'économie d'énergie sleep. Mais n'ayant pas réussi, nous approfondirons ultérieurement pour la réalisation finale du projet. Nous avons articulé ces capteurs grâce à un code arduino avec la logique suivante (cette structure de code et sa logique nous permettra par la suite de travailler plus facilement par interruption) . Nous savons que lorsque le capteur infrarouge PIR capte un mouvement, il lui faut 15 secondes pour qu’il puisse être réactivable et qu’il est capable de détecter un mouvement jusqu’à 7 m. Ne voulant détecter que les oiseaux qui entrent dans la mangeoire pour cela nous avons couplé ce détecteur à un capteur de distance. Lorsque le détecteur de mouvement reçoit un signal, nous testons pendant 15 secondes si le capteur de distance capte un objet à moins de 15 cm. Si c’est le cas alors nous envoyons sur le port série l’ordre de prendre des photos et d’envoyer les différentes valeurs de nos capteurs (température , humidité, luminosité), et nous vérifions le niveau d’eau et de nourriture .

2. Communication entre raspberry Pi et arduino et prise de photos

La communication entre la raspberry Pi et l’arduino se fait via l’un des ports USB. C Tout d’abord nous importons les bibliothèques qui nous seront utiles. Puis nous configurons et initialisons plusieurs variables que nous utilisons dans la suite du programme. Nous avons firebaseConfig qui nous permet de nous connecter à une base de données en ligne, nous permettant de stocker toutes les informations de chaque oiseau et de chaque capteur en temps réel. Nous initialisons aussi la caméra ainsi que toutes les variables permettant de récupérer les données de l’arduino. “ser” nous permettra de lire sur le port USB.

Ensuite, nous entrons dans une boucle infinie, permettant au programme de tourner en continu. Nous récupérons le nombre d’oiseaux dans la base de données pour rendre tout cela dynamique et pour renommer les photos. Puis nous attendons que l’arduino nous envoie l’information “Photo”, nous permettant de savoir qu’un oiseau s’est posé sur la mangeoire. Nous récupérons les données envoyées par l’arduino, la date et l’heure actuelle et nous prenons une photo avec la caméra qui elle est sauvegardée dans le répertoire courant.

Une fois la photo prise, nous l’enregistrons dans la base de données, dans une partie qui s’appelle “storage” où nous pouvons stocker n’importe quel fichier. Nous récupérons ensuite le lien de la photo et nous créons une variable data contenant les informations de l’oiseau que nous envoyons sur la base de données et que nous retrouverons sur l’application. Pour finir, nous faisons le même processus pour les données des capteurs.

3. Communication entre la raspberry Pi et l’utilisateur

L’utilisateur aura accès aux photos et informations de la mangeoire via une application. Pour faire cela, nous avons décidé d’utiliser Android Studio permettant de créer des applications facilement et d’avoir un accès à une base de données gratuite (firebase).

Voici à quoi ressemble l’application. Pour l’instant, nous pouvons y voir les photos des oiseau, les détails de chaque oiseau et les statistiques de la mangeoire (température, nombres d’oiseaux passés, …), Le but étant à l’avenir d’améliorer cette application avec la mangeoire pour avoir plus de fonctionnalités comme des statistiques plus poussées ou des détails plus précis sur les oiseaux.

4. Lancement automatique

Afin de rendre la mangeoire autonome, nous avons automatisé le lancement de nos programmes. Nous avons utilisé “crontab” qui permet de lancer des programmes automatiquement à un moment précis. Dans notre cas, nous avons lancé le programme 1 minute après le démarrage de la Raspberry Pi afin de lui laisser le temps de se connecter au wifi.

Nous avons donc ajouté cette commande :

@reboot sleep $((60)); /home/pi/.local/lib/python3.7/site-packages python3.7 /home/pi/Desktop/img/envoie_donnee_database.py > /home/pi/logs/logs.txt 2>&1

En cas d’erreur, nous enregistrons les messages dans le fichier logs.txt.

Conception du modèle de mangeoire

1. Maquette 3D sur SketchUp

  • Recherche de la disposition optimale

Notre réflexion sur la disposition de chaque élément à débuté par des recherches internet afin d’observer les différentes dispositions déjà réalisées. Après avoir analysé de nombreux projets, nous avions tous en tête quelque chose de relativement concret et similaire : un objet relativement grand pour faciliter la disposition de tous les éléments, nos capteurs et caméra disposés au centre de la mangeoire et face à la zone de breuvage et d’alimentation pour avoir la meilleure visibilité possible. Les réservoirs d’eau et de graines seront donc disposés à gauche et à droite de la mangeoire, les composants auront un espace dédié et relativement éloigné de la réserve d’eau. Le principe de toit s’ouvrant sur le devant et permettant d’une part de remplir les réservoirs mais également d’atteindre l’emplacement des composants. L’utilisation de plexiglas nous permettra de récupérer un maximum de luminosité sur l’objectif de la caméra mais également d’avoir une meilleure visibilité des réservoirs d’eau et de graines.

  • Dimensionnement

Dans un premier temps, nous avons commencé par des schémas sur papier libre avec des dimensions qui nous semblaient raisonnables. Celles-ci étaient donc relativement raisonnables étant donné l’utilisation de notre mangeoire. En effet, notre mangeoire sera utilisée dans un jardin de campagne, cela implique qu’il n’y aura que des oiseaux de petites tailles qui viendront se nourrir et s’abreuver. C’est donc pour cela que nous avons revu à la baisse.

En résumé, la base de notre mangeoire mesure 40cm * 50cm. Celle-ci mesure également 30cm de hauteur. Nous avons décidé de réaliser des parois permettant de séparer chaque compartiment : eau, graines, composants et cartes électroniques. Les capteurs sont placés à distances égales afin de rendre plus esthétique visuellement notre mangeoire. La capacité maximum de notre réservoir d’eau sera de 2.6 dm3 et il sera possible de mettre plusieurs kilogrammes de graines dans le réservoir opposé.

"Modèle 3D de la mangeoire"

2. Réalisation d’une maquette en carton à taille réelle

L’utilisation de bois et de plexiglas nous permettra de réaliser la mangeoire finale. Pour le moment nous avons réalisé, à taille réelle, une mangeoire avec des feuilles de plastique permettant de remplacer le plexiglas. De même pour le carton qui remplace le bois. Ce prototype nous permettra de confirmer nos plans, de vérifier si la visibilité de la caméra est bonne mais également peut-être de réaliser un test par beau temps, pas de pluie pour ne pas abîmer le carton. Afin de faire tenir au mieux chaque pièce de notre mangeoire, nous avons utilisé un pistolet à colle mais également du scotch double face.

"Prototype en carton de la mangeoire"

Travail effectué au S7

Gestion de l'énergie (Panneau Solaire)

L’un des objectifs de la mangeoire était de la rendre autonome en énergie, nous avons donc alors réfléchi à la consommation de notre Arduino et de notre Raspberry pi. Nous trouvons pour notre Raspberry une consommation de l'ordre de 350mA - 400 mA heure. Néanmoins il doit être alimenté en 5V /1.5A ce qui peut être fourni par notre module MPPT et pour une Arduino Uno avec une consommation de 35 mA mesurer à l’aide d’un ampèremètre USB semblable à celui ci. L’Arduino fonctionne en 5V branché au Raspberry.

"Ampèremètre USB"

On à donc en totalité besoin au maximum de 500mAh à 5V soit 2.5W/h. On prendra 6 batteries de 3.6 V en série d’une capacité de 3.5A chacune. au final nous avons donc 21A soit 8.4h de fonctionnement (On soudra nos batteries par point). Dans un budget raisonnable on à décidé de prendre un panneau solaire 10W sachant que la journée, le panneau solaire est en considérant que la panneau génère 4W ce qui n’est pas aberrant avec un faible ensoleillement on rechargera sur 8h 12A de batterie. Si nous arrivons à réduire au maximum la consommation la nuit et la journée quand il ne se passe rien nous serions dans la possibilité de tenir sur batterie au minimum 2 Jours.

"Panneau solaire 10 W SOL10P 17,6 V/610 mA"

Nos trois éléments, panneau solaire, batterie et Raspberry seront reliés grâce à un module MPPT. Ce module nous permettra de récupérer une puissance optimale du panneau solaire puis de charger la batterie en lui fournissant la puissance, selon la méthode adaptée pour des li-ion (générateur de courant constant et tension constante).Ce qui protège la batterie ( rôle d’un BMS ) et abaisser / remonter la tension de la batterie à 5 V pour le Raspberry.

"Module SunFlower 3,3/5/9/12 Vcc "

Conception informatique

Pour la partie informatique nous avons essayé d’élaborer une intelligence artificielle afin de pouvoir reconnaître l’espèce des oiseaux. Pour cela nous avons fait des recherches sur le deep learning et la reconnaissance faciale.


1. Recherche de dataset d’oiseau

Pour apprendre à notre IA à reconnaître les oiseaux, il nous fallait avoir une dataset contenant des dossiers de chaque espèce avec de nombreuses photos. Pour cela nous avons fait des recherches sur des dataset déjà existantes. Nous avons trouvé une dataset contenant 325 espèces du monde. Ce dossier contient des sous-dossiers pour l'entraînement, la validation et les tests de notre modèle. Dans ce dossier, nous avons fait un tri car il y avait des espèces non désirées. Nous avons fini avec une dataset de 65 espèces. Pour avoir une dataset plus complète, nous avons pensé la créer nous même. En effet, nous avons fait des recherches sur des programmes pouvant télécharger les images automatiquement. Cependant, par manque de temps nous n’avons pas pu tester cette solution. Nous ferons cet essai lors du prochain semestre.

2. Le deep Learning

C’était la première fois que nous apprenions à faire du deep learning. Nous avons tout d’abord fait des recherches afin de comprendre comment cela fonctionne et comment apprendre à notre modèle à faire de la reconnaissance aviaire. Pour réaliser l’entraînement de IA nous avons codé un programme en python avec les librairies TensorFlow et keras. Ci-dessous notre programme qui s’inspire d’un code existant provenant de la chaîne youtube TensorFlow. Nous allons maintenant l’expliquer.

Nous allons créer des images pour l’apprentissage et la validation à partir de la dataset téléchargées. Puis nous créons des générateurs d’entraînement et de validation qui permettent de créer des données d’apprentissage et de validation.

Ensuite, nous définissons nos réseaux neuronaux. Comme nous avons des images complexes et volumineuses, nous avons plusieurs couches de neurones afin de bien traiter les images et d’obtenir de meilleurs résultats lors de la reconnaissance des oiseaux. Nous utilisons pour l’entraînement des images de 150 par 150. et nous avons à une sortie de 65 neurones correspondant aux 65 espèces apprises par le modèle. Nous pouvons voir dans le sequencial que nous avons 4 couches de convolution. Nous lui fournissons une image en entrée et lui demandons de créer 65 et 128 filtres pour chaque image. Puis, à chaque entraînement il va déterminer les meilleurs filtres pour associer au mieux les images aux étiquettes voulues. Ces couches de convolutions étant empiler les unes sur les autres permettent d’améliorer l'apprentissage des caractéristiques de chaque espèce. Nous allons ensuite compiler ce modèle et lui faire effectuer 200 entraînements afin d’avoir un taux de réussite élevé.

Pour l’instant notre modèle n’est pas encore implémenté dans le programme de la mangeoire connecté. Nous voulons d'abord obtenir le meilleur modèle possible. Afin de tester notre modèle, nous utilisons un programme dont une partie sera utilisée dans le programme de la mangeoire.

Nous appelons notre modèle, ainsi que l’image que nous voulons tester. Puis nous utilisons la fonction predict() de notre modèle et nous affichons le résultat. Nous devrons ensuite parcourir ce tableau afin de trouver l’espèce prédit pour récupérer son nom.

Amélioration du modèle de mangeoire

Après avoir bien analysé notre besoin, nous avons décidé de modifier plusieurs choses dans la conception de notre mangeoire connectée. Premièrement la disposition des capteurs : nous avons décidé de mettre le capteur de présence IR dans le toit de notre mangeoire car ce sera plus simple pour détecter tout oiseau entrant au niveau de l’avant de la mangeoire. Les capteurs de force situés sous le réservoir de graines, ainsi que celui permettant de peser les oiseaux ont été enlevés de la maquette par simplification de fonctionnement et de réalisation. Maquette 3D sur Fusion 360 Nous avons décidé de modifier la taille de notre mangeoire car elle était bien trop grande par rapport aux oiseaux typiques de notre région. De plus, nous avons également repensé le toit de notre mangeoire pour pouvoir y insérer un panneau solaire nous avons donc un côté du toit beaucoup plus grand que l’autre pour pouvoir y poser un panneau solaire. Dans la partie réservée aux composants, nous allons réaliser des fixations pour que chaque carte (Arduino et Raspberry) ainsi que la batterie, pour qu’elles aient leur place respective pour simplifier les branchements. En ce qui concerne les verseurs de nourriture et d’eau nous avons gardé le même principe (jsp ce qu’on dit vu qu’on ne l’a pas fait)


Pour ce faire, nous avons réalisé une nouvelle modélisation 3D sur le logiciel « FUSION 360 » en faisant toujours attention à l’emplacement des capteurs et des réservoirs de nourriture.


1. Dimensionnement

Comme dit précédemment, nous avons décidé de réduire très largement la taille de la mangeoire. En effet, nous sommes passés d’une base mesurant 50 cm x 40 cm à une base mesurant 30 cm x 25 cm. De même, en ce qui concerne la hauteur qui n’est plus de 33 cm mais de 21 cm sans la hauteur du toit et 26 cm en considérant le toit. Le toit à également dû être modifié mais lui a été agrandi. Nous avons pris la décision de réaliser un pan qui mesure précisément la taille du panneau solaire qui permettra d’alimenter tous nos composants. Ce panneau solaire mesure 35.5 cm x 26 cm. Ces réductions de dimensions ne changent que l’espace de stockage des graines et de l’eau car nous avions calculé l’espace nécessaire pour le rangement de nos composants à l’arrière de la mangeoire.

2. Réalisation d’une maquette en carton à taille réelle

L’utilisation de bois et de plexiglas nous permettra de réaliser la mangeoire finale. Pour réaliser le prototype, nous avons choisi d’utiliser du carton, diminuant les frais. Contrairement à l’année passée, nous avons utilisé le logiciel InkScape pour réaliser des modèles 2D de chacune des planches constituant notre mangeoire. Ce logiciel nous a permis d’envoyer directement les schémas sur l’imprimante laser. Les découpes sont donc plus nettes et nous avons également utilisé le principe d’encoches pour fixer les planches entre elles. L’utilisation de scotch a été nécessaire pour assurer la fixation et le maintien.

Nous avons donc réalisé deux “feuilles” InkScape, l’une nous permettant de découper le toit en trois parties et une autre pour découper toutes les parties du cube principal Pour la découpeuse laser, nous avons utilisé un système de couleur (bleu et vert) permettant de donner l’ordre à la découpeuse de d’abord découper la couleur bleu (les contours) avant de découper les encoches (en vert).

Par la suite, nous avons rassemblé toutes les parties en respectant un ordre et un sens bien précis nous permettant de fixer au fur et à mesure. L’assemblage s’est réalisé correctement car les dimensions ont été respectées et les encoches correspondaient parfaitement. Seul souci concernant certaines planches pour lesquelles nous avions pris en compte l’épaisseur d’une planche de bois (environ 1 cm d’épaisseur) pour au final utiliser du carton (3 mm d’épaisseur).

Travail effectué au S8

Autonomie de la mangeoire avec Arduino

Gestion de l’énergie

L’une des plus grosses problématiques de notre projet est la gestion d'énergie, c’est pourquoi nous sommes passés sur un Arduino nano car l’Arduino nano consomme moins d'énergie, elle est également plus petite et moins chère. Nous avons donc comparé l'impact de nos programmes sur la consommation de l’Arduino. Dans un premier temps, nous avons testé notre programme du semestre précédent avec une boucle loop qui teste si un oiseau est arrivé toutes les secondes. Pour mesurer la consommation nous avons tout d’abord acheter un mini multimètre USB mais qui malheureusement ne fonctionne pas sur les Arduino nano car la consommation est trop faible.

Nous avons donc placé une résistance entre le 5v de sortie du RaspBerry et le Vin d’entrée de l’Arduino avec la loi d’Ohm U=RI et une résistance de 102 ohms. On obtient une tension à ces bornes de 1.430 V soit un courant I =0.0137A et une puissance P=0.0685W. Avec le code précédent en mode « sleep » on obtient 1.1V soit I=0.010 P=0.05W/h.

Nous avons aussi eu l’idée, pour réduire au maximum la consommation, d’utiliser un transistor pour couper l’alimentation des différents modules sauf le PIR, car il consomme toujours le même courant. Cette fois-ci, en mode « sleep », en coupant leurs alimentations on obtient une tension de 0.9V, soit 0.00882 A et donc P= 0.04W/h. Grâce à ces tests avec le « sleep » mode que nous avons implémenté, nous arrivons à diminuer de presque 30% notre consommation (voir de 42 % avec un transistor Mosfet contrôler par une broche digitale en guise d'interrupteur). Ainsi on remarque rapidement l'intérêt d'être passé sur un Arduino nano et d’avoir optimiser le code. En effet, lors de notre précédent montage on obtient une consommation de 0.04A soit une puissance de 0.2 W. On a donc dans le meilleur des cas avec le transistor, une diminution de notre consommation par 20. Lors des tests sur le RaspBerry, on est au minimum à une consommation de 1.1 W en veille avec des tensions de 2.5V à 5V en fonctionnement. Pour consommer moins de courant, on pourrait tout d'abord améliorer le facteur de puissance en ajoutant des capacités à l'entrée de notre alimentation pour qu’on obtienne un retard faible pour que les courants soient en phase ou alors réussir à passer la RaspBerry en mode veille et la réveiller par interruption de l’Arduino.

Finalement, nous avons une batterie totale de 21A pour 73.5W composé de 6 cellules de 3.6V et d’une capacité. La RaspBerry et l’Arduino consomme, dans le meilleur des cas, 1.1W et 0.04W ce qui implique avec une batterie de 73W, 64,4 heures d’autonomie (contre 56.53 sans l’optimisation Arduino), dans le pire des cas 5W et 0.04A soit 14h sachant qu’en réalité, nous serions aux alentours des 2W+0.04 soit 36.02h (contre 33h sans l’optimisation Arduino). Avec un panneau solaire de 4W en moyenne sur l’année par journée de 12h, on peut charger, dans le meilleur des cas, 36W par jour dans la batterie. Et, dans le cas moyen, être stable. Dans le pire des cas, on perd 24W par jour.

Conception du PCB (remplacement de l’Arduino)

Pour optimiser au maximum l’espace de stockage des cartes dans la mangeoire et optimiser les pins que nous utilisons en enlevant les pins inutiles, nous avons réalisé un PCB qui se plug directement sur la Raspberry. Pour ce faire nous avons réalisé des rails qui comportent chacun une partie, comme par exemple le rail d’alimentation qui permet d’alimenter les cartes et les différents capteurs (5V et 3.3V). Il y a également les headers des cartes qui sont des deux côtés du PCB (avec des via) reliés à un autre rail qui lui reprend toutes les pins pour se retrouver facilement dans les branchements.

"Schéma et routage PCB"

En ce qui concerne la communication entre les deux cartes nous avons router les ports Tx et Rx sur les deux cartes mais nous n’avons besoins que du port Tx de l’Arduino et du port Rx de la RaspBerry car notre communication n’est pas bilatérale, l’Arduino transmet seulement ses données à la RaspBerry. Néanmoins notre PCB est donc double face, nous pensions dans un premier temps que nous ne pouvions pas imprimer ce genre de PCB et les via à Polytech et nous l’avons appris trop tard pour pouvoir le faire. Nous avons donc réalisé notre propre PCB à la main en soudant les pistes et les headers à la main. Celui-ci est au final semblable au PCB que nous aurions pu réaliser.

"Shield physique remplaçant l'Arduino"

Conception Informatique

1) Reconnaissance des oiseaux

Tests d’améliorations

Augmenter le nombre de couches cachées dans la partie dense Notre réseau contient 4 couches de réseau de neurones de convolutions. Ces 4 couches permettent de créer les filtres qui vont reconnaitre les oiseaux. Une fois ces filtres créés, ils sont introduits dans une couche dense contenant un nombre de couches cachés que nous allons régler. Cette couche dense sera notre modèle final contenant tous les filtres de chaque oiseau. Le premier modèle avait un nombre de 512 couches cachées. Le deuxième modèle a eu 4096 couches cachées et cela lui a permis d’atteindre 86 % de réussite.

Augmenter la taille des images

Des images de taille 150x150 pixels étaient fournies au premier modèle pour son entraînement. Pour notre troisième modèle, nous avons gardé une résolution de 4096 couches cachées mais nous avons fourni des images de taille 256x256. Cependant, ce modèle a échoué et atteint un taux de 74% de réussite.

Augmenter le batch size

Le batch size est le dernier test que nous allons faire. Il s’agit du nombre itération que le modèle va faire sur chaque image lors de son apprentissage pour chaque entraînement. Le premier modèle avait un batch size de 64. Pour notre modèle final, nous avons gardé les 4096 couches cachées dans la partie dense du modèle et nous somme revenu à des tailles d’images de 150x150. Nous avons augmenté le batch size à 150 ce qui nous a permis d’atteindre les 90% de réussite.

Conclusion de l’IA

Des tests plus poussés ont été essayés. Cependant, par manque de puissance niveau ordinateur, nous n’avons pas pu les réaliser. Notre modèle final ayant un taux de 90% de réussite, ne fait que 2 erreurs sur 10 oiseaux.

De plus, nous avons maintenant un dictionnaire (Annexe 3) contenant les noms de chaque oiseau. Nous parcourons le tableau que nous retourne le modèle afin de trouver l'indice de la prédiction la plus haute. Une fois trouvé, nous retournons le nom de l’oiseau.

2) RaspBerry Pi

Nous avons changé la transmission des données entre la RaspBerry Pi et l’Arduino. Nous sommes passés de la liaison USB à l’utilisation des pins TxD et RxD. Le code n’a pas changé car il s’agit toujours d’une liaison série. Nous avons fait des tests et nous recevons bien les données de l’Arduino.

Nous avons essayé d’implémenter notre modèle de reconnaissance d'oiseaux dans le programme de la RaspBerry Pi. Cependant, le programme n’arrive pas à ouvrir le modèle et à l’utiliser. Il n’est donc pas implémenté sur la RaspBerry Pi.

3) Arduino

Les gros changements dans le code lors de ce semestre sont les suivants : l’ajout d’interruption et d’un mode « sleep » permettant de ralentir le fonctionnement de l’Arduino ainsi que la communication en série via les broches RX et TX de l’Arduino et de la RaspBerry qui seront expliquée par la suite. Pour l’ajout de l'interruption il nous a suffi de réaliser la fonction « attachInterrupt » déjà implémentée dans le code Arduino. Le mode « sleep » quant à lui nous à poser pas mal de difficulté, en effet il existe une bibliothèque s’appelant « AVR sleep » permettant de mettre en veille les processeurs de la marque AVR notamment les Atmega néanmoins nous n’avons jamais réussi à nous servir de cette bibliothèque avec une interruption.

C’est pourquoi après quelques heures nous nous sommes penchés dans la datasheet de l’Atmega 328p processeur de l’Arduino nano. Pour ce faire et pour naviguer efficacement dans les 300 pages de datasheet nous avons tout d’abord rechercher le mot clef « sleep ». Ce qui nous a permis de tomber sur la partie system clock and clock options représentent tout d’abord l’ensemble du microcontrôleur et ses différents modules.

Puis en analysant ce système nous nous sommes ensuite intéressés à la partie Power management and « sleep modes ».

Ce mode de fonctionnement correspond à nos attentes. La partie qui nous intéresse le plus est la partie « 9.5 power-down mode » qui nous permet d'éteindre le microprocesseur. Pour ce faire nous devons modifier les bits SM que nous avions vu dans le « sleep MODE » et qui appartiennent au registre SMCR.

Il nous faut donc trouver le fonctionnement de ce registre dans la datasheet.

On choisit donc selon la datasheet SM2...SM1 =010 pour « power-down ». Et SE = 1 pour activer le « sleep mode ». Une fois la veille activée il faut attendre une interruption pour réveiller le microcontrôleur. Mais comment faire pour le réveiller efficacement ? En effet, lorsque l'on coupe le « power » de la manière dont on le fait, nous pouvons couper et modifier des bits permettant le bon fonctionnement des différents modules. N'étant pas expert dans le fonctionnement des Atmega, le moyen le plus efficace est de réinitialiser le pointeur de programme pour forcer un “reboot logiciel” de l’Arduino.

Nous mettons un « Delay » avant le « dodo () » pour être sûr que les données aient été transmises avant l'arrêt dans le code final. En effet, les registres d'émission sur le port série USART, par exemple, fonctionne indépendamment du programme principal alors que l'exécution power down pourrait arriver au milieu d’une émission d’un paquet. Pour la communication entre l’Arduino et le RaspBerry il suffit de se brancher au port TXd et RXd entre l’Arduino et le port GPIO.

Amélioration du modèle de mangeoire

Après avoir bien analysé notre besoin, nous avons décidé de modifier plusieurs choses dans la conception de notre mangeoire connectée.

1) Optimisation du système de distribution d’eau

Pour la modélisation de notre réservoir à eau nous avons pensés à un système classique pour la majorité des versoirs pour animaux utilisant le principe de pascal et la théorie de l’hydrostatique (Dans un liquide en équilibre de masse volumique uniforme, la différence des pressions en deux points est égale au poids de la colonne de liquide ayant pour section l'unité de surface et pour hauteur la différence de niveau des deux points. Toute pression exercée sur un liquide se transmet par lui intégralement et dans toutes les directions). En retournant la bouteille munie d’un bouchon possédant un petit orifice avec une membrane qui lors ce qu'elle sera percée par un pic permettra l’écoulement de l’eau. Les dimensions de notre bouteille sont de 190 mm en hauteur et 60 mm de rayon grâce à cela nous avons calculé la quantité d'eau contenu.

𝐴 = 𝜋 𝑥 𝑟² = 3,14 𝑥 3² = 28,26 𝑐𝑚² 𝑉 = 𝐴 𝑥 ℎ = 28.26 𝑥 19 = 536.94 𝑐𝑚3

Pour ce faire, nous avons réalisé une nouvelle modélisation 3D sur le logiciel «  FUSION 360 » en faisant toujours attention à l’emplacement des capteurs et des réservoirs de nourriture.

Puis nous avons pensé à un nouveau design ce semestre qui a été pensé pour faciliter le remplissage de la bouteille. Pour ce faire, nous avons mis en place un système de vis qui nous permet d'accéder par le dessus ce qui permet aussi de remplacer facilement la membrane permettant la bonne étanchéité et le bon fonctionnement. Pour le plateau qui va supporter la bouteille, l’idée reste la même avec le principe de Pascal et la théorie de l’hydrostatique. Nous avons également modifié le plateau pour que le capteur de niveau d’eau puisse recevoir de l’eau sans avoir besoin d'être dans la bouteille.

"Réservoir d'eau"

L’une des grandes difficultés sur cette partie était de bien paramétrer les imprimantes 3D pour obtenir une bonne précision pour permettre le vissage et le dévissage ainsi que l’emboitement des pièces et jouer avec les supports d’impressions. Puis, pour le bac à graines, nous avons gardé le même modèle que l’année dernière avec une pente permettant de verser les graines.

2) Réalisation d’une maquette en bois

Pour la réalisation de notre mangeoire finale, nous avons utilisé du bois (du contreplaqué de 10mm d’épaisseur) ce qui permet d’obtenir une structure très solide permettant de résister aux vents violents. En ce qui concerne les intempéries pluviales, ce prototype en bois n’est pas optimal car il n’y a pas de joints étanches. En ce qui concerne l’impression, nous avons réalisé un fichier InkScape comme pour la précédente maquette en carton. Nous avons donc utilisé les mêmes fichiers mais avons modifié les dimensions afin de prendre en compte l’épaisseur de la planche. Nous avons également modifié les dimensions des encoches.

Une fois les mesures prises et les schémas InkScape réalisés, il nous a suffi d’envoyer les fichiers vers la découpeuse laser et de surveiller que notre planche ne prenne pas feu pendant la découpe. L’utilisation de scotch a été nécessaire pour assurer la fixation et le maintien, car nous avons pu observer que le système d’encoches se doit d’être extrêmement précis pour s’auto-suffire.

Nous avons donc réalisé deux “feuilles” InkScape, l’une nous permettant de découper le toit en trois parties et une autre pour découper toutes les parties du cube principal.

Pour la découpeuse laser, nous avons utilisé un système de couleur (bleu et vert) permettant de donner l’ordre à la découpeuse de d’abord découper la couleur bleu (les contours) avant de découper les encoches (en vert).

"Fichier de Design de la mangeoire sous InkScape"

Une fois toutes les planches découpées, nous nous sommes attaqués au découpage des emplacements des capteurs et de la caméra. Nous avons également anticipé en perçant les trous nécessaires au passage des fils vers l’espace réservé aux composants. Nous avons décidé de fixer le toit avec des vis pour maximiser la solidité, et nous avons collé la plupart des autres parties entre elles avec de la colle à bois. Nous avons également utilisé la découpeuse laser afin de réaliser les planches de plexiglas au niveau du toit mais également en façade permettant de voir le niveau de graines.

"Mangeoire finale en bois"
Récupérée de « https://projets-ima.plil.fr/mediawiki/index.php?title=IMA3/IMA4_2020/2022_P7&oldid=88207 »