Version actuelle datée du 21 juin 2018 à 15:48

Projet IMA3-SC 2017-2018

Projet informatique

Cahier des charges

Serre automatisée

Description du système

L'objectif du projet étant de communiquer entre une page HTML hébergé par la Raspberry Pi3 et une Arduino, nous devions trouvé une idée de projet pour à la fois récupérer des données envoyées depuis l'arduino mais également de pouvoir envoyer des informations depuis la raspberry. Nous avons donc décidé de créer une serre autonome. Celle-ci pourra être commandée à partir de l'application web dans laquelle on trouvera des informations telles que la température l'humidité ou encore l'intensité lumineuse. La page web devra être capable d’interagir avec l'Arduino pour pouvoir démarrer/arrêter un ventilateur ou ouvrir/fermer une électrovanne. On pourra alors vérifier que le micro climat de la serre est correct.

Matériel nécessaire

• Raspberry Pi 3
• Arduino
• capteur de température/hygrométrie
• caméra Raspberry pi
• Résistance chauffante ?
• Électrovanne
• Capteur de luminosité
• Bande LED
• Afficheur LCD arduino
• Capteur Hydrométrie ?
• Boite
• Ventilateurs

Séance 1

• Mise en place du projet

Au début de la séance, nous nous sommes mis d'accord pour réaliser une serre autonome. Nous avons alors réfléchi aux capteurs que nous pourrions utiliser, ainsi qu'à la répartition du travail.

Schéma d'ensemble

• Partie Arduino/FPGA

Dans un premier temps, nous nous sommes familiarisé avec Altium en suivant un tutoriel pouvant générer un compteur allumant des Leds.
Nous avons alors décidé, en remarquant la complexité de programmer en FPGA, de d'abord nous attarder sur la partie Arduino pour réaliser dans un second temps certaines commandes en FPGA.
Nous avons alors cherché les différents capteurs disponibles pour réaliser notre serre. Ainsi nous avons pu trouver un ventilateur fonctionnel, un capteur de luminosité, et un capteur 2 en 1 d'humidité et de température. Après avoir fait un bref essai sur le ventilateur, nous nous sommes attardés sur le capteur HTU21D-F (humidité/température).
Nous avons donc étudié la Data Sheet afin de comprendre son fonctionnement

Enfin, nous avons téléchargé une librairie nous permettant de coder très facilement son utilisation.

• Partie Raspberry Pi 3

La séance a été consacré a l'installation de Raspbian ainsi que la configuration du système. Pour cela, la suppression du paquet systemd nous a posé problème car il fallait exécuter une commande non-renseigné sur le wiki. Ceci étant certainement du a la nouvelle version de raspbian qui a apporté des conflits entre les paquets. En poursuivant dans la configuration de la Raspberry. Au redémarrage, le système à refuser de démarrer. Il a donc fallu réinstaller le système complètement et ainsi perdre plus d'une heure de travail. Au second paramétrage, le redémarrage s'est correctement effectué. Le hot-spot wifi apparaît bien. Il reste cependant a configurer le serveur DHCP afin d'autoriser la raspberry Pi a gérer son réseau en attribuant des adresses IP aux différents clients ainsi que l'installation du serveur Web permettant d’héberger l'interface utilisateur qui permettra à l'utilisateur de communiquer avec l'Arduino.

Séance 2

• Arduino
  

Lors de cette séance, nous avons terminé de coder sur Arduino la récupération des informations des capteurs de température/humidité et de luminosité. De plus, nous avons réalisé le câblage du panneau d'affichage. Ayant quelques problèmes avec la reconnaissance du capteur de température/humidité, nous avons pu afficher uniquement les valeurs du capteur de luminosité, que nous avons d'ailleurs converti directement en Lux.
Le but est désormais de finir le contrôle de l'électrovanne ainsi que du ventilateur grâce à des transistors. Nous aimerions également commencer à s'attarder sur la partie FPGA.

• Raspberry
  

Lors de la deuxième séance, nous avons continué l'installation de la raspberry qui avait échoué due à l'absence d'une commande dans la documentation. La réinstallation et la configuration se sont ensuite passés sans problème.
Pendant la dernière heure, nous avons essayé d'utiliser les différentes commandes comme l'arrêt du système mais également le redémarrage de la rasberry qui est maintenant possible depuis la page web.
La configuration de la communication série a permis la commande de l'arduino par la raspberry via une interface web. Il est maintenant possible d'utiliser le service web pour allumer les différents services de la serre comme le chauffage, l'arrosage... La commande des actionneurs est alors possible. Cependant, différents problèmes sont parvenus comme la récupération d'informations de la raspberry permettant, entre autres d'afficher la température et l'hygrométrie.

