Virtual Mimic !

Publié le 6 juin 2021 par PAPIN Noemie

Bonjour à tous !

Dans le cadre de notre classe préparatoire intégrée à Polytech Angers, nous avons eu l’opportunité de réaliser des projets de groupe. Au résultat des choix, notre binôme s’est constitué de Clotilde HAS et Noémie PAPIN.

L’une étant intéressée par la simulation, l’acquisition de compétences sur un nouveau logiciel; l’autre portant de l’intérêt à comment l’ingénierie intervient dans le monde de la santé : il s’agit d’une collaboration poly’valente.

N’oubliez pas : [M.De Montaigne]

“La vie n’est que mouvement”

Objectif et Présentation :

L’objectif de « Virtual Mimic » est de nous initier au développement d’une plateforme innovante, destinée à la rééducation de patients cérébrolésés. Ce sont des victimes de lésions cérébrales consécutives à un traumatisme crânien grave, un accident vasculaire cérébral ou d’une autre origine (infectieuses, tumorales, …).
Notre projet s’inscrit donc dans le milieu médical et plus particulièrement dans l’utilisation des technologies interactives et ludiques appliquées à la santé. L’approche proposée repose sur la reproduction de gestes statiques et/ou dynamiques par le patient.
Pour ce faire, il est proposé d’utiliser des outils et techniques de réalité virtuelle. Notre travail consistait à développer une application, sur le logiciel Unity 3D à l’aide du langage C# (C sharp).

Ce projet comportait majoritairement deux grands points. Devant respecter l’utilisation d’avatars animés, provenant du site Mixamo, et les adapter en fonction des besoins des patients, notre travail a vu naître deux sous-projets orientés vers deux types de population : un pour les adultes, l’autre pour les enfants.

Illustration du projet :

Menus & Univers :

Voici un rendu de nos menus respectifs. Le but étant de nous plonger directement dans l’univers:

Capture du menu de Clotilde

Capture du menu de Noémie

Remarque : Malgré tout, l’environnement de la simulation est identique sur nos deux projets (forêt visible en arrière plan du menu de Noémie). Celui-ci était adaptable à nos besoins et était gratuit 🙂

Chaque bouton est utilisable et redirige vers la scène de notre choix. Chaque scène correspond aux différents modes proposés.

Modes disponibles

Les animations pour chaque personnage sont représentées par les blocs gris ci-dessous. Lorsqu’une animation est jouée, elle passe en orange. C’est par l’appui sur une touche (ou un bouton sur l’écran) qu’on passe à l’animation de notre choix. On peut les enchaîner indéfiniment et y revenir comme on veut.

Capture de l’Animator

Il existe un animator controller (ensemble d’animations par blocs) par mode proposé. Clotilde a orchestré les deux modes imposés (gestes Statiques et Dynamiques) sur son application tandis que Noémie en a ajouté un troisième pour initier le patient à quelques pas de danse en bonus.

Scripting

Le scripting C# (qui permet de gérer des fonctionnalités logiciels avec du code) fut une découverte pour nous, il nous était parfois difficile de manipuler correctement les différentes fonctions. A force de patience et de nombreuses recherches à naviguer entre le net et les cours à disposition, nous avons réussi à créer nos scripts en C# par nous-même.

Voici un exemple d’un script en C#, qui nous a permis de mettre en place un chronomètre avec une barre de décompte.

Exécutables finaux

Vous trouverez ci-dessous le rendu vidéo de nos exécutables. Bon visionnage !

Application de Clotilde
Application de Noémie

Distanciel / Autonomie :

Le projet a été un exemple pour la mise à l’épreuve de notre capacité à être autonomes. Le distanciel fut une contrainte majeure durant nos créneaux de projet. En effet, la communication rendue difficile, la mise en commun n’a pas toujours été évidente. À regret de ces mêmes conditions, nous n’avons pas pu expérimenter nos propres projets avec les casques de réalité virtuelle 🙁

Conclusion :

Puisque notre cahier des charges n’était pas stricte, nous avons ajouté des contraintes afin de compléter le projet pour l’améliorer et le rendre plus attractif.

Nous pensons qu’avec un meilleur encadrement, rendu impossible dû aux conditions sanitaires actuelles, nous aurions pu être encore plus intransigeantes avec nous-mêmes et aller plus loin.

***

Ce projet très concret nous a permis de mettre un pied dans cycle ingénieur qui nous attend individuellement ces trois prochaines années (Noémie : SAGI / Clotilde : Génie Biomédical).

Merci pour votre lecture !

Nous remercions également M. Paul RICHARD pour son encadrement.

Projet Rubiks Cube 2021 Antoine Nolan Nicolas

