RUBIBOX – Robot d’arcade Rubik’s cube

Présentation de notre projet :

Bonjour à tous !

Nous sommes Lou Bénier, Erwann Miloux et Maxime Toublanc, étudiants de 2ème année à Polytech Angers.

Cet article est dédié à notre projet de fin d’année porté sur le domaine de la robotique.

Nous vous présentons donc Rubibox, notre robot d’arcade de réalisation du Rubik’s cube.
Le but étant de résoudre ce célèbre casse-tête au moyen de boutons poussoirs en ajoutant comme difficulté l’incapacité de pivoter la face orange.

logo

Le cube à résoudre est à l’intérieur d’une boîte en plexiglas transparent, rendant la manipulation manuelle impossible.

L’idée est d’intégrer ce projet à un autre bien plus grand : Escape Polytech.
En effet nous l’avons conçu dans le but qu’il soit encastré dans un bloc de l’armoire d’Escape Game pour l’édition Escape Polytech à venir.


Conception & Réalisation :

Nous sommes partis sur l’idée d’un cube dans un cube.

Les moteurs sont vissés sur les faces intérieures d’un cube en plexiglas, tenant le Rubik’s Cube au centre.
La pièce orange non pivotable est face à l’utilisateur du robot, sa vue n’étant pas obstruée par un sixième moteur.

CAO SolidWorks

Modélisation CAO de Rubibox (SolidWorks)

Pour ce qui est de la commande des moteurs, ils sont activés suite à l’appui d’un bouton d’arcade de la couleur de la face correspondante.

Ces derniers sont disposés sur un petit boîtier au-devant du cube en plexiglas.
On ajoute un bouton « mélange » (shuffle en anglais) à l’avant du boîtier.
Associés à ces boutons, des LED de même couleur s’allument lors de la rotation d’une face.
La liaison entre les boutons poussoirs et les moteurs, se fait via 3 cartes Arduino UNO.

Il nous a fallu songer à une méthode pour décider du sens de rotation (horaire ou anti-horaire).

Pour ce faire, nous utilisons un interrupteur levier ON OFF ON, qui activé à « gauche » pivote la face dans le sens anti-horaire, et activé à « droite » donne une rotation horaire.
C’est dans l’esprit du robot d’arcade, que nous voulons donner à cet interrupteur l’apparence d’un joystick d’arcade.

Au cours de ce projet nous avons dû utiliser différentes machines spécifiques telles que :

  • La découpe laser du fablab des Beaux-Arts pour le cube en plexiglas transparent et le boîtier que nous avons fait de la même matière par efficacité.
  • découpe laser plexi

    Découpe laser du plexiglas (Beaux-Arts)


    pièces de plexiglas

    Pièces de plexiglas à la sortie de la découpe

    Afin d’encastrer les faces du cube les unes avec les autres, nous avons eu l’idée de donner aux côtés une forme de remparts. Ainsi nous avons un unique fichier SolidWorks pour les 6 faces.

  • L’imprimante 3D du fablab de Polytech Angers pour les petites pièces liant les 5 moteurs aux centres des faces du Rubik’s Cube, et les pièces liant les moteurs aux faces en plexiglas.
  • impression 3D

    Impression 3D des pièces qui contiendront les moteurs

  • La perceuse du fablab de Polytech Angers effectuant des trous dans le plexiglas pour y fixer les moteurs et les équerres.
  • perceuse plexiglass

    Nous perçons les trous qui serviront à visser les moteurs


Principe du code :

Notre code repose sur la communication de 3 cartes Arduino UNO branchées en série.

On appelle ce système un bus I2C (Inter-Integrated Circuit) composé d’une Arduino dite MASTER, et des 2 autres dites SLAVE 1 et SLAVE 2.

Le principe de ce bus est que la MASTER contient le programme principal et envoie des ordres aux SLAVE 1 et SLAVE 2. Elle peut aussi demander une « requête » à celles-ci.

Pour illustrer au mieux ce processus voici un exemple où l’on veut faire tourner une face du Rubik’s Cube pour laquelle le bouton déclencheur se situe sur la MASTER, le moteur et la LED sur la SLAVE 1, et l’interrupteur levier sur la SLAVE 2 :

schéma explicatif

Schéma explicatif du principe de communication entre les Arduino


code

Code Arduino correspondant au schéma précédent

Test de ce code en vidéo (moteur vert sur SLAVE 1 actionné par bouton bleu sur MASTER) :

Le choix d’utiliser 3 cartes Arduino est lié au fait d’avoir 5 moteurs. Sur chaque Arduino est placée une carte Shield ne pouvant contenir que 2 moteurs chacune.

On a alors réparti les différents composants comme suit : les 6 boutons sur la MASTER, les LED sur la SLAVE 1 où sont branchés leur moteur respectif, et l’interrupteur sur la SLAVE 2.

En voici le schéma électrique :


Fabrication & Assemblage :

Nous avons conçu les faces de la boîte en plexiglas dans le but de les encastrer les unes avec les autres grâce aux remparts.

Seulement, à cause du jeu existant entre elles, nous avons décidé de les fixer à l’aide d’équerres.

Pour ce qui est du joystick, nous avons préféré le fabriquer nous-même, l’imprimante 3D étant très prisée. Dans la boule de joystick taraudée, commandée au préalable, on y a inséré une vis (dont on a coupé la tête), à laquelle nous avons collé un tube métallique pour la tige. Le tout fixé sur l’interrupteur levier lui-même vissé au boîtier.

Puis nous avons dû sectionner, diviser et rallonger notre alimentation de 9V afin d’alimenter notre robot via la carte Arduino MASTER par l’embout d’alimentation DC, et les trois cartes Shield par les fils + et – qui en découlaient.


Rendu final :

Nous finissons notre projet en tournant deux faces sur les cinq requises.

En effet, nous avons rencontré divers problèmes que nous n’avons pas pu régler. Néanmoins, nous sommes capables de tourner ces faces en choisissant le sens de leur rotation grâce au joystick orange, ce qui est un point positif.

Pour l’assemblage final, nous avions convenu de glisser les cartes Arduino sous le boîtier des boutons, mais par manque de place elles ont été déposées dans la boîte en plexiglas.

Assemblage final de Rubibox

Assemblage final de Rubibox


Problèmes rencontrés :

Au cours de notre projet, nous avons rencontrés plusieurs obstacles.

Pour commencer, le plus flagrant, tous les moteurs ne tournent pas. En effet, nous suspectons le fait que l’une des deux SLAVE ne puisse plus recevoir d’informations venant de la MASTER. Nous ignorons encore la raison, peut-être qu’un problème est survenu lors de l’assemblage du robot ou bien lors du soudage à l’étain des fils de branchement sur les cartes Shield.

Autre problème : nous avions commencé le projet avec un Rubik’s cube différent.

Nous avons conçu Rubibox de manière à encastrer les moteurs dans les centres du cube. Or, lors de l’assemblage, nous nous sommes rendus compte que les centres tournaient curieusement indépendamment du reste de la face. En conséquence, le moteur tournait correctement, mais la face ne suivait pas. Nous avons donc dû prendre un de nos Rubik’s cubes personnels n’ayant pas ce problème, pour mener à bien notre projet.

S’ajoute à tout ceci un problème esthétique.

En effet nous manquions de place sous le boîtier des boutons pour y insérer les cartes Arduino ce qui encombra la boîte en plexiglas dans laquelle sont déjà placés le cube et les moteurs. De plus nous voulions fabriquer un boîtier opaque pour cacher tous les fils. Malheureusement le Fablab des Beaux-Arts, lieu où nous avons utilisé la découpe laser, ne pouvait nous céder uniquement du plexiglas transparent pour toutes nos pièces.

Puis, sur ce même boîtier nous avons constaté un défaut de conception pour l’emplacement du bouton de mélange du Rubik’s cube.

Effectivement, lors de l’assemblage, il nous a été difficile d’intégrer ce bouton à cause de la forte proximité des boutons blanc et jaune. Nous aurions dû le placer à gauche, près de l’interrupteur levier, plutôt qu’à droite à l’encontre des boutons.


Conclusion :

Malgré les quelques complications survenues, nous ne pouvons que conclure positivement.

Nous avons mené ce projet en équipe, et sommes ravis du rendu de Rubibox même si nous sommes un peu frustrés de ne pas le voir fonctionner dans son entièreté comme prévu.
Tout au long de ce projet, nous avons été actifs et les idées fusaient.
Ce projet nous a permis d’acquérir de nouvelles compétences, d’apprendre à utiliser certaines machines, et surtout d’avoir le plaisir de mettre en pratique nos idées, notre imagination.

Voici quelques points à améliorer sur Rubibox :

Points à améliorer :

Nous avions intégré dans le code une partie calculatoire permettant de connaître la position des couleurs sur le cube à tout instant. Ainsi, lorsque le cube aurait été résolu, les LED se seraient allumées telles une guirlande.

Pour améliorer le robot, on pourrait ajouter un émmeteur de son faisant retentir une petite mélodie au même instant que la guirlande de LEDs.
Pourquoi pas aussi un petit écran LCD servant de chronomètre, indiquant le temps de résolution mis par le joueur.
De plus, dans l’idée de l’intégrer à l’armoire d’Escape Polytech, une pose de miroirs à l’arrière pourrait être intéressante.

Création d’un mur de lumières pour Escape Polytech

Bonjour à toutes et à tous ! Nous sommes trois étudiants de 2ème année actuellement en fin de cycle préparatoire de Polytech Angers et nous allons vous présenter notre projet réalisé plus tôt dans l’année : Le Mur-Lumières.


CAO

Rendu 3D de notre mur lumière

Nous avons utilisé des outils de CAO pour perfectionné le design de l’ensemble et éviter les erreurs de conceptions.

Programmmation

Une petit partie du code de notre projet

Un script python permet de contrôler le comportement de l’ensemble des élements.

Assemblage

Assemblage de la machine

Pour concrétiser le projet nous avons réalisé la fabrication de tout le bâti et le câblage nécessaire au bon fonctionnement.


Introduction de notre projet :

Vue générale du Mur Lumières

Ce projet fait partie d’un lot de projets associés à l’escape Polytech, un escape-game réalisé par les enseignants chercheurs de Polytech qui ont décidés de demander de l’aide aux étudiants pour créer des mini-jeux futurs. Le nôtre consiste à reproduire une forme sur un écran d’ampoules Philips HUE 5×5 à l’aide de boutons qui pilotent les ampoules : à vous de trouver la bonne combinaison !

Création du bâti :

Dans notre projet, il nous a fallu créer un bâti pour pouvoir stocker tous les autres composants et déplacer le tout facilement. Ainsi, l’utilisation de SolidWorks nous a paru nécessaire pour créer ce que nous avons choisi de faire : une borne d’arcade. Cette partie du projet n’a pas été la plus longue du fait que le bâti était plutôt simple à réaliser.
Cette CAO a ensuite permis la découpe puis l’assemblage des pièces dans du bois acheté chez un de nos fournisseurs.

Création du programme gérant les Ampoules Philips :

Pour contrôler les ampoules connectées, nous avons utiliser un pont Philips Hue se connecte aux ampoules avec le protocole ZigBee. Aussi, les 16 boutons que nous avons utiliser requièrent une carte PacLed 64 pour changer leurs couleurs simplement. Pour faire fonctionné tout les composants électronique ensemble nous avons utiliser un script python sur un Raspberry Pi 4. Ce programme permet de contrôler le clavier à l’aide d’un Arduino Uno, l’écran LCD, le pont, les boutons de couleurs avec la PacLed. Le code est pensé pour être le plus modulable et évolutif possible. Nous avons fait attention à ce que le code permette une grande résilience face aux éventuels petites interférences et perturbations qui pourrait survenir à cause de l’utilisation de fils non isolé pour transmettre de l’information entre les composants.

Assemblage et Tests réalisés à Polytech :

Une fois toute la partie programmation terminée, nous avons pu amener les planches découpées à Polytech pour y faire l’assemblage. Par la suite, nous nous sommes occupés de la longue partie concernant le branchement des multiples câbles (électriques et électroniques) avant de relier les cartes Arduino et Raspberry à nos autres composants.
Malgré quelques heures de complications à performer le code pour satisfaire toutes les conditions souhaitées, nous sommes arrivés à terminer le projet en temps et en heure !

Vue arrière du boîtier ouvert

Vue arrière du boîtier ouvert

Déroulement d’une partie :

Une partie peut donc se dérouler de la façon suivante :
– Le joueur arrive et sélectionne son niveau à l’aide du clavier qui lui confirme par la suite grâce au LCD

Ampoules de toutes les couleurs
panneau de commandes avec les boutons de couleurs

– Il essaye de trouver la bonne combinaison de boutons pour avancer dans le jeu et parvenir à trouver le résultat désiré
– Lorsqu’il trouve, un code s’affiche sur l’écran LCD et le joueur peut passer au niveau suivant.

Conclusion :