Séance complémentaire

Nous avons essayé lors de cette séance d'aborder la partie la plus importante du projet qui est la communication entre la raspberry (depuis la page web de serveur local de la Raspberry) et l'Arduino. En effet sur l'Arduino on est capable de lire la température, l'humidité ainsi que l'intensité lumineuse depuis les différents capteurs sur un écran lcd mais on est pas encore capable de communiquer cette information à la Raspberry. Pour se faire nous avons rédigé un programme arduino envoyant sur la la liaison série toutes les informations(cable USB connecté de l'Arduino à la raspberry).

Il n'est pas si évident d'envoyer un nombre sur la liaison série. En effet on ne peut envoyer sur la liaison série qu'un seul caractère à la fois. Si par exemple on veut envoyer 53 et qu'on fait un "Serial.write(53)" on envoie le code ASCII coréspondant à 53 et non 53. Il est donc essentiel de créer une fonction capable de décomposer un nombre. La fonction "envoi" présenté ci dessous permet de décomposer un nombre et d'envoyer chiffre par chiffre l'information.



On savait que le nombre max que l'on allait devoir transmettre à la page web était de l'ordre de la centaine et que les nombres étaient précis au centième près. La fonction envoi doit donc être capable de transmettre tous les chiffres de la centaine au centième. Pour procéder nous avons tout d'abord multiplié le nombre par 100 pour facilité l'isolement des chiffres. Exemple : 102.25 * 100 = 10225, pour isoler la centaine on récupère la partie entière de 10225/1000=1 (pour récupérer la partie entière on a juste à placer le résultat dans un int). On procéde de la même façon pour tous les autres chiffres. Une fois cela fait, on a tout simplement à envoyer les chiffres les uns après les autres sur la liaison série tout en s'assurant que chaque chiffre ait eu le temps de s'envoyer avec des delays (on a bien vérifié d'envoyer le code ascii de chaque chiffre : le code ascci de 0 étant 48 on ajoute 48 à tous nos chiffres).

Même si à présent on est capable d'envoyer correctement les informations des différents capteurs à la raspberry, on doit lui permettre de différencier les informations de chaque capteur. Pour ce faire nous allons tout simplement envoyer un caractère propre à chaque information au début celle-ci afin de pouvoir l’identifier. Dans notre cas on envoie 'T' pour la température, 'H' pour l'humidité, 'L' pour la luminosité et 'F' pour la fin d'une série d'information.
Le programme ci dessus nous correspondant à une partie du "loop" nous le montre. On peut également remarquer qu'on continue d'afficher les différentes infos sur le lcd afin de pouvoir l'observer depuis la serre.



Il faut maintenant que la raspberry soit capable d'interpréter et d'afficher l'information sur la page web. Le code ci dessous nous montre une fonction capable d'afficher dans différents champs du code html la valeur des différentes informations.



La fonction fonctionne de cette façon : on récupère l'information transmise dans une variable, on crée ensuite une chaîne de caractère qu'on concatène pour chaque caractère envoyé qui n'est pas une balise ('T','H','L','F'). On teste chaque caractère individuellement, si ce caractère est une balise, on l'affiche dans le champ correspondant et on réinitialise la chaîne de caractère comme vide. Exemple : on reçoit 'T27H65L103F' on sait que la température sera transmise quand le caractère H sera reçu, on affiche le résultat reçu dans le champ de la température, on réinitialise la chaîne de caractère. La chaîne de caractère sera concaténée jusqu'à la prochaine balise et ainsi de suite ...

Nous somme désormais capables d'envoyer et de recevoir sur la page HTML les informations des différents capteurs. La prochaine étape consiste à envoyer une commande à l'Arduino. La fonction ci dessous nous permet d'envoyer une commande à l'appui sur un bouton. Elle prend en paramètre un chiffre qui détermine sur quel actionneur on agira (0 on allume le chauffage et 1 on démarre le ventilateur). Elle change ensuite la valeur du bit correspondant à la commande (0 à 1 si éteint,1 à 0 si déjà allumé).



Du coté Arduino dès qu'on reçoit quelque chose sur la liaison série on identifie la fonction à réaliser en fonction du chiffre reçu. Ici on l'affiche juste sur le lcd.



Screen de la page web récupérant bien les informations des différents capteurs de l'Arduino. A gauche les deux voyants OK de l'état du chauffage et du ventilateur sont rouges (off), à droite on appuie sur le bouton chauffage qui allume le voyant et transmet l'inforamtion à l'Arduino.

Photo du lcd quand on appuie sur le bouton chauffage depuis le site.



Photo du lcd affichant les informations des différents capteurs.



sur cette vidéo on peut observer la communication entre la raspberry et l'Arduino lorsqu'on appuie sur les boutons chauffage et ventilateur

Activité électronique

Séance 3

Durant cette séance, nous nous sommes focalisés sur la partie FPGA. L'objectif était de contrôler la vitesse de rotation du ventilateur.
Nous avons donc pensé à utiliser la méthode PWM (Pulse Width Modulation): A fréquence fixe, on modifie la valeur moyenne du signal de sortie en changeant le rapport cyclique (plus le rapport cyclique est grand, plus la valeur moyenne sera grande). On est donc capable de faire varier la tension de sortie et ainsi de choisir une vitesse de rotation.

Dans un premier temps nous avons utilisé le bloc modélisant la PWM disponible sur Altium afin de réaliser les premiers tests. Nous nous sommes alors rendus compte que la tension délivrée par la maquette était trop faible : pas plus de 5V alors que le ventilateur tournait entre 5 et 12V. De ce fait, nous avons réalisé en parallèle un circuit électronique capable d'amplifier la tension de sortie tout en respectant la commande.
VOIR PHOTO
Dans un second temps, nous avons essayé de créer un bloc PWM équivalent au bloc déjà existant.
Pour cela, on génère un signal d'horloge qu'on relie à un compteur. On compare cette valeur à une consigne (sur 8 bits). Tant que la valeur est inférieure à la consigne, le signal de sortie est à 1. Dès qu'elle la dépasse, le signal passe à 0. Cela permet de créer un signal dont le rapport cyclique est déterminé par la consigne (utilisateur).
Par exemple, en envoyant 1000 0000 (128) en consigne, on a un rapport cyclique de 128/255 soit environ 50%.

On a notamment pu faire quelques tests et constater la variation du rapport cyclique sur un oscilloscope. En l'associant au montage électronique, on a ainsi pu voir que les variations de vitesse du ventilateur.
Nous avons donc réaliser le schéma de gauche sur la photo de droite.

On aurait pu optimiser notre tension de sortie en la filtrant, afin un signal de sortie lissé (moins de changements brusques de tension).

Pour une sortie petite on obtient un rapport cyclique petit :


Pour une sortie où les 4 bits de poids fort sont à 1 on à un rapport cyclique de 240/255 ~= 94%. Ce qui est cohérent avec l'observation sur l'oscilloscope où on voit que le signal est à l'état haut sur presque une période. :


Pour une sortie où seul le bit de poids fort vaut 1 on a un rapport de 128/255 soit environ un rapport cyclique de 0.5, effectivement, sur l'oscilloscope on observe une période a l'état haut égale à celle a l'état bas donc un rapport de 0.5

Bilan

Grâce à ce projet, nous avons appris comment mettre en liaison un Raspberry et un Arduino et c'est sûrement ce point le plus important. En effet, la communication des deux interfaces permet d'élargir considérablement les possibilités de projets de systèmes embarqués. Cependant, la partie FPGA a été plus compliquée à gérer et à intégrer car le principe de ces cartes est de créer des interfaces plus bas niveau et industrialisables par la suite, et comprendre le fonctionnement n'était pas évident.

Pour parler de certains points d'améliorations possible, le projet pourrait être complété par la création d'un prototype intégrant les différents composants dans la serre. Cependant cela demande un matériel relativement inerte et plutôt résistant, soit du PET, qui a l'avantage d'être alimentaire mais présente des propriétés élastiques importantes, soit de l'ABS mais qui n'est pas forcément compatible avec des plantes aromatiques ou destinées à la consommation humaine, ce genre de plastique étant plutôt toxique, mais est beaucoup plus résistant aux déformations. De plus, l'étude de LED permettant d'adapter le spectre lumineux nécessaire à une photosynthèse efficace aurait été également nécessaire. On pourrait également avoir accès à une base de données répertoriant les conditions optimales de la germination à la maturité des plantes et choisir via le site l'espèce et la variété afin d'adapter automatiquement les conditions de chaleur, d'humidité et de luminosité.

Finalement, bien que le projet soit ambitieux, une première version de l'interface logicielle et de l'interface matérielle montre que cela est réalisable, mais qu'il mériterait d'être entrepris à plus grande échelle, et en impliquant peut-être des personnes de différents milieux, comme des biologistes, et du matériel qui peut supporter en permanence l'exposition à l'eau et à l'air sans se dégrader.