Publié le 6 juin 2021 par SARRAZIN Antoine

Présentation du projet:

Bonjour, nous sommes Antoine Nicolas et Nolan, étudiants en deuxième année préparatoire intégrée de Polytech Angers. Dans l’objectif de réaliser une armoire à énigmes pour le futur escape Polytech nous étions chargés de concevoir une de ces énigmes qui n’était autre que la résolution d’un Rubik’s Cube. Il ne fallait pas simplement résoudre le Rubik’s Cube à la main (ce serait trop simple) mais il fallait le résoudre à l’aide d’un robot qui ferait tourner ces faces grâce à des boutons.

Phase de conception:

Nous avons aussi pensé à la manière dont nous allions faire tourner le Rubik’s cube. Nous avons opté pour 6 servomoteurs à rotation continue qui seront contrôlés par un Arduino. Ils ont l’avantage de pouvoir tourner comme son nom l’indique en continu et dans les deux sens de rotation contrairement à d’autres moteurs qui ne peuvent tourner qu’à 270°. Pour connaître la force qu’il faudrait exercer pour faire tourner les faces du Rubik’s cube, nous avons effectué des tests simples à Polytech, ce qui nous a permis d’avoir des servomoteurs suffisamment puissants et ainsi ne pas commander des servomoteurs inadaptés. Afin de créer une interface homme-machine affordante, nous avons pensé à des boutons qui auraient la même couleur que la face que l’utilisateur souhaite faire tourner. De plus, nous avons réfléchi à un switch qui permet de faire tourner les faces dans les deux sens. Nous avons également réfléchi à un boitier de contrôle qui permettrait de ranger l’Arduino et la breadboard afin d’avoir un rendu plus agréable à utiliser et à regarder. Enfin, nous avons pensé à mettre un miroir à l’arrière de la structure afin de voir le Rubik’s cube dans son ensemble.

Conception Assistée par ordinateur:

Nous avons ensuite réfléchi sur la forme de la structure qui pourrait accueillir le Rubik’s cube. Nous avons opté pour trois formes différentes, chacune avec ses avantages et ses inconvénients. La première est simple à construire mais présente des problèmes pour accueillir les servomoteurs, il faut réaliser un porte-à-faux assez important afin d’aligner les moteurs avec le centre du Rubik’s cube. La seconde est simple à construire avec une installation facile des servomoteurs, mais les pièces pour la construire ne sont pas disponibles chez notre fournisseur ; il nous fallait des cubes qui puissent relier 4 barres pour former une croix. Enfin, la dernière structure est réalisable avec les pièces disponibles et permet de monter les servomoteurs. Cependant elle est relativement compliquée à monter car il est compliqué de centrer parfaitement les servomoteurs.
Pour mieux visualiser nos idées, un travail de modélisation 3D a été effectué. Nous avons modélisé les pièces présentes sur le site du fournisseur à l’échelle quand les dimensions étaient disponibles. Cela nous a permis d’éviter des problèmes futurs, comme des erreurs de mesures, des problèmes liés à des dimensions inconnues…
Voici les images de nos trois structures :

Code:

Simultanément avec la modélisation 3D, nous avons créé le code Arduino qui nous permettra de faire pivoter nos faces suite à un appui sur un bouton. Le code est relativement simple, il fait tourner le moteur quand l’utilisateur appuie sur le bouton. Il y a en plus un délai entre chaque appui de bouton afin de ne pas faire tourner deux faces en même temps et de risquer de casser le Rubik’s cube.

Assemblage:

Une fois la forme de la structure choisie et le code réalisé, nous avons commandé nos pièces et nous les avons assemblées pour commencer à faire des tests grâce à l’Arduino.
Nous avons vissé les barres ensemble grâce à des cubes prévus à cet effet. Une fois cela fait, nous avons mis les servomoteurs dans leur support que nous avons fixés aux équerres. Ensuite, nous avons placé les équerres afin que l’axe de rotation des servomoteurs soit parfaitement aligné avec le centre des faces du Rubik’s cube. Pour tenir le Rubik’s cube, nous avons vissé des entretoises sur les servomoteurs. Ces entretoises sont ensuite mises en contraintes dans des bouchons en liège qui sont collés au centre des différentes faces du Rubik’s cube. En parallèle, nous avons ajusté le temps que mettaient les servomoteurs pour faire tourner les faces de 90°.
Enfin, nous avons eu quelques idées afin de rendre le système plus ergonomique. Par exemple, nous avons pensé à créer une boîte dans le style des contrôleurs de borne d’arcade permettant d’accueillir l’Arduino et les boutons afin que les câbles soient rangés de façon optimale.

Problèmes rencontrés:

Nous avons rencontré quelques problèmes lors de la conception et de la réalisation de notre projet. Pour commencer, évoquons les problèmes ayant attrait à l’aspect fonctionnel de notre projet. Notre première structure n’était pas adaptée pour faire tourner les faces avec les servomoteurs car il fallait les déporter sur une trop longue distance, ce qui aurait apporté des forces et des moments sur la structure et les servomoteurs supplémentaires, ce que nous voulions absolument éviter afin de faire tourner au mieux le Rubik’s cube. Pour la seconde structure, nous avons eu des problèmes concernant les pièces proposées par le fournisseur avec lequel nous devions travailler. Nous avons donc créé une nouvelle forme pour notre structure, ce qui nous a permis de monter les servomoteurs avec les pièces disponibles. Cependant, cette dernière a été très compliquée à construire car il faut être très précis dans l’installation de nos servomoteurs. Enfin, le problème reste que deux servomoteurs sont un peu déportés de l’axe du Rubik’s cube. Ce problème se corrige un minimum avec les supports de servomoteurs mais cela ne reste pas parfaitement centré.

Nous avons également rencontré des difficultés liées à la logistique. Le temps de livraison de nos pièces a été très long. En effet, nous avons attendu un mois pour que les pièces nécessaires à la construction de la structure et les servomoteurs arrivent. Nous ne pouvions donc rien entreprendre de nouveau car nous ne pouvions pas savoir si de nouvelles difficultés allaient se présenter. Ce problème s’est réitéré avec un nouveau mois d’attente pour les dernières pièces qui nous manquaient.

Nous avons aussi rencontré un problème concernant les servomoteurs car rien n’indiquait sur le site du fournisseur leur manière de fonctionner, c’est-à-dire que nous ne savions pas qu’ils ne se contrôlaient que par la vitesse et non grâce à sa position angulaire. Nous avons donc testé tous les servomoteurs afin de régler les vitesses dans le but de faire un angle de 90° suite à un appui sur un bouton.
Cependant, la friction ne nous permettait pas de réaliser des angles de 90° à chaque fois donc nous avons utilisé des servomoteurs à contrôle angulaire qui ne peuvent tourner que de 270° mais qui permettent quand même d’avoir toutes les configurations pour résoudre le Rubik’s cube. Cependant, nous avons rencontré un problème avec les entretoises qui tiennent le Rubik’s cube. Elles se dévissent lorsque l’on les tourne dans un certain sens, il a donc fallu coller les entretoises au moteur.

Nous avons donc commandé et monté les nouveaux servomoteurs à contrôle angulaire, nous nous sommes malheureusement rendu compte que ces servomoteurs ne tournent pas parfaitement à 270°, nous avons 2 à 3° de décalage ce qui nous empêche de parfaitement utiliser notre solveur de Rubik’s cube.
De plus, nous avons dû changer de « type » de Rubik’s cube car nous avions commencé avec un cube « blanc ». En effet, quand nous faisions tourner les faces, le cube central tournait dans le vide donc nous n’arrivions pas à faire tourner la face. Nous avons donc opté pour le modèle « noir », qui lui est plus rigide mais qui peut être plus compliqué à faire tourner.

Nous avons eu aussi un servomoteur qui était défectueux; dès que nous le branchions, il créait un court-circuit ce qui éteignait l’Arduino instantanément.
Nous avons donc rencontré des difficultés de montages assez importantes. En effet, nous devions fixer le Rubik’s cube à tous les servomoteurs tout en nous assurant que les servomoteurs tiennent à la structure, ce qui n’était pas une mince affaire.

Vidéo du solveur de Rubiks Cube en action:

Conclusion :

Le résultat final est conforme au cahier des charges car il permet à une personne de résoudre le Rubik’s cube par l’intermédiaire de servomoteurs. Cependant, il serait possible d’améliorer de nombreux points afin de rendre l’utilisation de notre système plus facile et plus rapide. Pour commencer, le système frotte donc nous perdons en rapidité. Il nous faudrait donc un moyen afin de rendre la rotation du Rubik’s cube plus fluide ou de mieux centrer nos servomoteurs. Nous pourrions aussi surement améliorer la visibilité en ayant un moyen de voir le Rubik’s cube sans l’intermédiaire d’un miroir, pourquoi pas une caméra qui nous permettrait de voir toutes les faces du Rubik’s cube en même temps grâce à un moniteur externe. Enfin, nous pourrions avoir un tableau de jeu plus agréable pour l’utilisateur, c’est-à-dire un tableau de jeu qui pourrait plus ressembler à ceux des bornes d’arcade avec des boutons plus gros donc plus faciles à manipuler.

Display box

Publié le 4 juin 2021 par DESTOMBES Eli

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è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è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 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’’

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.