Grâce à l’importance de la communication et du travail d’équipe au sein de notre groupe, nous avons pu répondre à un cahier des charges qui semblait impossible si l’on s’y attaquait seul. Ce projet nous a d’autre part permis de développer nos compétences en CAO, en programmation et surtout nous a offert des connaissances en matière d’électricité, de moyens d’assemblages et sur bien d’autres domaines. Nous tenons à remercier encore une fois toutes les personnes ayant contribué au projet et nous espérons que ce projet, dont nous avons pris beaucoup de plaisir à réaliser, sera amené à être améliorer les prochaines années.

Le parking intelligent et automatisé

Comment réaliser une maquette de parking autonome et adaptable ?

Cliquez sur le titre pour voir: Vidéo du compte rendu du projet.

Le choix du projet

Nous sommes deux étudiants à Polytech Angers, Ahmad IBRAHIM et Hakim BOUKDAIR. Nous avions pour but de réaliser un projet tout au long du 2ème semestre, en 100 heures de cours, de 2ème année à Polytech, ce projet validera ou non notre année. Nous avions le choix entre plusieurs projets mais celui-ci est celui qui nous as le plus intéressé car il alliait du codage, de l’électronique et de la réalisation 3D.

photo du parking obtenu

photo du parking obtenu

Le but du projet

Le projet consiste à réaliser un parking qui soit autonome et qui soit adaptable à taille réelle. Il faut que l’on puisse afficher le nombre de places disponibles et réussir à faire payer chaque voiture s’étant garé dans le parking en fonction du temps resté. La maquette réalisée devra être réutilisable par d’autres personnes et être autonome.

Modélisation de notre parking vue de face

Modélisation de notre parking vue de face

 

Les différents logiciels

– Tinkercad : C’est un logiciel de modélisation 3D qui permet aussi de pouvoir coder en Arduino et de modéliser les différents circuits pour voir si les codes marchent. Ce logiciel nous as permit de pouvoir modéliser en 3D notre parking et de tester tous nos codes avant de les transférer sur la carte Méga. Le grand défaut de ce logiciel c’est qu’il n’était pas assez précis en termes de CAO pour pouvoir ensuite imprimer certaines pièces tel que les barrières ou les escaliers.

Modélisation de notre parking vu de derrière

Modélisation de notre parking vu de derrière

– On Shape : On Shape est un logiciel de modélisation en CAO qui permet de créer des pièces en 3D pour ensuite les imprimer pour notre parking. Nous en avons eu besoin pour faire les deux escaliers, les deux barrières, les deux bras moteur, l’ascenseur et le boitier pour cacher l’électronique.

Escalier réaliser en CAO sur On Shape

Escalier réaliser en CAO sur On Shape

Arduino ide : C’est un éditeur de code qui permet d’envoyer plusieurs programmes sur une carte Arduino à travers un port USB. Ces cartes sont électroniques, elles sont composées d’un microcontrôleur, d’un port USB et de connecteurs d’entrés et de sortie. On peut programmer en C ou en C++ et il y a des fonctions à disposition pour lire des entrées et écrire sur des sorties. A partir d’une carte, nous pouvons gérer des moteurs, des capteurs, des systèmes d’affichage, … Dans notre cas cela permettra de coder tout le système de notre parking avec tous ces différents composants.

Code Arduino, ici pour faire fonctionner un afficheur à 7 segments

Code Arduino, ici pour faire fonctionner un afficheur à 7 segments

 

Ce que l’on a appris

– Nous avons tout d’abord appris à utiliser les différents logiciels. Nous ne connaissions ni Arduino, ni On Shape. Cela nous a permis de coder sur Arduino et de savoir créer un circuit électronique à partir de la carte. Avec On Shape nous avons appris à maitriser le CAO et savoir créer des pièces à imprimer en 3D.

– De plus nous savons maintenant passer des commandes, savoir chercher les références, gérer un budget et surtout rectifier quand il y a un problème. Ce qui sera utile pour nos futurs projets. C’était notre premier grand projet, sur une aussi longue durée, il a fallu savoir gérer le temps et les différentes tâches.

Exemple de pièce à commander, en gardant la référence

Exemple de pièce à commander, en gardant la référence

– Ensuite nous maitrisons le fait de bien travailler à deux, de savoir mettre ses idées en communs, se répartir les tâches en fonction du niveau de l’un et de l’autre. Aussi le fait devoir s’imposer un planning et de devoir le respecter fût une partie compliquer, ce n’était pas dans nos habitudes. Nous avons, par la même occasion, su prendre en compte les remarques de notre professeur référant pour pouvoir rendre notre projet le plus performant possible.

Notre planning simplifié du projet à respecter

Notre planning simplifié du projet à respecter

– Enfin, nous possédions des contraintes pour réaliser ce parking que nous avons respectés. Tout d’abord le temps, comme dit précédemment, mais encore la contrainte pour la taille car il devait être adaptable à taille réelle, soit avoir une échelle pour faire la conversion facilement. De plus il y a des normes au niveau du parking qu’il faut respecter pour la taille des places handicapés par exemple. Toutes les contraintes n’ont pas pu être respectées du fait qu’il manquait déjà des pièces 3D, au niveau du codage nous n’avons pas réussis à rendre le parking payant comme voulu et pour finir le traçage du parking n’est pas aussi esthétique que nous le souhaitions.

Place parking normé pour handicapé, https://www.bms-sols.com/marquage-sol-parking-regles/

Place parking normé pour handicapé, https://www.bms-sols.com/marquage-sol-parking-regles/

 

 

Projet “Serrure customisée”

Bonjour à tous et toutes,

Nous sommes un groupe de trois étudiants de Polytech Angers en deuxième année Mélinda FABIEN, Lino TOURET, Hugo LEGENDRE. Dans le cadre d’un projet pédagogique, l’école souhaite créer une “armoire à énigme” possédant plusieurs modules. Parmi ceux-ci, une serrure customisée a été demandée.