É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

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

Publié le 4 juin 2021 par macochet

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

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

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é

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 :

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.

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

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.

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

Soufflerie aérodynamique à flux laminaire

Publié le 25 juin 2019 par GUERINEAU Maxence

Bonjour à tous!

En cette fin de cycle préparatoire de Polytech Angers, nous avons pu réaliser un projet de conception. Nous nous sommes imposé comme objectif de réaliser un projet qui nécessiterait la mise en pratique de compétences et connaissances acquises durant ce cycle préparatoire.Quant au choix de notre sujet, nous avons décidé d’approfondir un phénomène découvert lors d’une séance de travaux pratique de mécanique appliquée. En effet, ce TP était consacré à l’étude de l’écoulement de l’air. Concept que nous avions déjà abordé en première année, en mécanique des fluides. L’un des objectifs, ce jour-là, fut de mesurer la portance et la traînée aérodynamiques d’une aile pour différents angles d’attaques d’un profil d’aile.

Nous avons pu conclure qu’après un certain angle d’incidence entre l’aile et le flux d’air généré par le tunnel, l’aile perd subitement la plupart de sa portance aérodynamique ce qui s’apparente à sa capacité à “voler”. Cela correspond dans l’aviation au phénomène de décrochage, qui est la principale cause d’accident mortel en aviation commerciale.
Ainsi, nous avons choisi d’étudier ce phénomène et de l’expliquer de manière simple et visuelle en construisant notre propre soufflerie aérodynamique à flux laminaire.

Objectifs :

Afin d’expliquer simplement comment une aile subit un décrochage nous avons donc construit une soufflerie, avec l’ajout de vapeur épaisse pour visualiser l’action de l’air sur l’aile. En effet lors du décrochage, on peut visuellement noter des turbulences dans l’air.

Observez sur le dessin ci-dessous les flux d’air sur toute la surface de l’aile.

À mesure que l’angle d’attaque augmente, le flux d’air supérieur commence à se séparer de la queue de l’aile. Cela crée des turbulences dans son sillage.

Enfin, l’avion décroche lorsque l’angle d’attaque critique, spécifique à la surface portante, est dépassé. Après quoi, le flux d’air supérieur se sépare soudainement de l’aile, ce qui réduit dangereusement la portance. L’avion est donc en situation de décrochage.

Expérimentations :

Une de nos première réalisation fut de créer une ébauche en 3D de notre projet afin de pouvoir étudier les problèmes auxquels nous allions être confrontés. Pour cela, nous avons utilisé le logiciel Sketchup Web qui a l’avantage d’être sur un serveur en ligne et donc d’être accessible sur n’importe quel ordinateur, sans avoir à télécharger de logiciel.

Un des éléments principaux de notre soufflerie , l’aile(4), fut imprimés en 3D afin d’assurer une pièce la plus lisse possible. Le forme de l’aile est un véritable profilé, car il correspond au profil NACA 4418 utilisé sur de véritables aéronefs.
Pour notre expérience, nous avions besoin d’amener de la vapeur dans notre tunnel, nous avons donc placé un ventilateur(5) à l’envers, à sa sortie. Ce qui a pour effet d’aspirer l’air, avec peu de perturbations.
Toutefois, cet air est très turbulent et donc rend la visualisation difficile, nous avons donc placé une structure en nid d’abeilles(1), imprimée en 3D, afin de rectifier le flot d’air et ainsi avoir un flux plus ou moins laminaire.
Afin de pouvoir observer les flux de vapeur plus facilement nous avons placé une rangée de LEDs(2) sur le dessus du tunnel.
Pour pouvoir mesurer la vitesse du vent nous avons mis en place une sonde de Pitot(3), nous l’avons placé sur le bas du tunnel, là où elle génère le moins de turbulence.

Enfin, le pilotage de l’ensemble fut réalisé grâce à la carte programmable Arduino Uno. Le pilotage du ventilateur, des lumières et du servomoteur se fait à l’aide de potentiomètre et de bouton-poussoir.
La mesure de la vitesse du vent dans le tunnel est lisible depuis l’environnement de développement d’Arduino.

Aperçu du rendu final :

Conclusion :

L’expérience fut donc enrichissante et stimulante, que ce soit en terme de travail d’équipe ou de résolution de problèmes. De plus, ce fut l’occasion d’en apprendre davantage sur des sujets qui nous passionnent, et d’expérimenter dans ces domaines. Nous avons pu travailler avec de nombreux professeurs et techniciens qui nous ont partagé leurs connaissances et expériences, ce que nous avons particulièrement apprécié et nous les en remercions.

Macadré Clément
Guerineau Maxence

Projet Peip2 : Dépollution, un serious game basé sur Unity3D

Publié le 25 juin 2019 par BATAILLE Alexandre

Logo du jeu – Dépollution

Bonjour chers lecteurs et lectrices,

Nous sommes trois étudiants du second cycle préparatoire de Polytech Angers, Alexandre, Arthur et Veton. Durant notre quatrième semestre, nous devions travailler sur un projet de conception pour un total de 80h. Nous avions choisi celui qui portait sur la mise en sécurité d’un site industriel pour l’intérêt qu’il offrait à la fois sur les filières BEMS et SAGI par le biais des contrôles de sécurité sur un site industriel et sur l’utilisation d’un moteur graphique. Dépollution est un serious game basé sur Unity 3D.

Photo de groupe De gauche à droite : Veton G., Arthur C. et Alexandre B.

Photo de groupe
De gauche à droite : Veton Gashi, Arthur Cochennec et Alexandre Bataille

Notre objectif

Le but de ce projet est d’apprendre à reconnaître les différents polluants et dangers que nous pourrions trouver sur un site industriel désaffecté et de pouvoir évaluer leur dangerosité. Le joueur devra utiliser la solution adéquate pour décontaminer chaque composant sensible du site suivant les mesures qui lui seront annoncés.

Le jeu se veut à la fois sérieux et ludique, principe du serious game en anglais. Vous jouerez le rôle de l’ancien directeur dont son but consiste à nettoyer toute la zone dans un temps imparti.

Avec cette article nous voulons vous présenter comment nous en sommes arrivé là. D’une part, nous avons découpé le travail en trois parties: la conception du terrain, le codage et la collecte de données. Pour le dernier, nous n’en parlerons que brièvement. Il ne s’agit que de recherches approfondies sur les différents produits et matériaux toxiques que l’on peut retrouver dans une centrale.

Le level design

Petite aparté, le level design consiste en la création des niveaux et l’environnement présent(s) dans un jeux vidéos ainsi que ses éléments décoratifs.

Dans notre cas, nous avons décidé de démarrer sur une île pour sa simplicité aux niveaux des bordures (la carte étant entourée d’eau) et qui est plutôt grande afin de créer différentes zones.

Capture d’écran de notre usine sur Unity 3D

L’usine présente un complexe industriel similaire aux centrales à charbon déjà existantes. Nous avons choisi une usine à charbon plutôt qu’une centrale nucléaire par exemple, parce que celle-ci présente davantage d’éléments polluants de risques différents et plus ou moins dangereux pour l’homme et l’environnement.

Capture d’écran de la carrière sur ledit logiciel

Nous souhaitions rajouter une carrière afin d’ajouter un autre univers lié à l’exploitation des ressources naturelles, ici celle du charbon.

Capture d’écran du lac (Unity 3D)

Enfin, nous avons créé un lac pour le refroidissement de la centrale, lui-même lié à la carrière via l’écoulement des eaux.

Le game design

Le game design quant à lui décrit tout ce qui se rapporte aux règles du jeu, à l’élaboration des mécaniques de gameplay, à la physique des éléments et bien plus.

Celui-ci se résume au codage que nous avons fait avec le langage C#. Le codage est sans aucun doute la partie la plus fastidieuse et la plus complexe du projet.

D’une part, nous avions choisi de commencer par l’élaboration d’un cycle jour/nuit ainsi qu’un chronomètre. Très vite, nous avons remplacé le second par une barre de vie qui diminue au fil du temps et qui décélère plus le joueur arrive à dépolluer correctement. Nous avons ensuite ajouté une fenêtre de fin pour indiquer que le joueur a réussi sa mission et a contrario, un game over. Puis nous avons fini sur les éléments toxiques, avec des interactions pouvant ajouter une couleur en fonction du bon ou du mauvais choix qui a été émis.

Voici une petite présentation du jeu en vidéo :

Les problèmes rencontrés

Nous avions rencontré quelques problèmes au cours de nos sessions de projet. Avant toute chose, nous devions nous approprier le logiciel Unity3D à l’aide du cours de M. Richard et le projet initial mis à disposition par M. Capelle, nos deux professeurs référents. Malheureusement, nous n’avons pas reçu la partie xml du fichier sur laquelle nous devions nous reposer afin de générer un texte automatique.
À cela s’ajoute la corruption de données dû aux mises à jour. Il était donc important de vérifier que nous avions la bonne version de Unity, celle avec laquelle nous avions commencé la première fois. D’autre part, le jeu est assez volumineux et pas bien optimisé ce qui rajoute de la latence lorsque nous voulons ajouter de la flore sur la carte, comme des arbres par exemple ou bien de l’eau en mouvement. Ainsi, nous avons dû nous dispenser de ces idées pour la conception du terrain.