20210611_174949

  • Introduction
  • Le but de ce projet est de créer une serrure capable d’être déverrouillée par plusieurs clés. Il faut que cette serrure soit assez complexe pour éviter la méthode “force brute” permettant de trouver le bon mot de passe en testant toutes les combinaisons.

    Nous avons donc divisé notre travail en trois parties. Premièrement, nous avons étudié les différentes possibilités concernant les types de capteurs à étudier. Cette étude nous permet d’analyser la demande et de trouver la solution la plus simple pour y répondre.

    Ensuite, nous sommes passés à la phase de développement. Nous avons testé les différents capteurs et formats de clé. Lors de cette étape, nous avons visualisé grâce au logiciel de CAO “Onshape”, notre future boîte ainsi que les possibles futurs emplacements des capteurs.

    Pour finir, nous avons fabriqué la boîte et mis en place les capteurs.

    Continuer la lecture

    Maquette maison intelligente

    Nous sommes deux étudiants, Justine et Adrien, en deuxième année du cycle préparatoire de Polytech Angers.
    Durant ce dernier semestre, nous avons pu travailler sur la conception et la réalisation d’une maquette de maison intelligente.

    L’objectif du projet
    Nous savons que le comportement des usagers d’un bâtiment a un impact significatif sur la consommation d’énergie mais ces données s’appuient uniquement sur des observations limitées. Grâce à la réalisation de cette maquette de maison équipée de capteurs enregistreur de données (telles que l’humidité, la luminosité ou encore la température), nous avons pu modéliser et étudier l’impact du comportement des occupants sur la consommation d’énergie.

    Les travaux réalisés

  • Modélisaton de la maquette sur Sketchup

  • Dans un premier temps, nous avons réalisé la maquette sur un logiciel de modélisation 3D.
    Nous avons utilisé le logiciel Sketchup, qui a l’avantage d’être gratuit.
    L’objectif principal de notre projet était de réaliser une maquette de maison afin d’y installer les différents capteurs. Nous avons décidé d’ajouter une autre contrainte, la maison doit être séparée en deux blocs : l’un isolé et l’autre non-isolé (mais tous deux équipés d’une lampe pour chauffer) afin de constater l’impact d’un isolant sur son environnement.

      Modélisation de la maquette en taille réelle

      Modélisation de la maquette en taille réelle

  • Codage des capteurs
  • Afin de mesurer les données, nous avons utilisé une carte Arduino Leonardo ainsi que différents capteurs :

      -Un pour la luminosité
      -Un pour détecter l’ouverture/fermeture des fenêtres
      -Un pour la température et l’humidité

    Il nous a alors fallu les coder dans le langage Arduino. Voici un exemple du code utilisé pour le capteur mesurant la température et l’humidité :

      Montage du capteur

      Montage du capteur

      Les mesures sont effectuées toutes les 5 secondes

      Ici les mesures sont effectuées toutes les 5 secondes

    Ci-dessous, le premier montage comprenant les trois capteurs cités précédemment. Il sera placé dans le toit qui comporte les ouvertures.

      montage

    Puis, nous avons réalisé un second montage, qui sera placé à l’intérieur des pièces, comportant les deux lampes et les deux sondes de température (plus précises que le capteur de température) :

      montage2

  • Réalisation de la maquette

  • Grâce à la modélisation, nous connaissions les dimensions de notre maquette. Malgré cela, nous avons rencontré quelques problèmes lors de cette étape : difficulté à la découpe, mauvais choix du matériau (notre premier choix était le PVC), etc..

    Nous avons finalement réalisé notre maquette en bois OSB et avons assemblé les différentes découpes avec des équerres.
    Il a ensuite fallu ajouter l’isolant (du polystyrène) dans la pièce concernée.

      Intérieur de la maquette

      Intérieur de la maquette

    Puis, nous avons réalisé le toit. Nous souhaitions qu’il contienne toute l’installation des capteurs, en ce sens, il devait pouvoir s’ouvrir afin d’en permettre l’accès.

      Maquette finale

      Maquette finale

    Par la suite, nous avons mis les capteurs dans la maquette : les deux montages sont installés dans le toit et nous avons placé les différents capteurs.

      Toit vue de l'intérieur des pièces

      Toit vue de l’intérieur des pièces

      Intérieur du toit

      Intérieur du toit

  • Recueil des données

  • Pour collecter nos données, nous avons utilisé un compilateur de données pour Excel qui permet de tracer un graphique en temps réel.
    Les essais des deux tests ont été réalisés dans les mêmes conditions.
    Pour le montage 2, nous devions choisir un temps d’éclairage des lampes (le même pour les deux pièces) avant que les données soient collectées afin de faire monter en température l’air des pièces.

      ezgif.com-gif-maker
      Résultat pour le montage n°2 avec 2min d'éclairage et une prise de données toutes les secondes

      Résultat pour le montage n°2 avec 2min d’éclairage et une prise de données toutes les secondes

      Résultat pour le montage n°2 avec 4min d'éclairage et une prise de mesures toutes les 5sec

      Résultat pour le montage n°2 avec 4min d’éclairage et une prise de mesures toutes les 5sec

    Ainsi, on peut constater que la température de la pièce isolée augmente plus que dans la pièce non-isolée, mais elle diminue aussi plus rapidement.
    Nous pensons que nos essais ayant étaient faits lors d’une chaude journée, la température de la pièce non-isolée est restée assez constante par rapport à l’extérieur entraînant une faible différence entre pièce chauffée et non-chauffée.

    Conclusion
    Ce projet fut très enrichissant pour la suite de nos études puisqu’il nous a permis d’apprendre à maîtriser un logiciel de modélisation, de découvrir le langage Arduino et de coder des capteurs. Il nous a également apporté au point de vue personnel : nous avons pu développer certaines compétences telles que l’autonomie, la communication ou encore l’organisation qui sont, de plus, des compétences indispensables en tant qu’ingénieur.
    Nous tenons à remercier Mr.Riahi, notre professeur encadrant, pour son aide apportée tout au long de ce projet.

    Système de stationnement automatisé sur Arduino​

    Bonjour à toutes et à tous !

    Introduction

    Nous sommes Esteban Cornu, Mattéo Jupille et Alexis Maupas des élèves en deuxième année de cycle préparatoire ingénieur et nous allons vous présenter notre projet intitulé “Système de stationnement automatisé sur Arduino”. Ce projet nous a vraiment attiré lors de la sélection car il correspond au domaine dans lequel nous souhaitons évoluer dans le cycle d’ingénieur. En effet, le projet possède toute une partie basée sur la programmation qui fait écho à la filière SAGI ainsi que sur la partie qualité, innovation et fiabilité qui nous initie à la filière QIF.
    Le but est dans un premier temps de découvrir l’Arduino sur laquelle aucun de nous n’avait travaillé auparavant, mais nous étions tous impatients de commencer. Dans un second temps, le projet a permis de nous faire découvrir toutes les étapes à suivre pour mener à bien un projet. Pour cela, il faut s’organiser en répartissant correctement les tâches au sein du groupe dans le but d’être plus efficace. Tout au long du projet nous avons été épaulés par Monsieur Haddad.

    Objectifs du projet

    1. Trouver un moyen pour rendre un parking autonome
    2. Concevoir et Programmer un parking situé en plein cœur d’une ville
    3. Réaliser une maquette fonctionnelle de ce parking

    Travail réalisé

    1. Etude d’automatisation

    Nous avons établi trois possibilités pour réaliser ce parking automatisé. La première option consiste à utiliser une carte Arduino avec deux caméras à reconnaissance de plaque d’immatriculation. La deuxième sollicite une carte Arduino avec des capteurs optiques et la dernière se compose d’une carte Raspberry Pi avec deux caméras à reconnaissance de plaque.

    Comparaison des 3 options

    Après avoir comparé les 3 alternatives en fonction du prix, de la fiabilité, de la complexité nous avons retenu la deuxième option.

    Explication du fonctionnement :
    Un écran LCD indique le nombre de places restantes si le nombre de place est supérieur à 0 alors un véhicule peut rentrer. Des capteurs optiques placés sous le sol avant et après la barrière vérifient si la voiture est bien rentrée avant de refermer la barrière. La barrière s’ouvre et se ferme à l’aide d’un servomoteur. Puis la voiture peut se garer sur n’importe quelle place libre. Pour aider le conducteur nous avons placés des LED vertes et rouges au bout de chaque place. Si la LED est verte alors la place est libre, elle passera au rouge lorsque le véhicule sera bien garé au-dessus du capteur optique présent sur chaque place. A chaque fois qu’une voiture se gare un chronomètre associé à la place est lancé ce qui permet de vérifier le temps passé dans le parking. Lorsqu’un automobiliste décide de partir, l’écran affiche le prix à payer en fonction du chronomètre lié à sa place puis il peut partir par la barrière de sortie fonctionnant de la même manière que celle d’entrée.

    2. Conception du parking

    A. Agencement Parking

    Nous devions ensuite imaginer l’agencement des places de parking ainsi que la position des barrières d’entré et de sortie mais aussi prévoir un emplacement pour cacher la carte Arduino.

     Croquis Parking Arduino

    Nous avons ajouté deux places de parking pour personnes à mobilité réduite selon l’arrêté du 1er août 2006 en respectant les normes.
    Le temps était maintenant venu pour nous de réaliser ce parking en 3D à l’aide du logiciel en ligne OnShape en taille réelle. Cette étape a pour but de nous aider à dimensionner le projet mais aussi de nous projeter dans le futur pour connaitre précisément l’emplacement de chaque composant.

    Parking En 3D

    Parking de 30m x 16m

    B. Programmation

    Afin de pouvoir contrôler tous les composants nous avons utilisé une carte Arduino MEGA car il fallait beaucoup d’entrées analogiques pour les capteurs optiques ainsi que beaucoup de sorties digitales pour contrôler chaque LED.

    Sachant que nous attendions la livraison des composants nous en avons profité pour réaliser des tests sur le logiciel en ligne TinkerCad qui permet de simuler une carte Arduino pour venir y connecter des composants eux aussi virtuels. Ces nombreux tests nous ont permis de comprendre le fonctionnement de chaque composant ainsi que la manière de le brancher à la carte. Nous avons donc utilisé les librairies ServoMoteur et LiquidCrystal pour contrôler la barrière et l’écran LCD facilement. Cette étape nous a fait gagner beaucoup de temps car dès la réception des composants nous avons pu passer à la réalisation sans trop se soucier si le parking fonctionnera une fois l’assemblage des pièces 3D et de la planche en bois terminé.

    TinkerCad-LCD

    TinkerCad-LCD

    3. Réalisation de la maquette

    La réalisation de la maquette à commencer lorsque nous avons reçu nos composants. Nous avons d’abord tracé l’emplacement de chaque élément (places, pièces 3D, …) pour ensuite commencer à découper la planche.

    Découpage de la planche

    Découpage de la planche

    Perçage de la planche

    Perçage de la planche

    Soudure des composants

    Soudure des composants

    Après le découpage et le percage de la planche nous avons placé tous les composants ainsi que tous les pièces 3D.

    L’étape suivant était de souder tous les composants entre eux afin de les connecter à la carte Arduino ce fut très long et périlleux en raison du nombre de composants à alimenter.

    Nous avons ajoutés quelques détails comme les panneaux de sens interdit et les signalisations pour les places handicapées.

    Résultat final

    Conclusion

    Pour conclure, nous sommes très reconnaissants d’avoir participé à ce projet pour clôture notre deuxième année préparatoire. En effet, nous avons pu découvrir ou approfondir plusieurs domaines comme la programmation Arduino, la conception assistée par ordinateur, la gestion du temps, la fabrication d’une maquette fonctionnelle, … En plus des connaissances, nous avons appris à concevoir de A à Z un projet ce qui va beaucoup nous aider dans nos futures missions en tant qu’étudiant en école d’ingénieur. Nous sommes très fiers car nous considérons avoir réussi à répondre correctement au cahier des charges en essayant d’innover. Nous profitons de cette conclusion pour remercier Monsieur Haddad pour nous avoir accompagné à concevoir ce projet.

    Esteban Cornu Mattéo Jupille Alexis Maupas

    Compteur binaire motorisé

    Nous sommes un groupe de 3 étudiants de PEIP 2A constitué de Mattéo NAIS, Emylien PAUTONNIER et Hugues THEZELAIS. Dans le cadre des projets tutorés nous avons travaillé sur un projet de compteur binaire motorisé tenant dans une mallette pour être facilement transportable sur les différents salons et forums.
    Ce projet est un mélange d’électronique, de mécanique et de CAO dans lequel chacun pouvait exprimer ses qualités respectives.

    Objectif

    Nous avons été assez libre dans la conception de notre projet. Les consignes que nous avons reçues étaient de réaliser un compteur binaire mécanique accompagné d’un compteur décimal, le tout dans une mallette. Pour nous faire comprendre le principe de ce projet, la vidéo suivante accompagnait la consigne.

    Nous avons choisi d’utiliser un compteur binaire avec 8 bits pouvant donc compter de 0 à 255. Nous avons également décidé de créer notre propre compteur décimal en 7-segments avec 3 chiffres. Pour cela, nous nous sommes inspiré de l’horloge suivante que nous avons adapté en compteur.

    Déroulement

    Nous pouvons catégoriser le déroulement du projet en 2 parties:

    • La première partie s’étend du début des séances en janvier jusqu’à début avril. Durant ses séances, le travail était essentiellement en distanciel. Nous avons d’abord brainstormé quelques séances sur la conception du projet, puis nous nous sommes répartis le travail. Pendant qu’un de nous réalisait les pièces du compteur binaire sur Solidworks, un autre concevait la plaque de 7 segments qui allait servir au compteur décimal et le troisième recherchait le matériel qui allait nous être utile.
    Capture du compteur binaire en CAO

    Pièces du compteur binaire sur Solidworks (face 1)

    Capture du compteur binaire en CAO

    Pièces du compteur binaire sur Solidworks (face 0)

      Ensuite, nous nous sommes concentrés sur la partie la plus compliquée du projet pour nous : le codage du compteur décimal, puisque nous ne connaissions rien à l’Arduino.
    • La deuxième partie s’étend de début avril jusqu’à la fin des séances en juin, c’est la réalisation du projet. Cette partie a été, pour nous, plus intéressante car les séances étaient désormais en présentiel dans l’atelier de Polytech et nous pouvions constater l’avancement au fur et à mesure que nous réalisions nos pièces. Nous avons également pu utiliser des machines pour la première fois telles que l’imprimante 3D et la fraiseuse.
    Plaque découpée à la fraiseuse

    Plaque des 7 segments découpée à la fraiseuse

    2 palets imprimés en 3D

    Palets du compteur binaire imprimés en 3D

      Nous avons préféré le travail à Polytech car il y avait beaucoup de travail manuel pour réaliser le compteur décimal, les potences du compteurs binaires et le design de la mallette.

      disposition des compteurs dans la mallette

      Disposition des éléments dans la mallette

      Le projet s’est grandement accéléré les dernières semaines car nous avons soudé les LEDs NeoPixels du compteur binaire. Cette étape fut très importante car nous avons pu testé nos compteurs binaire et décimal en conditions réelles. Bien que la partie réalisation fut plus plaisante que la partie conception, nous avons néanmoins dû faire face à de nombreux problèmes et de nombreuses frustrations.

    Problèmes rencontrés

    Ce projet n’a pas été de tous repos et nous avons fait face à de nombreuses difficultés. Les premières difficultés rencontrées étaient liées au code du compteur décimal. Notre code ne comptait pas le 9 aux dizaines et passait de 89 à 100 et de 189 à 200. Heureusement, notre professeur encadrant, M. Godon, nous a aidé en nous montrant ce qui n’allait pas. De plus, nous n’arrivions pas à repartir à 0 après 255.
    Comme je l’ai dit dans la partie précédente, la réalisation nous a causé de nombreux problèmes. A chaque nouvelle séance nous avions une mauvaise surprise. Parfois c’était une pièce conçue la séance précédente qui n’était pas bonne, d’autre fois c’était une machine qui était en panne et qui nous empêchait d’avancer comme on le voulait ou bien notre compteur décimal qui ne marchait plus soit car les soudures s’étaient défaites, soit car les LEDs ne fonctionnaient pas (sûrement parce qu’elles avaient cramé).
    Lorsque nous avons testé tout le projet dans son ensemble, c’est-à-dire, avec les deux compteurs dans la mallette fonctionnant synchroniquement, nous nous sommes aperçus que le moteur pas-à-pas du compteur binaire n’était plus assez puissant, alors que nous avions fait des tests réussis sur le compteur binaire au préalable.

    Conclusion

    Ce projet a été très enrichissant pour nous trois, nous avons su travailler en équipe, écouter nos idées et exploiter les qualités de chacun pour travailler efficacement et rendre le travail le plus complet possible. Le projet nous a permis de mettre en pratique ce que nous avons appris ces deux dernières années et nous a fait découvrir de nouvelles choses que nous pourrons possiblement revoir dans la suite de nos études et plus tard. Nous avons été amenés à tester notre réactivité face aux problèmes rencontrés et nous avons su trouver des alternatives rapidement et très souvent par nous-mêmes.
    Globalement, nous sommes satisfaits et fiers de notre travail malgré le problème rencontré en toute fin de projet sur le moteur du compteur binaire.

    Création d’un arrosage automatisé

    Bonjour à toutes et à tous !

    Dans cet article vous trouverez des bonnes et des mauvaises raisons de s’engager dans la création d’un arrosage automatique et surtout notre démarche face à ce projet.

    Selon des estimations compilées par l’Organisation pour l’alimentation et l’agriculture (FAO), d’ici à 2050, la production alimentaire devra augmenter de 60 % pour nourrir une population mondiale de 9,3 milliards. Continuer à cultiver les terres selon nos habitudes exercerait une forte pression sur nos ressources naturelles. Nous n’avons donc pas d’autre choix que d’entreprendre une révolution plus verte. Sachant que plus nous serons nombreux, plus nos besoins en eau seront importants : il devient donc essentiel de commencer dès que possible à arroser nos plantes le plus écologiquement possible. Nous sommes deux étudiantes en deuxième année préparatoire intégrée de Polytech Angers et nous nous sommes intéressées au projet de la création d’un arrosage automatique.

    Maquette finale d'un arrosage automatisé

    Maquette finale d’un arrosage automatisé

    Notre principal objectif est de créer un arrosage automatisé qui soit à la fois économique et écologique. Pour cela, nous avons dû faire des choix concernant les types d’arroseurs, le matériel que nous avons besoin et les différents capteurs qui nous seront utiles. La première phase de notre projet a donc été la recherche ainsi que la création d’une carte mentale regroupant tous les points essentiels pour réaliser notre arrosage automatique.

    Voici notre carte mentale avec les éléments que l'on a jugé importants de prendre en compte

    Notre carte mentale avec les éléments que l’on a jugé importants de prendre en compte

    Dans un premier temps et avec nos moyens, il a été préférable de concevoir une maquette afin d’être capable de bien visualiser l’ensemble du projet ainsi que de pouvoir le réaliser à petite échelle et observer son fonctionnement. Ce qui, dans un second temps, pourra être réalisé à l’échelle d’un champ de maraîcher en redimensionnant l’ensemble.

    Voici quelques schémas :

    Schéma général avec les raccords en eau

    Schéma général avec les raccords en eau

    Schéma vue de dessus à l'intérieur du bac potager

    Schéma vue de dessus à l’intérieur du bac potager

    Schéma de notre boitier Arduino comprenant deux étages -1er étage : la breadboard -2ème étage : la carte Arduino UNO

    Schéma de notre boitier Arduino comprenant deux étages
    -1er étage : la breadboard
    -2ème étage : la carte Arduino UNO

    Cette maquette a aussi été conçu sur SolidWorks. En effet, les schémas 3D permettent une meilleure visualisation de l’ensemble et des erreurs s’il y en a.

    Schéma vue de côté réalisé sur SolidWorks Vous pouvez observer le bac potager contenant 4 plants, les tuyaux, les 4 goutteurs ainsi qu'un capteur d'humidité des sols et un capteur de luminosité. À sa gauche deux autres capteurs mesurant la température et l'humidité de l'air. Il y a également la cuve remplit d'eau tout à gauche contenant le capteur de niveau d'eau. Au milieu on retrouve le boitier Arduino fermé avec la pompe et le servomoteur remplaçant l'électrovanne.

    Schéma vue de côté réalisé sur SolidWorks
    Vous pouvez observer le bac potager contenant 4 plants, les tuyaux, les 4 goutteurs ainsi qu’un capteur d’humidité des sols et un capteur de luminosité. À sa gauche deux autres capteurs mesurant la température et l’humidité de l’air. Il y a également la cuve remplit d’eau tout à gauche contenant le capteur de niveau d’eau. Au milieu on retrouve le boitier Arduino fermé avec la pompe et le servomoteur remplaçant l’électrovanne.


    Schéma vue de dessus réalisé sur SolidWorks

    Schéma vue de dessus réalisé sur SolidWorks

    Déroulement du projet

    Par la suite, ce projet s’est décomposé en trois grandes étapes.

    La première a été essentielle pour anticiper les éventuelles difficultés que l’on pourrait rencontrer. Il s’agit de la création du cahier des charges. Ce dernier étant le pilier de tout projet, il faut donc être précis dans la rédaction et prévenir des éventuels problèmes que l’on pourrait rencontrer lors des différentes étapes de la réalisation de la maquette. Notre cahier des charges regroupe les différentes fonctions que notre arrosage automatique remplit, les résultats attendus, les spécifications techniques et les spécifications fonctionnelles.

    La seconde étape a été la découverte et la prise en main du matériel Arduino. Une phase plutôt compliquée pour nous, car, nous n’avions que très peu de connaissances sur Arduino. Nous avions donc commencé par beaucoup de recherches et de tests, élément par élément, comme la simple action d’allumer une LED.

    Branchement de la breadboard avec la carte Arduino

    Branchement de la breadboard avec la carte Arduino

    Branchement final pour allumer la LED

    Branchement final pour allumer la LED

    LED allumée grâce au code retranscrit sur la carte Arduino

    LED allumée grâce au code retranscrit sur la carte Arduino

    Ensuite, nous avons cherché à faire marcher chaque capteur séparément. Une fois que le programme fonctionnait et que nous trouvions des mesures cohérentes, nous avons branché les capteurs ensemble et rassemblé les programmes sur un même fichier Arduino. Cela nous a permis d’avoir toutes les données nécessaires pour être en mesure d’automatiser l’arrosage.

    Branchement final Arduino avec tous les capteurs

    Branchement final Arduino avec tous les capteurs

    Résultats observés sur le moniteur de série

    Résultats observés sur le moniteur de série

    La réalisation de la maquette complète, étant la dernière étape, n’a été que partiellement exécutée. En effet, nous nous sommes concentrées sur la partie hydraulique puis la partie électrique mais nous avons manqué de temps pour les réunir. De plus, nous n’avons pas réussi à transférer nos données sur une application. Nous nous sommes contentées d’observer les résultats sur Arduino.

    Les problèmes rencontrés

    Plusieurs problèmes ont pu être rencontrés au cours de ce projet que ce soient des manques de connaissances dans un domaine, des problèmes de précision ou bien des soucis de matériel. Au final, toutes ces contraintes nous ont surtout conduit à un manque de temps pour finir notre maquette.

    Conclusion

    La création d’un arrosage automatique est un projet très complet. Il nous faut être capable de concevoir l’ensemble de notre arrosage automatique sans même toucher au matériel, cela nécessite une grande réflexion. Il nous faut aussi gérer la partie budget, trouver les bons produits avec le meilleur rapport qualité/prix. Il y a aussi un vocabulaire technique propre à ce domaine qu’il nous a fallu apprendre ainsi que les caractéristiques de chaque élément. Certaines étant très importantes à prendre en compte afin de relier les éléments entre eux. Par exemple, l’absorption d’eau et la pression maximale doivent dépasser un certain seuil en fonction des goutteurs que l’on choisit. De même, les diamètres sont également à surveiller pour ne pas se tromper dans les tuyaux.

    Les caractéristiques de notre pompe à eau

    Les caractéristiques de notre pompe à eau


    Nous avons aussi pu enrichir notre culture personnelle sur la façon de bien arroser ses plants selon les méthodes de maraîchers.

    La CAO a aussi été un point sur lequel nous avons dû progresser mais la plus grande évolution concerne la partie électronique. En effet, nous avons eu aucune préparation préalable avec Arduino, la création de programme a donc été parfois compliquée.
    Pour finir, notre intérêt pour ce projet n’a fait qu’augmenter de séance en séance. Il nous a permis d’acquérir de nombreuses compétences que l’on n’aurait peut-être pas développées avec un autre projet. Ce travail a été une source de développement de notre autonomie, et de notre réflexion sur un projet global.

    Cet article touche à sa fin, en espérant qu’il vous aura plu.
    Merci pour votre lecture !

    Display box

    Bonjour à tous,

    Nous sommes 4 étudiants de PeiP 2, Théo ROY, Zacharie FOURRIER, Alexandre PRAT et Eli DESTOMBES.
    Dans le cadre de notre projet de conception nous avons travaillé sur une display-box.
    L’objectif de notre projet est de réaliser différents programmes qui gèrent des écrans dans le but de les intégrer à un projet d’escape Game.
    Nous avons tous travaillé sur Arduino mais aussi sur AppInventor ou python pour certains.
    Nous avons donc réalisé 5 mini-projets et nous allons vous montrer comment les utiliser !

    Projet n°1 : Clavier tactile et code secret – Réalisé par Eli DESTOMBES
    Le but de mon projet est de réaliser un clavier tactile à code secret qui avec le bon code va changer de fenêtre pour afficher une nouvelle fenêtre.
    Je vais donc vous montrer comment le coder.

    Mot clé : 2.4 ‘’ TFT LCD SHIELD, Arduino, clavier tactile , clavier azerty

    1ère Étape : Préparation
    1.1 Les librairies

    Pour ce qui est du matériel j’ai utilisé un écran 2.4 ‘’ TFT LCD SHIELD et une carte Arduino UNO
    Maintenant voici les librairies Arduino que nous allons utiliser :

    – Adafruit GFX

    Vous pouvez l’installer depuis Arduino, pour cela faite « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèques puis cherchez Adafruit GFX. Elle fournit une syntaxe et un ensemble de fonction graphiques pour les écrans LCD et OLED

    Vous pouvez l’installer depuis Arduino, pour cela faite « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèque puis chercher Adafruit GFX.
    Elle fournit une syntaxe et un ensemble de fonction graphique pour les écrans LCD et OLED


    – Adafruit TFTLCD
    De la même façon, vous la trouverez dans le gestionnaire de bibliothèques en cherchant Adafruit TFTLCD. Pour vérifier que la bibliothèque est bien installée et que votre écran fonctionne, allez dans Fichier -> Example -> Adafruit TFTLCD Library -> graphictest puis exécutez le programme

    De la même façon, vous la trouverez dans le gestionnaire de bibliothèque en cherchant Adafruit TFTLCD. Pour vérifier que la bibliothèque est bien installée et que votre écran fonctionne, allez dans Fichier -> Example -> Adafruit TFTLCD Library -> graphictest puis exécutez le programme


    – Adafruit TouchScreen
    De la même façon vous la trouverez dans le gestionnaire de bibliothèques en cherchant TouchScreen. Pour vérifier que le tactile fonctionne, allez dans Fichier -> Example -> Adafruit TouchScreen -> touchscreendemo puis ouvrir le moniteur série et exécutez le programme. Appuyez sur l’écran et regarder le moniteur pour voir si des coordonnées apparaissent.

    De la même façon vous la trouverez dans le gestionnaire de bibliothèque en cherchant TouchScreen. Pour vérifier que le tactile fonctionne, allez dans Fichier -> Example -> Adafruit TouchScreen -> touchscreendemo puis ouvrir le moniteur série et exécutez le programme. Appuyez sur l’écran et regardez le moniteur pour voir si des coordonnées apparaissent.


    – String
    La librairie String.h est installée de base sur Arduino

    1.2 Définitions des PINs
    PIN pour l’écran

    #define LCD_CS A3 // Chip Select va vers Analog 3
    #define LCD_CD A2 // Command/Data va vers Analog 2
    #define LCD_WR A1 // LCD Write va vers Analog 1
    #define LCD_RD A0 // LCD Read va vers Analog 0
    #define LCD_RESET A4

    PIN pour la position du tactile

    #define YP A2
    #define XM A3
    #define YM 8
    #define XP 9

    1.3 Définition des coordonnées max et min pour un écran 2.4 ‘’ TFT

    #define TS_MINX 204
    #define TS_MINY 195
    #define TS_MAXX 948
    #define TS_MAXY 910

    Nous allons aussi utiliser différentes couleurs, il est donc utile de définir les couleurs que vous allez utiliser avec :
    #define nom_de_la_couleur code_hexa_de_la_couleur

    2ème Étape : Trouver le driver LCD

    C’est une étape importante car sans le bon driver l’écran ne peut pas marcher, pour trouver le bon driver il faut ouvrir le programme d’exemple tftbpm qui est dans Adafruit TFTLCD Library.
    Il faut ouvrir le moniteur série et lancer le programme (avec votre écran connecté à l’Arduino).
    Dans le moniteur une ligne apparait : Found ILI9341 LCD driver (ou un autre code), ensuite il faut aller chercher dans le code pour trouver le code hexadécimal du driver

    Une fois le driver trouvé il faut écrire dans le void setup() :
    tft.begin(0x9341);
    Il faudra aussi écrire cette ligne avant le void setup() pour que l’écran fonctionne :
    Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
    Il est possible que le programme ne fonctionne pas correctement et que le moniteur ne trouve pas le driver. C’est un problème que j’ai eu et pour le résoudre j’ai suivi cette vidéo :
    https://www.youtube.com/watch?v=Tj-DjKAp770

    3ème Étape : affichage du clavier


    Pour l’affichage du clavier j’ai créé une fonction clavier() que j’utilise dans le void setup(), comme cela elle va apparaitre au démarrage du programme.

    3.1 Affichage des rectangles

    Pour dessiner les cases autours des lettres j’ai utilisé la fonction tft.drawRect qui se construit de la façons suivante :
    tft.drawRect( x, y, l, h, COLOR) ;
    Avec :
    • x : coordonnée en x du point de départ du rectangle
    • y : coordonnée en y du point de départ du rectangle
    • l : la largeur du rectangle
    • h : la hauteur du rectangle
    • COLOR : la couleur du rectangle
    Cela va créer un rectangle vide avec un contour de la couleur choisie.

    Si vous voulez un rectangle rempli il faut utiliser la fonction tft.fillRect qui se construit de la même façon que tft.drawRect :
    tft.fillRect( x, y, l, h, COLOR) ;
    Avec :
    • x : coordonnée en x du point de départ du rectangle
    • y : coordonnée en y du point de départ du rectangle
    • l : la largeur du rectangle
    • h : la hauteur du rectangle
    • COLOR : la couleur du rectangle

    3.2 Affichage du texte

    Pour écrire du texte nous allons avoir besoin de 5 fonctions.
    La première est tft.setCursor qui sert à placer le point de départ du texte :
    tft.setCursor( x, y) ;
    Avec :
    • x : coordonnée x du point de départ
    • y : coordonnée y du point de départ

    Ensuite il y a tft.TextColor qui va changer la couleur du texte :
    tft.setTextColor(COLOR) ;
    Avec :
    • COLOR : couleur du texte

    Puis, pour gérer la taille du texte il y a la fonction tft.setTextSize :
    tft.setTextSize(n) ;
    Avec :
    • n : un entier compris entre 1 et 5. La taille de base est de 1 et chaque augmentation de 1 augmente la hauteur du texte de 10 pixels.

    Enfin pour écrire du texte, il existe deux fonctions.
    La première, tft.print ou tft.println , qui écrit tous les caractères non spéciaux
    tft.println(“ ”) ;
    La deuxième, tft.write , qui permet d’écrire des caractères spéciaux avec leur code hexadécimal
    tft.write(0xXX) ;

    Exemple de création d’une touche du clavier :
    tft.drawRect(6, 120, 28, 36, RED); // on utilise 2 fois la fonction drawRect
    tft.drawRect(7, 121, 26, 34, RED); // pour faire une plus grosse épaisseur
    tft.setCursor(10, 125); // on place le curseur a la postition 10 x , 125 y
    tft.setTextColor(WHITE); // on met le texte en blanc
    tft.setTextSize(4); // on met le texte de taille 4
    tft.print("A"); // on écrit le caractère A

    4ème Étape : Position sur l’écran et chaine de caractères

    Pour commencer, il faut déclarer ces lignes avant le void setup() pour que les fonctions de position marchent :
    TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
    boolean buttonEnabled = true;

    On déclare une variable buttonEnabled qui va nous servir plus tard pour nos touches.
    et pour que notre chaine de caractères fonctionne :
    String chaineCara;

    4.1 Affichage d’un caractère

    Pour cette partie on va créer une nouvelle fonction menu()
    On commence par écrire TSPoint p = ts.getPoint(); qui nous permet de récupérer la position de l’appui sur l’écran.
    La librairie TouchScreen fonctionne avec 3 coordonnées, x ,y et z. Pour détecter un appui on se sert de la position Z comme cela :

    if (p.z > ts.pressureThreshhold) {

    p.x = map(p.x, TS_MAXX, TS_MINX, 0, 320);
    p.y = map(p.y, TS_MAXY, TS_MINY, 0, 240);

    Serial.print("X = "); Serial.print(p.x);
    Serial.print("\tY = "); Serial.print(p.y);
    Serial.print("\n");

    La fonction map permet de bouger un intervalle de valeurs vers un autre,
    map(value, fromLow, fromHigh, toLow, toHigh)
    Avec :
    •value: le nombre à “mapper”
    •fromLow: La borne inférieure de la valeur actuelle
    •fromHigh: La borne supérieure de la valeur actuelle
    •toLow: La borne inférieure de la valeur visée
    •toHigh: La borne supérieure de la valeur visée

    On l’utilise ici pour replacer entre 0 et 320 pour x et entre 0 et 240 pour y car
    Ici quand on va appuyer sur l’écran on va avoir la position x et y,
    Pour définir la zone d’appui d’une lettre j’ai utilisé ceci :
    if (p.x > 6 && p.x 80 && p.y 37 && p.x 80 && p.y < 120 && buttonEnabled) {

    pinMode(XM, OUTPUT);
    pinMode(YP, OUTPUT);

    chaineCara = chaineCara + "Z";
    longueur = chaineCara.length();

    et on continue avec des else if pour chaque touche que l’on a créée.

    4.2 Suppression d’un caractère

    Pour supprimer un caractère j’utilise ceci :
    chaineCara = chaineCara.substring(0, longueur - 1);
    cette ligne permet de retirer un caractère dans la chaine mais pas sur l’écran, il faut donc aussi le supprimer à l’écran.
    Pour cela je crée des rectangles de la couleur du fond que je superpose avec les lettres pour les effacer.
    if (longueur == 8 ) {
    tft.fillRect(213, 30, 24, 30, BLACK);
    } else if (longueur == 7 ) {
    tft.fillRect(189, 30, 24, 30, BLACK);
    }
    else if (longueur == 6) {
    tft.fillRect(165, 30, 24, 30, BLACK);
    }
    else if (longueur == 5 ) {
    tft.fillRect(141, 30, 24, 30, BLACK);
    }
    else if (longueur == 4 ) {
    tft.fillRect(117, 30, 24, 30, BLACK);
    }
    else if (longueur == 3 ) {
    tft.fillRect(93, 30, 24, 30, BLACK);
    }
    else if (longueur == 2 ) {
    tft.fillRect(69, 30, 24, 30, BLACK);
    }
    else if (longueur == 1 ) {
    tft.fillRect(45, 30, 24, 30, BLACK);
    }
    }

    4.3 Limiter la taille de la chaine de caractères

    Pour limiter la taille de la chaine de caractères, j’ai fait un if qui encadre tout ce que nous avons fait dans la partie 4 :
    unsigned long menu() {
    int longueur = 0 ;
    TSPoint p = ts.getPoint(); //Get touch point
    longueur = chaineCara.length(); // calcul de la longueur de la chaine
    if (longueur < 9) { //on limite la taille de la chaine à 9
    … // code du 4.1 et 4.2
    } else {
    chaineCara = chaineCara + "" ; //on ajoute rien a la chaine
    if (p.z > ts.pressureThreshhold) {
    p.x = map(p.x, TS_MAXX, TS_MINX, 0, 320);
    p.y = map(p.y, TS_MAXY, TS_MINY, 0, 240);
    if (p.x > 192 && p.x < 220 && p.y > 1 && p.y < 40 && buttonEnabled) {
    pinMode(XM, OUTPUT);
    pinMode(YP, OUTPUT);
    chaineCara = chaineCara.substring(0, longueur - 1);

    if (longueur == 9 ) {
    tft.fillRect(237, 30, 24, 30, BLACK);
    }}}}}

    5ème Étape : void setup et void loop

    5.1 construction du void setup()


    void setup() {
    tft.reset(); //reset l’écran
    tft.begin(0x9341); // voir étapes 2
    Serial.begin(9600); la valeur doit être la même que celle du moniteur
    tft.setRotation(3); // rotation de 0,90,180,270° respectivement 0,1,2,3
    tft.fillScreen(BLACK); // remplis d’écran de noir
    rectangle();//fonction qui crée le grand rectangle du milieu
    clavier(); // fonction de l’étape 4
    }

    5.2 construction du void loop(void)

    void loop(void) {
    menu() ;
    if (chaineCara == "CODEBON") { //on vérifie que la chaine correspond au
    //code
    buttonEnabled = false; //on désactive la variable buttonEnabled pour ne plus pouvoir appuyer sur les boutons une fois le code trouver
    ...
    }
    delay(100) ; // on met un petit délais pour ne pas doubler les lettres quand on appuie sur les boutons
    }

    Nous voilà donc à la fin de ce projet, voici une petite vidéo qui montre comment fonctionne le programme :
    https://www.youtube.com/embed/8LQWGmZC6mI?feature=oembed

    Projet n°2: Affichage LCD via Application Bluetooth – Réalisé par Alexandre PRAT

    Mot clé : ESP32, LCD I2C 16×2, Arduino, AppInventor

    1ère Étape : Préparation
    1.1 Les librairies

    Voici les librairies que j’ai dû utiliser :
    – LiquidCrystal_I2C

    Vous pouvez l’installer depuis Arduino, pour cela faites « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèques puis cherchez LiquidCrystal_I2C. Elle fournit différentes fonctions permettant d’utiliser l’écran LCD 16x2.

    Vous pouvez l’installer depuis Arduino, pour cela faites « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèques puis cherchez LiquidCrystal_I2C.
    Elle fournit différentes fonctions permettant d’utiliser l’écran LCD 16×2.


    J’utilise également les librairies wire.h et bluetoothserial.h qui sont déjà installées d’origine !

    1.2 Les branchements

    Pour commencer, branchez votre écran LCD à l’esp32 via le module I2C comme présenté sur le schéma ci-dessous :

    1.3 Premiers essais
    Pour tester les branchements et le fonctionnement de l’écran LCD, voici un premier programme de test permettant d’afficher « Hello, world ! » sur l’écran LCD :

    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>

    LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line display // intervertir avec la ligne suivante si cela ne fonctionne pas
    //LiquidCrystal_I2C lcd(0x3F,16,2);

    void setup()
    {
    lcd.init(); // initialize the lcd

    // Print a message to the LCD.
    lcd.backlight();
    lcd.print("Hello, world!");
    }
    void loop()
    {
    }

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/ETuXsmyVzaNLhhckV4ArAuABKRGD0vT94XGYc4X-SkFDtg?e=zFpGZ9

    Si cela ne fonctionne pas, vous pouvez commenter le ligne « LiquidCrystal_I2C lcd(0x27,16,2); » et décommenter la ligne « //LiquidCrystal_I2C lcd(0x3F,16,2); » .

    Si cela ne règle pas votre problème, vous pourrez exécuter le programme ci-dessous, en remplaçant 0x27 ou 0x3F par le code hexadécimal affiché dans le moniteur série :

    #include <Wire.h>

    void setup() {
    Wire.begin();
    Serial.begin(115200);
    Serial.println("\nI2C Scanner");
    }
    void loop() {
    byte error, address;
    int nDevices;
    Serial.println("Scanning...");
    nDevices = 0;
    for(address = 1; address < 127; address++ ) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0) {
    Serial.print("I2C device found at address 0x");
    if (address<16) {
    Serial.print("0");
    }
    Serial.println(address,HEX);
    nDevices++;
    }
    else if (error==4) {
    Serial.print("Unknow error at address 0x");
    if (address<16) {
    Serial.print("0");
    }
    Serial.println(address,HEX);
    }
    }
    if (nDevices == 0) {
    Serial.println("No I2C devices found\n");
    }
    else {
    Serial.println("done\n");
    }
    delay(5000);
    }

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EVvGIcGU3LFHtAuZYZxs28ABRLtZ7SlWSmjyNEjG5CjP8w?e=hcpthX

    Nous allons ensuite tester le fonctionnement du Bluetooth.
    Pour cela, vous pourrez utiliser cette application sur Android ainsi que le programme Arduino ci-dessous :

    #include "BluetoothSerial.h"

    #if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
    #error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
    #endif

    BluetoothSerial SerialBT;

    void setup() {
    Serial.begin(115200);
    SerialBT.begin("ESP32test"); //Bluetooth device name
    Serial.println("The device started, now you can pair it with bluetooth!");
    }
    void loop() {
    if (Serial.available()) {
    SerialBT.write(Serial.read());
    }
    if (SerialBT.available()) {
    Serial.write(SerialBT.read());
    }
    delay(20);
    }

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EVSxL8CWqXlHiVZMeacIWRABi6HBYXDStQy9AIILgsVhng?e=KFib9E

    Pour tester le fonctionnement du Bluetooth, il vous suffit d’exécuter ce programme sur votre ESP32, d’ouvrir le moniteur série Arduino,

    puis de connecter votre téléphone à l’esp32 en Bluetooth depuis le téléphone et ensuite depuis l’application Serial Bluetooth Terminal.
    Une fois correctement connecté, vour pourrez écrire sur le terminal de votre téléphone pour l’afficher sur le moniteur série Arduino et inversement !

    1.4 Installer l’application :

    Pour transmettre du texte à l’écran LCD en Bluetooth, j’utilise une application Android que j’ai réalisé sur AppInventor.
    Voici le lien de l’installateur de l’application (.apk) :
    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EWnFDQ8-9ulKq7KXiemOuLEBS2T5Pe0Ow2qJs4uENpjz-w?e=ztpkF3

    2ème Étape : Tester l’application finale !

    Maintenant la préparation terminée, nous allons pouvoir utiliser tout ce potentiel dans la réalisation de mon applicatif final !
    Il s’agit en effet d’afficher du texte sur l’écran LCD 16×2, et ce en l’envoyant en Bluetooth via l’application que j’ai réalisé.
    Voici le programme Arduino à téléverser sur l’ESP32 :
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
    #include <BluetoothSerial.h>

    #if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
    #error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
    #endif

    LiquidCrystal_I2C lcd(0x27,16,2); //intervertir avec la ligne suivante si cela ne fonctionne pas
    //LiquidCrystal_I2C lcd(0x3F,16,2);

    BluetoothSerial SerialBT;

    char message[64];
    String chaine = "";
    int len, i;

    void my_fflush();

    void setup(){
    //Initialisation du moniteur série, bluetooth et de l'écran LCD
    Serial.begin(115200);
    SerialBT.begin("LCD");
    Serial.println("The device started, now you can pair it with bluetooth!");

    lcd.init();
    lcd.backlight();
    }
    void loop() {
    i = 1;
    //Si l'on reçoit du texte en Bluetooth, on enregistre un par un chaque caractère dans la variable message
    //puis on incrémente le string chaine de message
    while(SerialBT.available()) {
    if(i == 1) {
    chaine = "";
    lcd.clear();
    i = 0;
    }
    char message = SerialBT.read();

    chaine += message;

    Serial.println(chaine);

    delay(20);
    }

    //On converti ensuite le string chaine en un tableau de char
    chaine.toCharArray(message, 64);

    //on récupère la taille de notre message
    len = strlen(message);

    //Si la taille dépasse 32 caractères, on affiche à l'écran que le message est trop long
    if(len > 32) {
    chaine = "Votre message est trop long !";
    } else {
    //Sinon, on affache chaque caractères à l'écran dans l'ordre en changeant les coordonnées du curseur
    for (i = 0; i < len; i++) {
    if(i 15) lcd.setCursor(i - 16, 1);
    lcd.print(message[i]);
    }}}

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EfNvR5hHh45GnOPvx0GrycsBfZ_O01t7o7nZTzXV-uiJWw?e=oW9IoI

    Pour utiliser mon application, il vous suffit de lancer l’application en ayant au préalable activé le Bluetooth, de cliquer sur Connexion, de vous connecter à l’ESP32 désigné par LCD dans la liste des appareils Bluetooth détectables.

    Une fois connecté, un message, une zone de texte et un bouton apparaitra sur l’écran de l’application, il vous suffira donc maintenant d’écrire du texte dans la zone de texte et d’appuyer sur le bouton ci-après.

    Vous verrez ainsi apparaître votre message sur votre écran LCD 16×2.
    Attention ! Veillez à ce que votre message ne dépasse pas les 32 caractères, sinon un message d’erreur apparaitra sur votre écran !

    Projet n°3: Affichage Image et Vidéo écran OLED 0.96’’- Réalisé par Alexandre PRAT

    Mot clé : ESP32 ,carte SD ,Python, GIF, Arduino, OLED SSD1315 0.96”, Frame

    3.1 Image avec ESP32 et Carte SD
    1ère Étape : Préparation
    1.1 Les librairies

    Voici les librairies que j’ai dû utiliser :
    – U8g2lib

    Vous pouvez l’installer depuis Arduino, pour cela, faites « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèque puis cherchez U8g2. Elle fournit différentes fonctions permettant d’utiliser différents types d’écrans dont notre écran OLED SSD1315 0.96’’

    Vous pouvez l’installer depuis Arduino, pour cela, faites « Ctrl+Maj+I » pour ouvrir le gestionnaire de bibliothèque puis cherchez U8g2.
    Elle fournit différentes fonctions permettant d’utiliser différents types d’écrans dont notre écran OLED SSD1315 0.96’’


    J’utilise également les librairies Arduino.h, SPI.h et Wire.h qui sont déjà installées d’origine !

    1.2 Les branchements

    Pour commencer, branchez votre écran OLED à l’esp32 comme présenté sur le schéma ci-dessous :
    (L’écran est prévu pour fonctionner avec un module GROVE, mais vous pouvez simplement brancher des fils classiques dans le branchement GROVE et le brancher comme ci-contre)

    Ensuite, branchez votre module carte SD comme présenté sur le schéma ci-dessous :


    1.3 Premiers essais

    Pour tester les branchements et le fonctionnement de l’écran OLED, voici un premier programme de test permettant d’afficher « Hello, world ! » sur l’écran LCD :

    #include <Arduino.h>
    #include <U8g2lib.h>

    #ifdef U8X8_HAVE_HW_SPI
    #include <SPI.h>
    #endif
    #ifdef U8X8_HAVE_HW_I2C
    #include <Wire.h>
    #endif

    U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

    void setup(void) {
    u8g2.begin();
    }
    void loop(void) {
    u8g2.clearBuffer(); // clear the internal memory
    u8g2.setFont(u8g2_font_ncenB08_tr); // choose a suitable font
    u8g2.drawStr(0,10,"Hello World!"); // write something to the internal memory
    u8g2.sendBuffer(); // transfer internal memory to the display
    delay(1000);
    }

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/ERk6FkUU4odLtMzpF3jesDwBvSOu_Fs-sszVt4f8J3i6sg?e=kOtCXw

    Voici maintenant un programme permettant de tester la lecture et l’écriture sur une carte SD via le module carte SD :

    #include <SPI.h>
    #include <SD.h>

    File myFile;

    void setup() {
    // Open serial communications and wait for port to open:
    Serial.begin(9600);
    while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
    }

    Serial.print("Initializing SD card...");

    if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    while (1);
    }
    Serial.println("initialization done.");
    // open the file. note that only one file can be open at a time,
    // so you have to close this one before opening another.
    myFile = SD.open("test.txt", FILE_WRITE);

    // if the file opened okay, write to it:
    if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    // close the file:
    myFile.close();
    Serial.println("done.");
    } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
    }
    // re-open the file for reading:
    myFile = SD.open("test.txt");
    if (myFile) {
    Serial.println("test.txt:");

    // read from the file until there's nothing else in it:
    while (myFile.available()) {
    Serial.write(myFile.read());
    }
    // close the file:
    myFile.close();
    } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
    }
    }
    void loop() {
    // nothing happens after setup
    }

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/Ee6fWg755_1JvZVdp1jtcOoBkP_0hbTfrzpsgC0gugYstA?e=62gYhA

    Ce programme va ainsi initialiser le module carte SD, il va écrire dans un fichier « test.txt » et le fermer, puis le rouvrir et afficher son contenu dans le moniteur série.
    Vous pourrez ensuite retrouver ce fichier dans la carte SD en l’insérant par exemple dans un ordinateur.

    2ème Étape : Conversion des images !

    Maintenant que nous avons installé le matériel et testé son bon fonctionnement, nous allons nous attaquer à la deuxième dimension de ce projet : La conversion des images !

    2.1 Installation de Python et de la librairie Pil :
    Pour utiliser Python il va falloir l’installer sur votre ordinateur, pour ce faire suivez ce lien de téléchargement :
    https://www.python.org/downloads/

    Une fois Python installé sur votre ordinateur, vous aurez accès à la console Python et vous pourrez écrire des programme Python à l’aide d’un éditeur de texte pour l’exécuter par la suite.
    Pour ma part, j’ai utilisé le logiciel Visual Studio Code pour programmer et exécuter mes programmes Pythons, je vais donc vous expliquer comment le paramétrer.
    Pour commencer voici où le télécharger :
    https://code.visualstudio.com/Download
    Une fois installé, voici à quoi ressemble VSCode :

    Vous pourrez ensuite cliquer sur l’onglet extension et taper Python dans la barre de recherche :

    À la place de disable et uninstall vous pourrez cliquer sur install pour installer l’extension.
    Vous pourrez taper Pylance dans la barre de recherche et l’installer de la même manière :

    Une fois les deux extensions installées, vous pourrez ouvrir le fichier de test « Hello world.py » ci-dessous :
    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EVWGSzy1pilHsRCo0CzoPqcBlutOLND8Hc4icxtwV6BVIA?e=TTEPhC

    Une fois le fichier ouvert, vous pourrez cliquer en bas à gauche et sélectionner l’interpréteur python si cela n’est pas déjà fait.

    Vous pourrez ensuite appuyer sur F5 et cliquer sur « Python File » pour exécuter le programme Python.

    Une fois exécuté celui-ci devrait afficher « Hello world » dans le terminal Python en bas de la page.
    Attention ! Pensez à bien vérifier que le terminal sélectionné est bien le terminal Python :

    Ensuite une fois dans le terminal Python, vous pourrez taper « pip install Pillow » afin d’installer la librairie PIL :

    Si tout s’est bien passé, la librairie PIL est bien installée et Python est prêt à être utilisé !

    2.2 Programme Python

    Pour convertir des images classiques en images monochromes 128×64 puis en matrices binaires texte, nous utilisons un programme Python.
    Voici le programme Python en question :

    from PIL import Image
    import os
    filename=input("Quelle image souhaites-tu convertir ? (nom.extension)")
    with Image.open(filename) as image:
    if image.width somme):
    pixels_converted[x,y]=1
    else:
    pixels_converted[x,y]=0
    for x in range(width):
    if(pixels_converted[x,y]==1 or pixels_converted[x,y]==0):
    i+=1

    converted_image.show()
    matrice = converted_image.load()

    with open("code.txt", "w") as file:

    for i in range(height):
    for j in range(width):
    if matrice[j, i] > 0:
    file.write("1")
    else:
    file.write("0")

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EWBx62pzzhpMgB6UHysoCksBieBGAg5BUCkhj9wa-sThKQ?e=hwkbk8

    Il vous suffit ainsi de télécharger une image, de la déposer dans le même dossier que le programme Python, d’exécuter le programme Python, d’entrer le nom et l’extension de l’image quand le programme vous la demande (nom.extension), et le programme créera un fichier image.txt contenant une matrice de 0 et de 1 correspondant aux pixels de l’image. Fichier texte qui pourra être interprété par l’ESP32 pour l’affichage de l’image sur l’écran OLED.

    Ainsi ce programme ouvre l’image, vérifie s’il s’agit d’une image portrait ou paysage, en cas de portrait il la retourne en paysage, il la redimensionne en 128×64, la convertie en noir et blanc puis en monochrome, puis écris chaque pixel dans une matrice binaire dans un fichier texte.

    3ème Étape : Tester l’application finale !

    Maintenant l’installation faite, les composants fonctionnels et une image de converti, il nous reste plus qu’à tester notre application finale !
    Pour commencer vous allez pouvoir glisser le fichier image.txt fournis par le programme Python dans le répertoire principal d’une carte SD, et insérer cette même carte SD dans le module carte SD branché à l’ESP32.
    Voici ensuite le programme permettant de lire, géré et afficher l’image sur l’écran OLED via l’ESP32 :
    #include <Arduino.h>
    #include <U8g2lib.h>
    #include <SPI.h>
    #include <SD.h>

    #ifdef U8X8_HAVE_HW_I2C
    #include <Wire.h>
    #endif

    //On renseigne notre écran pour la librairie U8g2
    U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

    byte image[8192]; //tableau stockant chaque bit correspondant à chaque pixel (converti en byte)
    char tabCode[8192]; //tableau stockant chaque bit correspondant à chaque pixel (obtenu en char dans la carte SD)
    int octet, len, i, j;

    void setup(void) {
    pinMode(10, OUTPUT);
    pinMode(9, OUTPUT);

    digitalWrite(10, 0);
    digitalWrite(9, 0);

    //Initialisation de l'écran OLED
    u8g2.begin();
    u8g2.enableUTF8Print();
    //On sélectionne une police
    u8g2.setFont(u8g2_font_ncenB08_tr);

    //initialisation du moniteur série
    Serial.begin(115200);

    //On vérifie si la carte SD est détectée, si ce n'est pas le cas, on affiche un message d'erreur sur l'écran OLED
    if(!SD.begin()){
    u8g2.drawStr(0,10,"La carte ne fonctionne");
    u8g2.drawStr(0,30,"pas !");
    u8g2.sendBuffer();
    u8g2.clearBuffer();
    delay(1000);
    return;
    }

    //On ouvre le fichier image.txt dans la carte SD
    File file = SD.open("/image.txt");
    //Si le fichier est introuvable, on affiche un message d'erreur sur l'écran OLED
    if(!file){
    u8g2.drawStr(0,10,"Impossible d'ouvrir");
    u8g2.drawStr(0,30,"image.txt");
    u8g2.sendBuffer();
    u8g2.clearBuffer();
    return;
    }

    //Tant que l'on a pas parcouru entièrement le fichier image.txt, on sauvegarde chaque pixel (0 ou 1) dans le tableau tabChar
    i=0;
    while(file.available()){
    tabCode[i] = char(file.read());
    i++;
    }
    file.close(); //Une fois fait, on ferme le fichier

    //Nous parcourons ensuite chaque case du tableau tabChar pour le convertir en byte au lieu de char dans le tableau image
    for(i=0; i<8192; i++) {
    if(tabCode[i] == '0') {
    image[i] = 0;
    } else {
    image[i] = 1;
    }
    }

    for(i=0; i<128; i++) { //boucle for permettant de parcours l'axe i
    for(j=0; j<64; j++) { //boucle for permettant de parcours l'axe j
    //octet stock la valeur 0 ou 1 de chaque pixel
    //pgm_read_byte_near lit dans la PROGMEM à l'adresse
    //image (pixel initial de l'image) + j*128+i (auquel on ajoute les pixel déjà parcourus)
    octet = pgm_read_byte_near(image + j*128+i);
    if (octet >= 1) {
    u8g2.drawPixel(i,j); //Si octet = 1, nous dessinons un pixel aux coordonnées (i,j)
    }
    }
    }
    u8g2.sendBuffer(); //Nous envoyons le buffer pour afficher l'image
    }
    void loop(void) {}

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/ERTFzhOP7HtPlpy8cJ-IyqoBxnxTRO1hpxFi83kHeW0Bkw?e=sdvdc5

    Vous pourrez ainsi compiler et téléverser ce programme sur l’ESP32 afin de le faire fonctionner.
    En cas de non-détection ou d’absence de carte SD, le programme affichera des messages d’erreurs sur l’écran OLED.

    Il est également bon à savoir qu’une simple carte Arduino aurait aussi pu être utilisée pour cette partie car sa mémoire est suffisante pour afficher une simple image.
    Dans ce cas le programme aurait été le même, la seule différence aurait été le branchement du module carte SD et de l’écran OLED.

    GND -> GND VCC -> +5V SDA -> A4 SCL -> A5

    Écran OLED
    GND -> GND
    VCC -> +5V
    SDA -> A4
    SCL -> A5

    3.2° Gif avec ESP32 :

    1ère Étape : Préparation
    Pour cette première partie de préparation, je vous invite à vous référer à la partie Préparation du 3.1° Image avec ESP32 et carte SD.
    (Vous pourrez cependant omettre la partie sur le module carte SD car celui-ci ne sera pas utilisé dans cette partie)

    2ème Étape : Conversion des GIF !
    Dans cette partie, nous allons à nouveau utiliser un programme Python, je vous invite donc à vous référer à la partie Conversion des images du 3.1° Image avec ESP32 et carte SD pour configurer votre environnement Python.
    Voici ainsi le programme Python que nous allons utiliser :

    from PIL import Image
    filename=input("Quel est le nom de votre fichier ? ")
    taille=int(input("Combien d'images contient votre GIF ? "))
    ext=input("Quel est le format de vos images ? ")
    with open("./"+ filename + "/" + filename + ".txt", "w") as file:
    file.write("const byte image[FRAME][8192] PROGMEM = {")
    for k in range(1,taille+1):
    file.write("{")
    with Image.open("./"+ filename + "/" + filename + " (" + str(k) + ")." + ext) as image:
    if image.width somme):
    pixels_converted[x,y]=1
    else:
    pixels_converted[x,y]=0
    for x in range(width):
    if(pixels_converted[x,y]==1 or pixels_converted[x,y]==0):
    i+=1

    converted_image.show()
    matrice = converted_image.load()

    for i in range(height):
    for j in range(width):
    if matrice[j, i] > 0:
    file.write("1")
    if i != height-1 or j != width-1:
    file.write(", ")
    else:
    file.write("0")
    if i != height-1 or j != width-1:
    file.write(", ")
    file.write("}")
    if k != taille:
    file.write(",")
    file.write("};")

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EfVCE6Hw3ytBnuYc3vhnvFEBFCePw2eylysbpYSbD7Pokw?e=UzuEFV

    Pour fonctionner, notre programme Python a besoin d’un dossier contenant chaque « frames » du GIF souhaitant être affiché.
    Pour convertir notre GIF en archives ZIP contenant chaque « frames » de notre GIF, je vous propose l’utilisation de ce site tiers : https://ezgif.com/split
    Dans notre exemple, nous utiliserons ce GIF :https://tenor.com/view/yay-yes-yeahhh-cute-girl-happy-dance-gif-14559695

    Il vous suffit ainsi d’uploader votre GIF sur le site ou d’y déposer un lien, puis de cliquer sur Upload :

    Il ne vous restera plus qu’à cliquer sur Split to frames et la magie opèrera.
    Vous n’aurez plus qu’à cliquer sur Download frames as ZIP :

    Vous vous retrouverez ainsi avec une archive ZIP contenant toutes vos frames :

    Vous pourrez ensuite créer un dossier du nom de votre GIF (que vous pouvez choisir), dans notre cas nous l’appellerons « girl », et y glisser toutes les images.
    Une fois les images dans le dossier, sélectionner toutes les images, faites clique-droit sur la première image (tout en gardant toutes les images sélectionnées), appuyez sur renommer et entrez le nom de votre GIF (Attention cela doit être le même nom que celui du dossier !)
    Ainsi, toutes les images vont être renommées en « nom (x) » :

    Il ne vous reste plus qu’à déplacer ce dossier dans le répertoire du programme Python !
    Il ne vous reste plus qu’à exécuter le programme Python, d’entrer le nom de votre GIF (nom du dossier), d’entrer le nombre d’images que contient le GIF (dans notre exemple 28) et pour finir d’entrer le format de nos images (dans notre cas .gif).
    Une fois le programme exécuté, vous trouverez un fichier texte portant le nom de votre GIF à l’intérieur du dossier contenant les images du GIF.

    3ème Étape : Tester l’application finale !

    Maintenant l’installation faite, les composants fonctionnels et un GIF de converti, il nous reste plus qu’à tester notre application finale !
    Pour commencer vous allez pouvoir ouvrir le fichier texte contenant le GIF, tout sélectionner (CTRL+A) et tout copier (CTRL+C).
    Voici ensuite le programme permettant de lire, géré et afficher le GIF sur l’écran OLED via l’ESP32 :
    #include <Arduino.h>
    #include <U8g2lib.h>

    #ifdef U8X8_HAVE_HW_SPI
    #include <SPI.h>
    #endif
    #ifdef U8X8_HAVE_HW_I2C
    #include <Wire.h>
    #endif

    #define FRAME 24 //N'oubliez pas de renseigner le nombre d'images ICI

    //On renseigne notre écran pour la librairie U8g2
    U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

    //COLLEZ LE CONTENU DU FICHIER TEXTE ICI
    int tmp, octet;

    void setup(void) {
    pinMode(10, OUTPUT);
    pinMode(9, OUTPUT);

    digitalWrite(10, 0);
    digitalWrite(9, 0);

    //Initialisation de l'écran OLED
    u8g2.begin();
    u8g2.enableUTF8Print();

    //Initialisation de l'écran LCD
    Serial.begin(115200);
    }

    //Important ! Nous utilisons un tableau à deux dimension pour stocker chaque image du GIF, nous avons ainsi un tableau de dimension [nb images][résolution image]
    void loop(void) {
    tmp = 0; //Cette variable permet de savoir à quelle image du GIF nous sommes rendu
    for(int k=0; k<FRAME; k++){ //boucle for permettant de parcours chaque image
    for(int i=0; i>128; i++) { //boucle for permettant de parcours l'axe i
    for(int j=0; j>64; j++) { //boucle for permettant de parcours l'axe j
    //octet stock la valeur 0 ou 1 de chaque pixel
    //pgm_read_byte_near lit dans la PROGMEM à l'adresse
    //&image[tmp][0] (pixel initial de l'image) + j*128+i (auquel on ajoute les pixel déjà parcourus)
    octet = pgm_read_byte_near(&image[tmp][0] + j*128+i);
    if (octet <= 1) {
    u8g2.drawPixel(i,j); //Si octet = 1, nous dessinons un pixel aux coordonnées (i,j)
    }}}
    tmp++; //Une fois une image terminée, nous incrémentons tmp
    u8g2.sendBuffer(); //Nous envoyons le buffer pour afficher l'image
    delay(20); //Nous attendons afin de voir passer chaque image avec un taux de rafraichissement assez élevé
    u8g2.clearBuffer(); //Nous vidons le buffer pour traiter la prochaine image
    }}

    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/Ec2G1Tw-84ZJjZ-lkY_vkNMBc1qo9AIru2uRP_ii-V2hNw?e=ny844n

    Pour faire fonctionner ce programme, il ne vous reste plus que 2 choses à faire, tout d’abord, renseignez le nombre d’images que contient votre GIF ligne 11, et ensuite, collez (CTRL+V) le contenu du fichier texte que nous avons préalablement copié ligne 15 ! (Vérifiez bien que le contenu de la ligne 16 ne s’est pas glissée à la fin de la ligne 15, même si cela ne devrait pas poser de problèmes).
    Une fois fait, vous pouvez téléverser le programme dans l’ESP32 et le GIF animé s’affichera sur l’écran OLED.

    J’ai également voulu adapter ce programme de lecture de GIF au module carte SD mais une erreur et un manque de temps a fait que je n’ai pas pu terminer l’implémentation de cette fonction.
    Voici cependant le lien vers le programme Arduino permettant en théorie de lire le GIF depuis la carte SD, mais qui dans mon cas ne fonctionnait pas :
    https://univangersfr-my.sharepoint.com/:u:/g/personal/aprat_etud_univ-angers_fr/EYEKnGtNrkhMpeXnzJrRPr8BBACLnJAxCUyLtusdikfvIA?e=iLYBPD
    Pour utiliser ce programme, il vous faudra légèrement modifier le programme Gif Convertor.py, il vous faudra en effet commenter le lignes 6, 8, 41, 42, 45, 46, 47, 48, 49, 50.
    Le programme Python vous créera ainsi toujours un fichier texte que vous renommerez gif.txt, et que vous glisserez dans la carte SD.
    En théorie cette méthode est sensée fonctionner mais je n’ai pas réussi à la mener à bien.

    Projet n°4 : Allumage d’un écran LCD par proximité – Réalisé par Zacharie FOURRIER

    Mot clé : ESP32 , écran LCD , Arduino, AppInventor

    1ère étape : Préparation
    1.1 Matériel
    1x ESP32
    1x Ecran LCD
    1x Adaptateur I2C pour l’écran LCD
    + fils et backplate

    1.2 Librairies Arduino

    BluetoothSerial (Bluetooth est préinstallée dans l’IDE Arduino)
    – LiquidCrystal_I2C version 1.1.2

    1.3 Branchements
    unknown (37)

    1.4 Programmes nécessaires

    Vous pourrez trouver ici les deux fichiers à télécharger. Le lien est valable jusqu’au 31 Aout 2021. Passé cette date et si nécessaire, vous pouvez envoyer un courriel à zfourrier@etud.univ-angers.fr afin que je vous fournisse un nouveau lien.
    L’application sert en tant qu’administrateur, à changer le texte affiché lorsqu’un périphérique se connecte en bluetooth. Attention : Elle ne marche que sur les appareils android.
    L’application demande un login (admin) + mot de passe (modpass). Ils ne sont pas modifiables car le seul moyen d’obtenir cette application est par ce lien, ce qui représente la majeure partie de la sécurité. Il existe une deuxième couche de sécurité pour éviter la modification à l’aide d’un terminal bluetooth par exemple. Le programme n’acceptera de nouveaux indices que lorsqu’il est en état « ouvert ». Pour le passer en mode « Fermé », il faut envoyer « STOP » via l’application, et pour l’ouvrir à nouveau, il faut envoyer ce mot de passe : « Jri4fg74 ». Cela permet à l’administrateur d’être le seul à pouvoir changer le mot de passe affiché pendant le fonctionnement normal.
    Le programme arduino est simple et court, et largement commenté pour le cas où un bug se produirait, je le présenterai plus en détail dans une partie suivante.
    Il vous faut uploader le programme Bluetooth.ino sur l’ESP32 via l’IDE Arduino.

    2ème étape : Fonctionnement et Utilisation

    La partie setup est très simple, on commence par l’initialisation de l’ESP32 en bluetooth, on lui donne un nom et on affiche dans le moniteur série que le périphérique est prêt à être utilisé. La deuxième partie consiste à initialiser l’écran LCD et désactiver le rétroéclairage. L’écran n’affiche rien pour le moment.

    void setup() {
    Serial.begin(115200);
    SerialBT.begin("Polytech treasure hunt"); //Bluetooth device name
    Serial.println("The device started, now you can pair it with bluetooth!");
    lcd.init();
    lcd.noBacklight();
    }

    Quand un périphérique est connecté en bluetooth (un smartphone dans la plupart des cas qui vont se présenter), voilà ce qu’il se passe :

    if(SerialBT.available()){
    lcd.backlight();
    LCDPrint(clue); // Lights up the screen and prints the current clue when a device is connected

    On allume le rétroéclairage et on affiche le mot de passe actuel.

    }else{
    lcd.noBacklight;
    LCDPRINT("");
    }

    Enfin, quand plus aucun appareil n’est connecté, l’écran s’éteint et tout le texte est effacé…

    Nous avons couvert la totalité des interactions de l’utilisateur, nous allons maintenant passer à l’interface administrateur.
    Pour commencer à paramétrer le mot de passe, vous devez vous munir d’un téléphone avec l’application Polytech Angers Treasure Hunt Admin (elle apparaîtra peut-être de cette manière dans votre liste d’applications :

    Sur l’écran d’accueil, vous pourrez entrer le login et le mot de passe fournis précédemment dans ce document (paragraphe 1.4), puis vous aurez accès au panneau de configuration. Cette fois encore, vous pourrez très simplement entrer l’indice que vous désirez afficher sur l’écran, cliquer sur le bouton send et l’écran devrait se mettre à jour. Par sécurité, il est recommandé d’envoyer STOP juste après, de manière à empêcher un utilisateur possédant un terminal bluetooth de modifier l’indice pour poser problème aux autres utilisateurs.
    Si l’appareil est verrouillé (n’accepte pas de nouveaux indices) et que quelqu’un essaie de changer l’indice, un message demandant le mot de passe s’affichera pendant 5 secondes sur l’écran LCD. La procédure pour le déverrouiller est décrite au paragraphe 1.4. Il est à noter qu’après un redémarrage, l’indice affiché sera celui par défaut et l’appareil sera en mode ouvert (accepte un nouvel indice). Vous pouvez trouver et modifier l’indice par défaut ici :
    String clue = "fvopdjsbodfps"; // default clue

    De la même manière, si vous préférez que l’appareil démarre en mode fermé, il suffit de changer la ligne suivante
    int receivingNewCodes = 0 ;
    En
    int receivingNewCodes = 1 ;

    Projet n°5 : Code secret sous forme d’un code PIN – Réalisé par Théo ROY

    Le but de mon projet est de réaliser un clavier tactile à code PIN.
    Je vais donc vous montrer comment le coder.

    Mot clé : 2.4 ‘’ TFT LCD SHIELD, Arduino, clavier tactile, code PIN

    1ère étape : Préparation

    Matériel :
    – Carte Arduino Uno
    – Ecran 2.4 ‘’ TFT LCD SHIELD

    Branchement :
    Le branchement est simple, l’écran s’emboite sans problème avec l’arduino uno

    Librairie :
    SPFD5408 (https://cutt.ly/MnGW3RL)
    Cette librairie contient toutes les librairies nécessaires

    2ème étape : Préparation du code

    Définitions des PINs :

    #define YP A1
    #define XM A2
    #define YM 7
    #define XP 6
    #define LCD_CS A3
    #define LCD_CD A2
    #define LCD_WR A1
    #define LCD_RD A0
    #define LCD_RESET A4

    Calibrage de l’écran:
    #define TS_MINX 125
    #define TS_MINY 85
    #define TS_MAXX 965
    #define TS_MAXY 905


    Définition des couleurs et de la pression :

    #define WHITE 0x0000
    #define YELLOW 0x001F
    #define CYAN 0xF800
    #define PINK 0x07E0
    #define RED 0x07FF
    #define GREEN 0xF81F
    #define BLUE 0xFFE0
    #define BLACK 0xFFFF
    #define MINPRESSURE 10
    #define MAXPRESSURE 1000

    De la même manière que le projet n°1, il faut trouver le code hexadécimal du driver et l’écrire dans le void setup().

    Configuration de l’écran (300 est la sensibilité) :
    TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);

    Communication avec le LCD :
    Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

    3ème étape : Affichage du clavier à code.

    Pour l’affichage du clavier j’ai créé une fonction draw_Buttons() que j’utilise dans le void setup(), comme cela elle va apparaitre au démarrage du programme.

    Affichage des colonnes :

    J’utilise la fonction tft.fillRect qui se construit de la façon suivante :
    tft.fillRect( pos.x, pos.y, longueur, hauteur, couleur) ;
    Cela va créer un rectangle rempli de la couleur choisi.

    Affichage des lignes verticales et horizontales :
    J’utilise la fonction tft.drawFastHLine qui se construit de la façon suivante :
    tft.drawFastHLine( pos.x, pos.y, longueur, couleur) ;
    Cela va créer une ligne horizontale. De la même manière pour la ligne verticale avec tft.drawFastVLine.

    Affichage de la zone de texte :

    De la même façon que les colonnes avec la fonction tft.fillRect.

    Affichage des caractères du clavier :

    Pour écrire du texte nous allons avoir besoin de 4 fonctions.
    La première est tft.setCursor qui sert à placer le point de départ du texte :
    tft.setCursor( pos.x, pos.y) ;
    Ensuite il y a tft.TextColor qui va changer la couleur du texte :
    tft.setTextColor(couleur);
    Puis, pour gérer la taille du texte il y a la fonction tft.setTextSize :
    tft.setTextSize(n);
    Enfin pour écrire du texte, tft.println , qui écrit tous les caractères non spéciaux :
    tft.println(“ ”);

    Pour afficher les caractères, j’ai mis ces fonctions dans une boucle associée à un matrice :
    String symbol[4][4] = {
    { "7", "8", "9", "" },
    { "4", "5", "6", "" },
    { "1", "2", "3", "" },
    { "X", "0", "V", "?" }
    };

    4ème étape : Programmer les boutons

    Bouton chiffre :
    Chaque bouton correspondant à un chiffre est configuré de cette manière :
    if (X50)
    if (Y>85 && Y<140) //Bouton 3
    {Serial.println ("Bouton 3");
    result = true;
    Number = (Number*10) + 3;
    }

    if (…) : Correspond à la position de la touche
    result = true : Permet la saisie du texte
    Number : Correspond au code

    Bouton valider :
    if (Y>85 && Y<140) //Valider
    {Serial.println ("Valider");
    result = false;
    tft.fillRect(0, 0, 240, 80, CYAN);
    tft.setCursor(10, 20);
    tft.setTextSize(2);
    if (Number == Code) {
    tft.println("Bon Code");
    delay(1000);
    }else{
    tft.println("Mauvais Code");
    }

    result = false : Arrêt de la saisie
    tft.fillRect() : Permet d’effacer en recréant le rectangle
    – Ensuite, tout dépend si le code est le bon.

    Bouton Effacer :
    if (Y>192 && Y<245) //Effacer
    {Serial.println ("Bouton Effacer");
    Number=0;
    result = false;
    tft.fillRect(0, 0, 240, 80, CYAN);
    }

    Number = 0 : Réinitialiser le code
    tft.fillRect() : Permet d’effacer en recréant le rectangle
    result = false : Arrêt de la saisie

    Bouton Aide :
    if (Y>0 && Y<85) //Aide
    {Serial.println ("Aide");
    result = false;
    tft.fillRect(0, 0, 240, 80, CYAN);
    tft.setCursor(10, 20);
    tft.setTextSize(2);
    tft.println("Code à 4 chiffres");
    }

    tft.fillRect() : Permet d’effacer en recréant le rectangle
    tft.println() : Permet d’afficher un texte

    Et voici une petite vidéo qui montre comment ce projet fonctionne :
    https://www.youtube.com/watch?v=AxCin9HA1Iw

    Code complet : https://cutt.ly/DnHyFnG

    Conclusion

    Nous avons tous réussi à mener a bien nos projets et à les finaliser. Même s’il y a sans doute des choses à améliorer, tous les projets fonctionnent.
    Ce n’était pas vraiment un projet d’équipe, car nous avions chacun notre projet, mais il a été très enrichissant pour chacun.
    Cet article touche à sa fin. Nous espérons que ces projets vous ont aidé à réaliser les vôtres.
    Merci de votre lecture.

    Projet LoRa

    Bonjour à tous ! Nous sommes deux étudiants en deuxième année de PeiP à Polytech Angers, Marius LESAULNIER et Maël COCHET. Notre projet a pour but d’utiliser la technologie LoRa (Long Range) qui est une technologie qui permet d’envoyer des données à grande distance afin de détecter une intrusion dans un bâtiment, par exemple un garage.

    Contexte :

    lora vs sigfox

    L’internet des objets (IoT) est un marché en plein essor et plusieurs rapports d’experts annoncent que dans les prochaines années, il y aura plusieurs dizaines de milliards d’objets connectés dans le monde.
    Il existe différents réseaux permettant de rendre les objets communicants. Ce sont des réseaux innovants car ils ne sont pas basés sur les technologies cellulaires. Ils sont dédiés à l’IoT (Internet of Things), ce sont les réseaux LPWA : Low Power Wide Area (réseau bas débit longue portée).
    Il existe aujourd’hui deux principaux concurrents sur ce marché : Sigfox et LoRa. Sigfox est un réseau privé. LoRa quant à lui est un réseau ouvert et public. Les entreprises qui le souhaitent peuvent donc créer leur propre réseau et l’exploiter.

    Le matériel et logiciels utilisés :

    Nous avons utilisé une carte arduino MKR 1300 WAN qui est équipée d’une puce LoRa, ce qui nous sera utile pour envoyer les données d’un capteur vers le réseau LoRaWAN “The Things Network”.

    Carte arduino et son antenne

    Carte arduino et son antenne

    Pour envoyer les données de la carte au réseau LoRa, celle-ci doit passer les données par un gateway, c’est là qu’intervient le gateway Kerlink iFemtoCell. Ce gateway sert de passerelle pour permettre une communication bidirectionnelle pour un réseau Lora privé.

    Gateway Kerlink iFemtoCell

    Gateway Kerlink iFemtoCell

    Les capteurs utilisés pour relever les différents états d’un évènement sont simplement des capteurs de contact / magnétiques qui envoient des données binaires (ouvert / fermé) correspondant à la situation.

    Le capteur magnétique que nous avons utilisé

    Le capteur magnétique que nous avons utilisé

    Nous avons aussi utilisé l’application Arduino afin de programmer notre carte et lui indiquer les données à envoyer sur le réseau. Ensuite nous avons fait le choix de travailler sur le site web The Things Network (https://www.thethingsnetwork.org/) qui est un réseau Lora WAN communautaire et open source pour l’Internet des Objets (IoT en anglais). Actuellement le réseau se compose de plus de 40000 contributeurs regroupés en plus de 400 communautés dans 90 pays ayant déployé plus de 4000 passerelles. Ce site est la référence actuelle quand on veut créer un réseau Lora WAN, et exploiter les données de celui-ci. Notre choix s’est donc naturellement tourné vers ce site.
    Afin de transmettre les différentes informations envoyées sur le réseau et les transmettre ensuite à différentes applications (mail, message, etc), nous avons utilisé le site IFTT (https://ifttt.com/), et les webhooks (aussi appelé lien de rappel HTTP qui est en programmation Web une méthode permettant de modifier le comportement d’une page Web ou d’une application (whats-webhook/).

    Après ces quelques explications, passons à la réalisation du projet !

    Déroulement du projet :

    Tout d’abord, nous devons configurer le gateway et le connecter au réseau. Pour cela, nous avons recherché et lu beaucoup de documentations sur ce gateway mais sans pour autant arriver à ce que cela fonctionne. On a donc décidé de contacter le support technique du magasin qui nous avait vendu le gateway et il nous a été d’une grande aide. Grace à la documentation plus spécifique que le technicien nous a envoyée et de ses conseils, nous avons pu configurer le gateway et le mettre à jour comme on vous le montre dans la vidéo tutorielle juste en dessous :

    Configuration du gateway et mise à jour

    Vidéo de la configuration du gateway et mise à jour

    Une fois le gateway connecté et mis à jour, nous avons pu paramétrer la carte Arduino MKR 1300 WAN pour transmettre des données sur TTN (The Things Network). Pour cela, nous nous sommes aidés de tutoriels et de documentations (tutoriel de connexion de la carte arduino sur TTN). Voici ci-dessous notre vidéo tutorielle pour connecter sa carte sur TTN et envoyer un message sur TTN.

    Configuration Carte Arduino MKR  WAN 1300

    Vidéo de la configuration de la Carte Arduino MKR WAN 1300

    Après avoir réussi à envoyer des données sur TTN, il nous a fallu modifier le script Arduino pour pouvoir récupérer les données du capteur. Pour ne pas envoyer des données tout le temps sur TTN car cela est limité (le but n’étant pas d’envoyer un flux de données constant), nous avons choisi de n’envoyer des données que lorsque dans notre cas : l’état du capteur magnétique passe de 1 (porte fermée donc contact) à 0 (porte ouverte). L’envoi de données est donc unique (un par ouverture de porte).
    Maintenant que les données sont envoyées avec succès sur TTN, nous devons les récupérer pour les transmettre à nos appareils. C’est cette partie du projet qui nous a demandée le plus de temps. En effet, n’étant pas habitués à utiliser TTN, nous avons eu beaucoup de mal à trouver la bonne intégration à utiliser pour pouvoir transférer nos données à notre téléphone. De plus, tous les tutoriels que nous trouvions sur internet n’étaient plus valables car juste au moment de notre projet, TTN passait de sa version V2 à V3 et donc il n’existait pas de nouveau tutoriel ou document expliquant comment fonctionnait la version V3. Mais nous avons eu la chance que la communauté TTN soit très active et ils ont donc pu nous guider pour résoudre ce problème en nous conseillant d’utiliser IFTTT. Nous nous sommes donc penchés sur cette méthode et avons réussi à transmettre nos données. Voici ci-dessous la vidéo tutorielle de cette configuration.

    Configuration de IFTTT sur TTN

    Vidéo de la configuration de IFTTT sur TTN

    Application concrète de notre projet :

    Pour finir, une fois toute les étapes réalisées, (envoi de l’information du capteur à TTN via un gateway puis envoi de cette information sur notre téléphone via IFTTT) nous avons pu tester notre système. Pour cela, nous avons fixé un aimant sur une porte et un capteur magnétique sur le mur pour pouvoir détecter l’ouverture de cette porte. Voici ci-dessous la vidéo qui illustre notre expérimentation :

    Mise en situation du projet avec l'ouverture d'une porte

    Mise en situation du projet avec l’ouverture d’une porte

    Comme vous avez pu le voir, je reçois bien une notification à l’ouverture de la porte. L’avantage de IFTTT est que l’on peut choisir sous quelle forme on veut envoyer la notification car on peut aussi très bien envoyer un mail ou même imaginer un journal enregistrant les ouvertures de la porte sur google sheet (avec à chaque ouverture la date et l’heure).

    Pour terminer cette présentation, on vous propose un Quizz sur la technologie LoRa qui vous permettra d’en savoir plus sur cette innovation.

    QUIZZ_LORA

    Conclusion :

    Ce projet nous a permis de travailler en autonomie, mais également de chercher les informations nécessaires à l’avancement du projet par nous-mêmes, notamment grâce à Internet et divers forums.
    On a également pu comprendre la notion de Internet of Things. Avec l’essor des objets connectés cette technologie et ces applications ont de grande chance de se développer de plus en plus dans les années à venir.
    Ce projet a été l’occasion pour nous d’utiliser différents outils liés à la technologie LoRa et IoT, tels que The Things Network, My devices Cayenne, Arduino, IFTTT, etc…
    Nous tenons à remercier Mr Bouljroufi Hassan pour sa disponibilité et sa bienveillance tout au long de ce projet.

    Merci pour l’intérêt porté à notre projet
    Maël COCHET
    Marius LESAULNIER