Ce que nous retenons de ce projet

Le projet était en somme très attrayant, nous avons pu découvrir les différentes étapes lors de la conception d’un jeu vidéo, mais aussi comprendre le fonctionnement d’un moteur graphique. Également, ce projet nous a permis d’approfondir nos connaissances au niveau de la programmation avec des exemples concrets comme la création d’un game over.

La partie sur l’élaboration du terrain demandait assez de minutie et de patience mais le rendu final était au delà de ce que nous nous imaginions. L’environnement est soigné, détaillé et les textures sont de plutôt bonne qualité.

D’un point de vue global, ce projet nous a permis de progresser sur notre manière d’appréhender un travail de groupe, sur la diffusion des connaissances et sur notre organisation.

Lanceur de ficelle

Publié le 25 juin 2019 par JUGLET Alexis

Bâti

Lanceur de ficelle

Bonjour,

Nous sommes 2 étudiants de 2ème année du cycle préparatoire de Polytech Angers. Lors de notre 4ème semestre, nous avons eu la chance de travailler sur le projet ” lanceur de ficelle”.

Un lanceur de ficelle, c’est quoi ?

C’est tout simple ! Un lanceur de ficelle est un système constitué de 2 roues qui propulsent un fil continuellement.Voici une vidéo pour mieux comprendre le principe: https://www.youtube.com/watch?v=rffAjZPmkuU

Les objectifs :

En partant du prototype déjà créé par le groupe précédent (voici son article : https://blog.univ-angers.fr/istiaprojetsei2/2018/06/20/projet-lanceur-de-ficelle/ ), nous devions créer des ondulations puis automatiser le système pour réaliser automatiquement des formes spécifiques.

Travail réalisé :

1) Prise en main

Dans un premier temps, nous avons pris en main le prototype réalisé l’année dernière puis nous avons remplacé le pack de pile qui alimentait les moteurs par un transformateur. Cela a permis d’avoir une source d’énergie plus stable.

2) Recherche de solutions

Nous avons commencé par chercher une solution pour créer des ondulations. Nous avons finalement retenue 3 solutions. Premièrement, utiliser un servomoteur pour diriger l’axe et ainsi créer des vagues :

Servomoteur de l’axe

Après plusieurs essais, nous avons conçu un bras en carton commandé par le servomoteur pour “taper” la ficelle et ainsi créer des vagues.

Bras en carton

Enfin, nous avons remarqué que sur le prototype précédent, le fil subissait beaucoup de frottements. C’est pourquoi nous avons conçu un guide pour l’envoyer entre les 2 roues et limiter le plus possible les frottements. Il a été conçu sous SolidWorks puis imprimer en 3D.

Guide conçu sous SolidWorks

Guide monté sur le prototype

Voici la version finale du prototype :

Prototype final

3) Automatisation

Puisque que notre prototype fonctionnait plutôt bien, nous avons débuté l’automatisation du système. L’automatisation c’est fait via une carte Arduino et un shield. Un Shield est une extension de l’Arduino qui permet d’alimenter nos 2 moteurs avec un courant suffisamment important. Puis nous avons écrit un programme commandant les 2 moteurs et les 2 servomoteurs simultanément pour obtenir des figures.

Carte Arduino et Shield

4) Conception de la version finale

Etant satisfait de notre prototype et de l’automatisation, nous avons poursuivit le projet par la conception de la version finale. Le but est de réduire la taille du lanceur et de le rendre plus stable. La solution retenue était de déplacer le centre de gravité du lanceur vers le centre du bâti. Nous avons donc conçu un bâti complètement démontable pour pouvoir l’imprimé pièce par pièce. Voici quelques exemples de fichier SolidWorks :

Côté gauche

Bas

Bâti complet

Puis nous les avons imprimés via l’imprimante 3D disponible au Fablab. Voici le résultat avec seulement certaines pièces :

Bâti

Nous avons aussi imprimé le bras qui permet de “taper” le fil :

Bras sous SolidWorks

Bras imprimé

Afin de distribuer la rotation du servomoteur à l’axe, nous avons opté pour un système poulie-courroie . Nous avons commandé la courroie et conçu sous SolidWorks puis imprimer les poulies :

Système poulie-courroie

La plaque contenant les moteurs et le servomoteur du bras a aussi été conçue sous SolidWorks pour ensuite être usinée via un Charly Robot . C’est une commande numérique qui permet, à l’aide d’une fraise, de détourer une pièce.

Version prototype

Version finale

Des roulements aux extrémités de l’axe ont été ajoutés pour assurer une rotation avec le moins de frottements possible.

Conclusion

Nous sommes fiers du résultat obtenu. La version prototype fonctionnait très bien. Cependant le passage à la version finale fut assez complexe et malheureusement nous n’avons pas pu terminer la version finale.

Goodies Polytech Angers

Publié le 6 juin 2019 par HUET Aristide

Nous avons été 3 à travailler sur ce projet : Manal EL AZHAR, Guillaume ROUZES & Aristide HUET.
Notre projet était de concevoir 2 goodies Polytech par personne. Il était très intéressant car cette année l’école est passée de ISTIA à Polytech Angers. Nous avons été accompagnés par deux professeurs : Mme. Cécile GREMY-GROS et M. Pascal CRUBLEAU. Avant de débuter nos conceptions, nous avons effectuer un benchmark ainsi que la formalisation de l’identité de l’école.

Le Benchmark

Les benchmarks sont souvent utilisés pour faire une étude comparative sur le marché. En l’occurrence, nous avions fait un benchmark pour comparer les différents goodies déjà existants dans les autres écoles Polytech par exemple ou même sur un autre continent, comme par exemple avec Harvard aux Etats-Unis.

Nous avions regroupés nos découvertes ainsi que nos idées dans le format d’une mind map (cf. fig. 1).

figure 1 : Mind map des goodies existants dans le monde

Grâce à nos recherches, nous avions pu conclure que les goodies d’une manière générale étaient très bénéfique pour une entreprise/école pour en diffuser l’image.

L’identité de l’école

Pour formaliser l’identité de l’école, nous avions décidés de réaliser un sondage sur l’outil Google Forms pour permettre aux étudiants et aux membres du personnel de nous donner leur avis sur l’identité et sur les goodies en général. A ce sondage nous avons eu 214 réponses, d’étudiants et du personnels. A partir de ces résultats, nous en avons conclut que Polytech Angers est une école dynamique avec beaucoup d’événements organisés tout au long de l’année. C’est aussi une école à échelle humaine avec un nombre modéré d’étudiants, ce qui permet une certaine proximité avec les professeurs. C’est également une école internationale comme nous le montre l’instauration de la semaine internationale avec des intervenants venant de différents pays européens, Lituanie, Portugal, Irlande, Allemagne…

Sur le sondage, nous avions proposer une liste de 16 goodies que nous trouvions intéressant à concevoir et prototyper, les étudiants et le membre du personnel avaient la possibilité de choisir 6 goodies parmi les 16. Nous avions donc une idée des goodies que les gens préfères, avec en tête le T-shirt, la gourde et le port-clés. (cf. fig. 2)

figure 2 : Diagramme bâton des goodies les plus demandés

Suite à ce sondage, nous avions tous les trois choisi 2 goodies chacun dans la liste :

Manal : La gourde & le tote bag
Guillaume : Le T-Shirt & le mug
Aristide : La bague d’obtention de diplôme & le porte-clés décapsuleur

Présentation des goodies sélectionnés

Guillaume

Pour le mug, je voulais un objet à l’image de l’école et de la ville d’Angers. Pour représenter l’école le logo suffit. Pour représenter la ville, la skyline d’Angers fait tout le tour du mug, avec des monuments importants de la ville, le théâtre, la cathédrale par exemple. La couleur bleu marine du mug rappel le réseau Polytech avec ses 13 000 étudiants.

figure 3 : Aperçu du mug Polytech

Concernant le T-shirt. De part notre Benchmark nous avons remarqué que différentes Universités américaines utilisées le modèle du T-shirt baseball. J’ai donc décidé d’en prendre inspiration. En utilisant une fois de plus couleur bleu marine représentant le réseau Polytech et qui se marie bien avec le logo de l’école. Pour le prototype du T-shirt j’ai acheté sur internet le modèle puis j’ai fait floquer le T-shirt dans une boutique Angevine. Le résultat est à la hauteur des espérances et de bonne qualité.

figure 4 : Aperçu du T-shirt Polytech

Aristide

J’ai choisi la bague d’obtention de diplôme et le porte-clés décapsuleur car je les trouvais très intéressant au niveau de la conception ainsi que pour l’aspect créatif.

La bague d’obtention de diplôme est un bijou communément distribué au Etats-Unis lors de l’obtention de diplôme des étudiants. C’est une bonne manière de se remémorer les études et en garder un bon souvenir. On peut également s’en servir pour savoir ou est-ce que un ancien étudiant a étudié.
Pour la modéliser, j’ai utilisé un logiciel qui se nomme Solidwork’s. C’est un logiciel souvent utilisé dans le milieu industriel pour concevoir des pièces avec des dimensions exacts et ensuite les usiner.
J’ai voulu garder un aspect simple pour que la bague puisse être porter plus facilement avec d’autres bijoux. Sur le bague se trouve le sigle ‘P’ de Polytech, à gauche du sigle se trouve l’année de l’obtention du diplôme et à droite se trouve la ville de l’obtention du diplôme. Etant donné que Polytech est un réseau, cela est intéressant d’indiquer la ville pour que les ingénieurs se reconnaissent lors de divers événements liés aux anciens étudiants.

figure 5 : Aperçu de la bague sur le logiciel Solidwork’s

Pour le porte-clés décapsuleur, j’ai décidé d’accentuer plus la conception sur l’aspect créatif en transformant le logo Polytech en décapsuleur. Je voulais créer un goodies esthétique tout en étant simple. Pour la modélisation, j’ai également utilisé le logiciel Solidwork’s.
J’ai pris l’initiative de changer les dimensions pour l’adapter à un décapsuleur. En effet, j’ai rogné sur la partie circulaire du ‘P’ pour pouvoir ouvrir une bouteille et j’ai allongé la barre du ‘P’ pour avoir une meilleure prise en main.
Grâce à son design original et hors du commun, ce porte-clés décapsuleur peut être utilisé durant un afterwork par exemple et commencer une conversation à propos de l’école.

figure 6 : Photographie du décapsuleur en aluminium

J’ai fait usiner le décapsuleur par un particulier. Le résultat final est correct et en aluminium, ce qui le rend léger et solide en même temps.

Manal

Parmi l’ensemble des goodies proposés, j’ai choisi le sac en tissu et la gourde, car ce sont deux objets que j’utilise dans la vie courante. Ils permettront aussi d’aider les étudiants et le personnel à réduire les déchets qu’ils produisent. (ex :bouteilles en plastiques, sac en plastiques)

Concernant le tote bag, j’ai créé un sac en tissu rectangulaire bleu marine avec de larges anses sur lesquels est inscrit le nom de l’école. J’ai aussi ajouté un grand logo Polytech sur le devant du sac afin de mieux diffuser l’image de l’école sur le campus ou dans la ville par exemple. Pour ce qui est de la couleur, j’ai choisi le bleu marine qui est une des deux couleurs représentatives de Polytech qui compte plus de 15 000 étudiants en France à ce jour. Elle permettra ainsi au sac de sortir du lot, car la majorité des sacs en tissus sont de couleur beige/écru.

figure 7 : Aperçu du Tote Bag

Pour ce qui est de la gourde, je me suis inspirée de ma bouteille d’eau, en effet, j’ai repris l’idée de la boucle sur le bouchon afin d’y intégrer le logo du réseau. J’ai aussi pris inspiration dans les bouteilles isotherme Swell au niveau de la forme et du matériau utilisée pour les bouteilles (acier). Dans mon cas, j’ai privilégié l’aluminium, car plus léger et moins chère.

figure 8 : Conception de la gourde

J’ai ensuite dessiné ne première esquisse de la bouteille, puis je l’ai conçu sur Solidworks. Voici le résultat final sur Solidworks (cf figure ci-dessous) , comme vous pouvez le constater, le nom Polytech Angers est inscrit sur la bouteille et sur le bouchon. J’ai également modifié la position initiale de la poignée, car la première ne correspondait pas avec le haut de la bouteille. Pour le prototype, j’ai choisi de seulement réaliser le bouchon car c’est l’élément principal du goodies et que c’est elle qui diffuse le plus l’image de l’école. J’ai donc décidé d’imprimer le bouchon en 3D malheureusement j’ai rencontré quelques difficultés lors de l’impression mais le résultat final est satisfaisant.

figure 9 : Prototype du bouchon Polytech Angers

Conclusion

Ce projet fut très intéressant pour nous trois. L’idée de concevoir un goodies pour diffuser l’image de l’école nous a directement charmée. Nous avons aimer le côté créatif que le projet nous a imposé et le fait de trouver des designs innovants était un réel défi. Les 3 goodies que nous avons prototyper sont de bonnes qualités mais par manque de temps et de budget, nous n’avons pu exploiter le maximum de nos goodies.

Polytech Angers – Projets PEIP2

Projets de deuxième année du cyle prépa Peip2

Archives par mot-clé : Polytech Angers

Virtual Mimic !

Projet Rubiks Cube 2021 Antoine Nolan Nicolas

Display box

Projet LoRa

Contexte :

Le matériel et logiciels utilisés :

Déroulement du projet :

Application concrète de notre projet :

Conclusion :

Soufflerie aérodynamique à flux laminaire

Objectifs :

Expérimentations :

Conclusion :

Projet Peip2 : Dépollution, un serious game basé sur Unity3D

Lanceur de ficelle

Goodies Polytech Angers