Borne d’arcade multijoueur transportable

Publié le 9 juin 2021 par Titouan Loiseau

Bonjour à tous!

Nous sommes deux étudiants (Titouan Loiseau et Amand Messé) en deuxième année du cycle ingénieur à Polytech Angers, et dans le cadre de nos études nous avons réalisé un projet en groupe. Le thème de notre projet était “Borne d’arcade”, et nous étions 3 groupes sur le même thème. Alors histoire d’innover, on a décidé de faire une borne d’arcade un peu originale.

Notre idée était de réaliser deux bornes d’arcade identiques mais distinctes, pouvant jouer en multijoueur, avec la contrainte que ces dernières doivent être transportables.
On est donc parti sur un design dit “Tabletop” qui désigne les bornes d’arcade qui se posent sur une table pour jouer, à l’exception que nos bornes auraient un écran pliable afin de gagner de la place.

Exemple de borne d’arcade “Tabletop”

Contraintes:

Chacune des deux bornes devait être pour 1 joueur, et devait comporter les éléments suivants:

8 boutons (A, B, X, Y, L, R, Start, Select)
Un joystick
Des haut-parleurs
Un écran repliable
Des prises USB et Ethernet à l’arrière pour connecter une manette ou un câble réseau à la borne

Modélisation:

On a donc modélisé la borne telle qu’on la voulait sur Solidworks (un logiciel de conception assistée par ordinateur), en prenant en compte les dimensions des éléments que l’on a choisis (boutons, joystick, etc…).

Modèle Solidworks de la borne d’arcade

Émulation:

Pour la partie logicielle, nous avons utilisé un Raspberry Pi dans chaque borne qui fait office de mini-ordinateur afin de jouer aux jeux. Nous avons installé dessus un système d’exploitation appelé Recalbox qui est spécialisé dans l’émulation d’une multitude de systèmes et qui a été créé pour être utilisé dans les bornes d’arcade. En plus, Recalbox possède une fonction nommée Netplay, qui permet de jouer à des jeux multijoueur en réseau en connectant les Raspberry Pi à internet.

De base, nous voulions que les bornes puissent se connecter directement entre elles via un câble sans avoir à passer par un réseau externe. Nous avons lu plusieurs posts faits sur le forum de Recalbox et l’un des modérateurs a dit qu’à l’aide d’un câble Ethernet croisé, c’était possible. Malheureusement, on n’a trouvé aucune autre information sur ce sujet, et nous n’étions pas sûrs qu’une telle liaison marcherait. Nous avons tout de même décidé d’essayer, et nous avons connecté les deux Raspberry Pi ensemble et lancé le netplay.

Essai de liaison directe

Et malheureusement, cela n’a pas fonctionné, et nous n’avons pas réussi à résoudre ce problème.

Echec de la liaison directe

Réalisation:

Après avoir commandé le matériel, on a commencé à couper les planches et à monter les bornes.

Photos de la borne d’arcade une fois montée

Malheureusement on n’a pas pu tout faire à temps, notamment l’usinage des pièces pour les écrans.

Conclusion:

Au final ce projet nous a plu, et le voir prendre forme était plaisant. Même si nous n’avons pas pu le finir en entier, ce projet nous a permis de mieux nous rendre compte de l’organisation que représente sa réalisation. Nous sommes heureux d’avoir fait ce projet qui représente pour nous une belle expérience de notre parcours en études d’ingénierie.

Merci d’avoir lu cet article, en espérant qu’il vous ait plu!

Projet d’optimisation d’un véhicule à air comprimé miniature

Publié le 7 juin 2021 par BOURDAIS Remi

Bonjour à tous, nous sommes un groupe de quatre étudiants en 2ème année du cycle préparatoire de Polytech Angers. Au cours de notre dernier semestre de formation nous avons réalisé un projet qui avait pour objectif : l’amélioration d’un véhicule à air comprimé fourni par l’école.

Vue générale de la voiture étudiée à air comprimé

1) Description du travail réalisé :

Nous avons passé la majeure partie du temps à réaliser le véhicule sous CAO (Conception Assistée par Ordinateur) sur le logiciel OnShape afin de reproduire le véhicule virtuellement.

Exemple de conception de pièces sous CAO avec esquisse au dessus et rendu final en-dessous (à gauche: un piston | à droite: le réservoir d’air)

Nous avons ensuite cherché à calculer la vitesse maximale théorique du véhicule afin de chercher à l’optimiser. Pour ce faire nous avons utilisé Excel:

Exemple de calcul sous excel:Tableau des différentes forces résultantes en fonction de l’angle de départ de la roue motrice

Exemple de formule utilisée (à gauche) et exemple d’utilisation de la CAO pour trouver les couples du système (à droite)

Après une série d’application de formules, nous avons trouvé une vitesse moyenne de 0,31 mètre par seconde.

Une fois cette vitesse obtenue nous avons émis des hypothèses permettant d’améliorer le véhicule telles que :
– Changer le matériau du réservoir (passer du plastique au verre pour augmenter la pression dans celui-ci)
– Remplacer notre réservoir par un réservoir plus grand afin que la voiture puisse rouler plus longtemps
– Remplir notre réservoir avec du protoxyde d’azote à 60 bars au lieu de l’air
– Changer le bâti en plastique par un bâti en carbone
– Supprimer des pièces non-obligatoires sur la voiture
– Calculer les forces pour optimiser les liaisons et ainsi avoir un meilleur rendement
– Changer le revêtement des roues

2) Conclusion :

Même si nous n’avons pas pu mettre en pratique toutes nos théories à cause de la situation sanitaire, nous avons pu améliorer le véhicule théoriquement. De plus ce projet de groupe nous a permis de travailler la communication et la concertation au sein d’une équipe. Il nous a également permis de mettre en pratique nos connaissances apprises au cours de notre cycle préparatoire. Ce fut une expérience très enrichissante.

Bourdais Rémi
Casteur Axel
Gacoin Baptiste
Poupet Eloi

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

Automate Animé en CAO

Publié le 2 juin 2021 par GUITARD Paul

Bonjour à tous !
Dans le cadre d’un projet de conception mis en place par Polytech Angers, nous avons travaillé sur la création d’un automate animé. L’objectif était de s’inspirer des travaux Disney Research afin de créer notre propre automate.

Automate : Appareil mû par un mécanisme intérieur et imitant les mouvements d’un être vivant

Automate Disney Research

Notre projet s’est décomposé en deux étapes :

Une première étape de modélisation sur un logiciel de CAO.
Une seconde étape de conception grâce aux imprimantes 3D de Polytech.

Avant de commencer à modéliser en CAO, il a fallu trouver des idées de mouvement à reproduire. Après quelques heures de recherches nous avons décidé de reproduire le mouvement d’un battement d’ailes. La première chose à faire a été de sélectionner un logiciel de modélisation 3D, nous avons rapidement choisi de travailler sur OnShape car le site permet le travail collaboratif en ligne.
Nos premiers mécanismes créés sur OnShape ne fonctionnaient pas.

Toute première tentative de mécanisme

Nous avons donc décidé d’approfondir nos recherches sur le mouvement de l’oiseau ainsi que sur les différents mécanismes permettant de le reproduire. Voici un aperçu du premier mécanisme ayant réellement marché :

Vue de face

Vue de haut

Ce premier mécanisme ne fonctionnait que sur un logiciel de CAO car il ne prenait pas en compte les contraintes des matériaux. Par exemple, les engrenages n’avaient pas de dents mais ils s’entrainaient tout de même en rotation.

Il nous a donc fallu adapter ce mécanisme à des conditions réelles. Notamment en créant de vrais engrenages et en faisant en sorte de pouvoir assembler toutes les pièces une fois imprimées.

Mécanisme vu de face

Mécanisme vu de haut

Ensuite, nous sommes passés à la deuxième phase de notre projet, l’impression et l’assemblage. Avant d’imprimer nous avons dû redimensionner toutes nos partie d’ailes afin que l’oiseau ne soit pas trop grand. Pour imprimer nous avons transféré toutes les pièces une par une sur le logiciel IdeaMaker.

Image de l’interface IdeaMaker

Après un bref tutoriel nous avons lancé l’impression de nos premières pièces :

Pour assembler les différentes parties de notre oiseau nous avons choisi d’utiliser des vis M3/40, c’est-à-dire des vis de 3 mm de diamètre et de 40 mm de longueur.
Une fois totalement monté, le mécanisme fonctionne à la perfection.

Un seul problème était à noter, les boulons se dévissaient petit à petit à mesure que le mécanisme fonctionnait. Nous avons donc cherché des solutions afin que les différentes pièces soient bloquées dans le temps. Après avoir discuté avec notre professeur référent nous avons décidé de commander des écrous frein puis nous avons remonté l’oiseau avec ces derniers.

Ecrous frein: la partie bleu est fait de caoutchouc et permet d’augmenter l’adhérence de l’écrou au filetage de la vis.

En parallèle nous avons développé un autre mécanisme permettant de faire un mouvement de tête. Nous avons voulu l’imprimer en 3D mais nous n’avons pas pu car l’imprimante était en panne et il ne nous restait plus beaucoup de temps pour finir le projet.
Nous avons choisi une bielle manivelle reliée à un engrenage, ce qui permet de faire monter et descendre la tête.

Pour le relier au premier socle, nous avons choisi de décaler vers le centre le mouvement de rotation grâce à deux arbres en rotation reliés par deux petits engrenages:

Voici des images de la totalité de notre travail en CAO:

Vue de devant

Vue de profil

Enfin, nous avons commencé à rajouter une couche esthétique en rajoutant une queue et des pates à l’oiseau:

Conclusion:

Même si l’oiseau une fois terminé propose un mouvement vraiment intéressant, on ne peut pas dire que l’automate est terminé pour autant. Nous aurions aimé y ajouter un mouvement de queue et imprimer le mécanisme de tête. Mais pour cela il aurait fallu concevoir de nouvelles pièces et réfléchir à de nouveaux mécanismes afin de créer ces nouveaux mouvements. Seulement cela demande énormément de temps. À cause de quelques pannes d’imprimante sur les dernières séances des projets, nous n’avons pas pu réaliser les quelques impressions qui nous manquaient, nous avons néanmoins réalisé au maximum la CAO.

Création d’un carrousel simplifié (calculs RDM)

Publié le 31 mai 2021 par MORICEAU Tanguy

Cher lecteur, Chère lectrice,

Nous sommes trois étudiants en PeiP2-A (deuxième année de classe préparatoire intégrée) à l’école d’ingénieurs Polytech Angers, et c’est à travers cet article que nous allons vous résumer et vous expliquer notre travail de groupe.

Commençons d’abord par nous présenter.
Nous sommes Alexi Schmid, Virgile Siegler et Tanguy Moriceau, âgés de vingt ans et futurs ingénieurs.

Comme annoncé précédemment, nous avons eu le plaisir de travailler tous les trois en groupe durant notre dernier semestre de classe préparatoire, sur un projet de conception. Il y avait beaucoup de choix possibles (vraiment beaucoup) et nous avons choisi de travailler sur la conception d’un carrousel simplifié.

Image 1 : Nous avons travaillé à la conception d’un carrousel comme celui-ci (mais en plus simple parce que là, il y a trop de chaises).

Pourquoi un tel choix ? Nous voulions tester nos capacités et compétences dans des domaines spécifiques. Dans notre cas, ces domaines principaux étaient la résistance des matériaux et l’analyse des systèmes mécaniques (pour plus de précision sur ces sujets, rendez-vous au bas de l’article).

Des modules à l’école nous ont donnés des notions dans ces domaines, mais ce projet de conception n’avait rien à voir avec ce qu’on a fait en cours. Nous étions au maximum en autonomie et devions donc trouver toutes les solutions par nous-mêmes.
Ainsi, ce projet était pour nous un moyen de nous améliorer sur des sujets où nous n’étions pas forcément à l’aise.

1) Présentation du projet et du cahier des charges

L’objectif du projet est clair : concevoir un carrousel simplifié à l’aide de calculs de résistance des matériaux et des notions acquises durant les quatre semestres d’études.
Pour ce qui est du cahier des charges, il y avait différentes conditions à respecter, comme la vitesse maximale de rotation du poteau central (imposée à trente tours par minute), le nombre d’enfants pouvant s’asseoir dans le manège (quatre enfants maximum, tous assis sur des sièges différents et pesant environ quarante kilos chacun) ou même des dimensions de pièces (comme celle du poteau central, qui devait être d’une hauteur de deux mètres).
Enfin, le carrousel devait être le plus léger possible, afin de réduire les coûts matériels.

Image 2 : Schéma simplifié du carrousel (en jaune les quatre poutres supérieures, en rouge les sièges, en vert clair le poteau central et la courroie transmettant la rotation, en bleu le châssis, en vert foncé le couvercle du châssis et en violet le moteur, relié au réducteur).

2) Le travail réalisé

Pour réussir ce projet, nous avions deux tâches majeures à faire : la première, était de dimensionner l’intégralité des pièces du manège et de choisir les composants permettant de les lier entre elles. La seconde tâche était de choisir un moteur adapté et de concevoir un réducteur, nécessaire pour réduire la vitesse de rotation du moteur (rappelez-vous que notre manège doit tourner à la vitesse maximale de trente tours par minute !)

Nous avons naturellement commencé par faire un schéma du système à concevoir (voir Image 2), ce qui nous a permis de visualiser le carrousel et de faire ressortir ses points-clés (numérotés en gras sur l’Image 2).

Pour continuer, nous nous sommes engagés sur les calculs des forces appliquées aux quatre sièges. Celles-ci comprenaient la force centrifuge, la résistance à l’air, le poids et les forces radiales et tangentielles. Enfin, nous avons calculé l’angle α, situé entre le câble soutenant le siège et la
perpendiculaire au sol (cet angle est aussi représenté sur l’Image 2).

Cet angle particulier change de valeur suivant la vitesse de rotation du manège. En effet, plus ce dernier tourne vite et plus l’angle α est élevé (car le siège subira une force centrifuge plus forte).
Nous avons donc calculé la valeur de cet angle pour la vitesse de rotation maximale, valant trente tours par minute.
Ainsi, à vitesse maximale, l’angle α vaut 62°.

Grâce aux valeurs des forces précédemment calculées et grâce à cet angle α désormais connu, nous avons mis en place différents torseurs de forces (si cette notion de torseur ne vous est pas familière, je vous renvoie ici pour plus d’explications sur leurs principes), aux points-clés du carrousel.

Avec ces torseurs nouvellement définis, nous avons utilisé le Principe Fondamental de la Statique (que vous êtes censés savoir maîtriser !) aux points-clés du manège, dans le but de déterminer, dans notre repère cartésien (repère tridimensionnel classique, dépendant de trois variables : x pour la longueur, y pour la largeur et z pour la hauteur), les valeurs des forces s’appliquant en ces mêmes points.

En connaissance des différentes forces, nous avons utilisé plusieurs formules issues de notre module de Propriétés et Résistance des Matériaux, pour déterminer les épaisseurs et les diamètres minimaux de pièces composant notre carrousel.
En faisant cela, nous avons aussi respecté une autre contrainte de notre cahier des charges, qui imposait une contrainte admissible de 120 MPa ou de 120 Newtons par millimètre carré (c’est-à-dire que le matériau en question doit pouvoir résister à une force de 120 Newtons, appliquée sur un millimètre carré) pour toutes les pièces.
Par exemple, ce sont avec ces formules que nous avons calculé le diamètre minimal à adopter pour le poteau central. Nous voulions que ce poteau soutienne tout le haut de la structure, mais avec le diamètre le plus faible possible, toujours dans le but de diminuer les coûts de production (il n’y a pas de petites économies !).

Pour continuer avec le poteau central, c’est en calculant son diamètre minimal que nous avons choisi les roulements (à partir d’une documentation issue de constructeurs) pouvant permettre sa rotation au sein de son châssis.
Suite à cela, nous avons de nouveau utilisé le Principe Fondamental de la Statique et les formules de notre module pour déterminer les diamètres intérieur (qui est en fait le diamètre extérieur du roulement défini précédemment) et extérieur adéquats du châssis.
Enfin, nous avons choisi une butée (l’élément se plaçant sous le poteau central, dans le châssis, et permettant la rotation) parmi celles qui nous étaient proposées.

Suite à cela, nous devions choisir les composants permettant de fixer les pièces entre elles, dans des liaisons d’encastrements, en sachant que les composants les plus efficaces pour faire cela sont des vis.
Nous avons donc calculé les forces et les contraintes de cisaillement et de traction (voir au bas de l’article pour plus de précisions) que subiront les vis, dans le but de déterminer leurs caractéristiques.
Celles-ci trouvées, nous avons choisi les vis appropriées (toujours grâce à la documentation) qui permettaient de maintenir le carrousel.

Par la suite, il nous fallait déterminer la courroie et la poulie à utiliser pour transmettre le mouvement de rotation, du réducteur jusqu’au poteau central.
Nous avons facilement choisi ces éléments grâce à nos résultats précédents, à la documentation et aux formules qui nous ont été données par notre professeur encadrant.
Pour finir, nous avons calculé le poids combiné de la poulie et de la courroie, ce qui a achevé la première partie de notre projet de conception.

La seconde partie de notre projet consistait à concevoir le réducteur et nous l’avons commencée en calculant la puissance nécessaire pour obtenir la vitesse de rotation maximale de trente tours par minute.
Après un simple calcul, nous avons trouvé la puissance minimale requise et avons, par la même occasion, choisi le moteur le plus adapté à notre cas de figure.

Ensuite, avec ce moteur, nous sommes passés à la conception du réducteur.
Nous avons calculé le taux de réduction de l’ensemble, c’est à dire le nombre de fois que l’on va réduire la vitesse initiale de sortie du moteur.
Par exemple, si notre moteur tourne à une vitesse de 1600 tours par minute et que l’on impose un taux de réduction de 4 au réducteur, la vitesse de rotation qui sera mesurée après ce dernier, sera de 400 tours par minute.

Avec ce taux de réduction et la documentation, nous avons déterminé qu’il fallait concevoir un réducteur à trois étages.

Image 3 : Schéma du réducteur à trois étages
(représentant les quatre arbres ou axes, les trois
engrenages et les forces s’appliquant sur ces derniers).

Pour continuer, nous devions trouver le nombre de dents adéquat pour chacune des roues et chacun des pignons. Pour faire cela, nous avons utilisé le solveur du logiciel Excel.
Nous avions plusieurs conditions à imposer, comme un nombre minimal de dents, le taux de réduction devait être compris dans un intervalle de 20% autour de sa valeur calculée, la masse de l’ensemble devait être la plus faible possible, etc.

Grâce aux calculs du solveur, nous avons obtenu les nombres optimaux de dents.
Ceci nous a ensuite permis de calculer le module de chacun des trois engrenages, un paramètre relatif à la périodicité et à la taille de ces mêmes dents.
Après avoir obtenu les modules, nous les avons normalisés (rapprochés d’une valeur entière normée et plausible).

Ensuite, comme nous avions toutes les caractéristiques nécessaires des engrenages, nous avons calculé les forces radiales et tangentielles (représentées sur l’Image 3) s’appliquant sur eux.
En effet, lorsque un pignon tourne, il va appliquer une certaine force sur la roue située au-dessous de lui, provoquant ainsi le phénomène de rotation. Ce sont donc ces forces que nous avons cherché à calculer.
C’est en utilisant à nouveau le Principe Fondamental de la Statique et des torseurs, que nous avons trouvé les valeurs des forces. Après avoir additionné ces dernières en respectant leur orientation dans notre repère cartésien, nous avons finalement obtenu trois forces générales, appliquées sur
chaque engrenage.

En nous rappelant qu’un de nos objectifs était de diminuer au maximum la masse du réducteur, nous avons rapprochés les engrenages entre eux. C’est donc en considérant la largeur des pignons, des roues et des roulements placés aux extrémités des arbres (roulements assurant la rotation des quatre arbres) que nous avons pu établir les distances minimales (appelées entretoises) entre tous les éléments intérieurs du réducteur.

Avec ces distances minimales, nous avons encore une fois utilisé le Principe Fondamental de la Statique et nos formules de Propriétés et Résistance des Matériaux, sur chacun des quatre arbres.
Cela nous a permis de connaître les valeurs des contraintes (principalement la flexion) subies par ces derniers. Enfin, c’est avec ces dernières valeurs calculées que nous avons déterminé le diamètre minimal à adopter pour chaque arbre.

Tout ceci achevé, il nous restait à choisir les différents composants nécessaires au bon fonctionnement du réducteur. C’est après avoir calculé les différentes vitesses de rotation des arbres, les couples transmis (le mouvement de rotation) et les forces appliquées sur chaque arbre, que nous avons choisi les roulements (différents de ceux utilisés plus haut, qui avaient été arbitrairement choisis, sans connaître les diamètres des arbres).
Nous avons ensuite sélectionné les épaulements (pièce mécanique servant à bloquer les roulements, pour leur empêcher tout mouvement) à partir des caractéristiques des roulements choisis.

Comme nous avons changé le type de roulement (rappelez-vous que nous avons arbitrairement considéré des roulements, au moment de calculer les entretoises entre tous les éléments intérieurs au réducteur !), nous avons dû recalculer ces distances minimales avec nos nouveaux roulements et nos épaulements.

Suite à cela, nous avons choisi d’après les diamètres minimaux des arbres, huit anneaux élastiques afin de maintenir les roulements et les arbres en place.
Pour terminer, nous avons choisi des clavettes (pièce mécanique se plaçant entre un pignon ou une roue et l’arbre en rotation auquel il/elle appartient) grâce à des formules spécifiques, décrivant la longueur minimale de ces dernières. Il s’agissait ici de calculer les contraintes que subiront ces six clavettes, pour chaque engrenage, afin de déterminer la longueur minimale à adopter, pour obtenir une résistance optimale.

3) Conclusion de notre projet de conception

Ce projet de conception, que nous avons réalisé durant notre quatrième semestre d’études, nous aura permis de réellement nous familiariser sur des sujets, au premier abord, compliqués.
Comme précisé au début de cet article, nous n’étions pas vraiment à l’aise avec les notions vues dans notre module de Propriétés et Résistance des Matériaux, ce que nous souhaitions donc changer.
Concevoir ce carrousel simplifié a été un véritable défi, où nous avons pu nous surpasser, tant sur le plan théorique que sur le plan humain.
Travailler avec d’autres personnes sur un projet commun est quelque chose de très enrichissant.
Cela nous permet d’exprimer notre point de vue, mais surtout de comprendre et de s’ouvrir à d’autres visions différentes de la notre : ce qui reste l’une des qualités les plus importantes d’un futur ingénieur.
______________________________________________________________________

Résistance des matériaux : discipline permettant d’étudier le comportement de différents matériaux au niveau local (sur un petit volume d’une pièce), de façon à étendre ce même comportement au niveau global (c’est-à-dire, à l’entière pièce considérée) et de calculer de façon détaillée les contraintes et les déformations subies par un matériau sous l’effet d’une sollicitation particulière (par exemple, le poids).

Analyse des systèmes mécaniques : discipline permettant l’étude de différents systèmes mécaniques comme un moteur de voiture, par exemple) à partir d’un schéma fonctionnel. Cette discipline est aussi utile pour déterminer les liaisons reliant des pièces entre elles et sert à choisir les composants qui permettent d’obtenir une telle liaison (un roulement à billes autorise une liaison pivot). Enfin, cette discipline intervient dans les transmissions de puissance, à travers des engrenages notamment.

Contrainte de cisaillement : contrainte mécanique appliquée de manière parallèle ou tangentielle à la face d’un matériau considéré.

Contrainte de traction : contrainte mécanique appliquée de manière perpendiculaire à deux faces opposées d’un matériau considéré, de façon à l’étirer pour mesurer le moment de rupture.

Crédits de l’Image 1 : Swing ride in Santa Cruz, the county seat and largest city of Santa Cruz County, California, photographie par Carol Highsmith, le 9 juin 2012, collection de la Bibliothèque du Congrès des États-Unis d’Amérique, œuvre placée dans le domaine public.

Les Image 2 et Image 3 ont été respectivement créées par Virgile Siegler et Alexi Schmid, dans le cadre de ce projet de conception.

Four solaire 2021 Louison-Tom-Thomas

Publié le 27 mai 2021 par COLLIN Louison

Bonjour à toutes et à tous !

Actuellement à Polyetch Angers, nous sommes 3 étudiants de Peip 2A (Thomas BEAUSSE, Tom CHARBONNEAU, Louison COLLIN). Dans le cadre de notre formation, nous avons dû effectuer un projet plus qu’intéressant liant plusieurs domaines (thermique, énergie, optique et un peu de mécanique). Ce projet consistait à imaginer et construire un four solaire du début à la fin pour ensuite l’utiliser dans la vie de tous les jours. Pour pouvoir réaliser le four correctement, nous avons dû définir trois sous parties. La première et la plus importante est celle concernant l’étude du four. Elle nous permet de comprendre quels sont les enjeux importants pour construire et réussir notre four. La seconde partie concerne la conception du four sur ordinateur. Cette étape permet de visualiser le four avant même de l’avoir construit. On peut s’apercevoir des éventuelles améliorations à apporter ou bien des erreurs à rectifier. Et pour finir, la dernière partie concerne la fabrication et la construction réelle du four : cette étape est l’aboutissement du projet.

Comment fonctionne un four solaire ? (Partie Étude)

Un four solaire est un système intéressant car pour garantir une bonne efficacité, il faut se pencher sur plusieurs points techniques. Tout d’abord, le four solaire contrairement à un four électrique classique à pour seule source de chaleur : Le soleil. L’installation d’une vitre transparente est donc obligatoire pour capter un maximum de rayons qui pourront être transmis à l’intérieur du four. Ceci nécessite par la suite des recherches et des calculs sur le rayonnement du soleil et sur le vitrage à choisir. Ensuite, la question sur le maintien de la chaleur à l’intérieur du four peut se poser. Pour une efficacité maximale du four, celui-ci doit être le plus hermétique possible. Il faut limiter le plus possible les pertes thermiques. Cela passe donc par une bonne isolation des parois en utilisant les bons matériaux. Il est donc nécessaire de s’intéresser de plus près aux phénomènes de transferts thermiques (Par exemple : effet de serre, émissivité, conduction, convection, corps noir…).

Schéma explicatif de l’effet de serre

Schéma explicatif du transfert par convection

Quel design choisir pour notre four ? (Parties Conception et Fabrication)

La conception (via SolidWorks) et la fabrication du four se sont décomposées en trois parties principales. D’abord la création des pièces, puis ensuite l’assemblage et enfin le montage

Création des pièces :

Un four ne se conçoit pas en un claquement de doigts. Il faut d’abord prendre connaissance de toutes les pièces nécessaires à la construction. Pour cela, on s’est aidé des recherches effectuées auparavant pour créer les pièces une par une avec les dimensions correspondantes. Pour notre four, une centaine de pièces ont dû être créées. Dans toutes ces pièces, on retrouve un bon nombre de planches, les panneaux d’isolant, des charnières, des roues pivotantes, un verrou …

Charniere

Roue

Verrou

Assemblage des pièces :

Une fois toutes les pièces créées, il faut les assembler les unes avec les autres. Cela permet de visualiser le four dans sa globalité avec les éventuelles problèmes ou améliorations à apporter. Mais c’est aussi souvent ici que beaucoup de problèmes surviennent. L’assemblage entre chaque pièce nécessite certaines contraintes qui parfois bloquent entre elles. Cela provoque donc des “bugs” dans la simulation. Pour notre part, il nous est arrivé d’avoir certaines planches qui ne coïncidaient pas en raison de mauvaises dimensions choisies. Nous avons donc pu remarquer nos erreurs pour ensuite les corriger.

Remarque : Lors de l’assemblage des pièces, il faut aussi réfléchir à la future construction. Il faut se demander si l’assemblage entre chaque pièce sera bien réalisable dans la vraie vie.

Face avant du four ouvert

Face avant du four fermé

Face arrière du four

Cette conception via SolidWorks nous a été très utile pour pouvoir chiffrer la surface nécessaire des planches et ensuite commander le matériel.

Montage du four :

Le montage est la partie la plus agréable du projet car il suffit de suivre les plans de la conception. C’est aussi la seule partie manuelle de notre projet, cela change énormément des écrans et des feuilles. Nous avons rencontré quelques problèmes suite à de mauvaises découpes de planches que nous avons réussi à rectifier. Le montage nous a pris environ 30h.

Face avant du four

Face arrière du four

vidéo du montage final :

Test et conclusion

Test :

Pour déterminer l’efficacité de notre four, nous avons effectué un test grandeur nature. Nous avons placé une casserole contenant 1 litre d’eau à l’intérieur de notre four et nous avons lancé un chronomètre. Après 1 heure d’utilisation, nous avons relevé une température de 80°C. Nous pensons cependant que nous aurions pu atteindre les 100°C avec plus de temps.

vidéo du test :

Conclusion :

De notre côté, nous pensons avoir réalisé le projet correctement en répondant aux cahiers des cahiers des charges. Notre four permet bien de faire chauffer des aliments ou du liquide à une température assez élevée même si cette température n’atteint pas celle d’un four électrique. Nous pensons en revanche que l’utilisation la plus pratique pour ce four est le réchauffage de plats préalablement cuits dans un four conventionnel. Pour conclure, tout est fonctionnel mais quelques améliorations auraient pu être trouvées en utilisant par exemple un double vitrage ou bien en augmentant l’épaisseur des planches utilisées.

Ce projet nous a aussi permis de travailler en équipe et de faire un projet concret du début à la fin. Cela a été très enrichissant !

Merci pour votre lecture !

Annexes

Compte-rendu détaillé :

OpenBCI

Publié le 17 mai 2021 par BIARD Valentin

Présentation du groupe

Nous sommes 3 étudiants de Polytech Angers en Peip2A, nous nous prénommons BIARD Valentin / DUGUÉ Tom / JOSPIN Kilian.

Description du projet

Le projet OpenBCI est un projet visant a créer une interface Homme-Machine par le biais d’un casque muni d’électrodes, afin de récupérer les signaux électriques émis par le cerveau et de pouvoir les interpréter par la suite.

Accessible à tous, le projet OpenBCI est Open Source. Mais ce n’est pas tout, il est également accessible par les amateurs. En effet, le casque n’est pas constitué de matériaux chers et compliqués à créer. De plus, une simple carte Arduino peut suffire pour l’utiliser. Un des objectifs de ce projet est que chaque personne, sans forcément de moyen, ni de connaissance puisse s’en servir. Ainsi, il existe toute une documentation permettant de créer son casque simplement par soi-même. De même que pour les personnes qui ne voudraient pas ou ne se sentiraient pas de se lancer dans la construction d’un casque de ce type, OpenBCI propose également des kits prêts à l’emploi (allant du casque en pièces détachées, jusqu’au casque préconstruit), c’est avec l’un d’entre eux que nous allons travailler, à part pour l’armature du casque qui a été imprimé en 3D. Le modèle 3D de l’armature du casque est un fichier Open Source, n’importe qui peut donc le récupérer et l’imprimer par ses propres moyens.

Origine du choix de notre projet

Nous sommes tous les trois intéressés par l’informatique et particulièrement par l’intelligence artificielle, c’est une des raisons pour lesquelles le projet OpenBCI nous semblait intéressant. De plus, ce projet nous semblait être l’occasion pour nous de découvrir des nouvelles technologies liées à nos projets d’études.

La proposition du projet OpenBCI a vu le jour à la suite de l’AVC de Mme Richard. Le but est alors de pouvoir exploiter la lecture du cortex cérébrale afin de pouvoir développer dans le futur des outils utilisables par la pensée.

Premières recherches sur le projet OpenBCI

Nous nous sommes rapidement rendu compte qu’il y avait beaucoup de notions que nous ne pouvions pas réellement comprendre à cause de notre manque de connaissances sur le corps humain.
Cependant, nous avons continués nos recherches et nous avons fini par trouver une vidéo présentant la construction du casque, ainsi que de la documentation expliquant comment faire fonctionner le casque avec le logiciel fourni.

Construction du casque

La première étape fut d’assembler l’armature imprimée en 3D, le modèle 3D étant fourni gratuitement par le projet OpenBCI. Cette étape ne fut pas sans difficultés, mais après plusieurs tentatives nous finit par y arriver.

Ensuite, nous avons ajouté les différentes électrodes sur l’armature

Nous avons dû nous adapter à une nouvelle manière de « cartographier » les zones du cerveau (vue du dessus), selon le schéma suivant :

Ce schéma représente l’emplacement des électrodes selon le système 10/20 chaque lettre représente une zone de la tête.
Fp : Fronto-polair, F : Frontale, T : Temporale, A : Auriculaire, C : Centrale, P : Pariétale, O : Occipitale. Les lettres ne correspondent pas toujours à des lobes du cerveau, notamment pour C, qui correspond plus à une zone. Les nombres pairs sont pour la partie droite du cerveau, et les nombres impairs pour la partie gauche, z pour la ligne médiane.

Par la suite, nous avons ajouté la carte électronique à l’arrière du casque, ainsi que fait les branchements des différentes électrodes sur la carte électronique.

Prise en main du logiciel OpenBCI

La découverte du logiciel OpenBCI nous a permis de tester notre matériel et de vérifier que chaque électrode fonctionnait bien.
Nous avons découvert plusieurs erreurs qui peuvent arriver lors de l’enregistrement des données. Nous avons donc fait plusieurs tests afin de résoudre ces différents problèmes et savoir comment empêcher qu’ils arrivent.

Nous avons également pu essayer deux méthodes différentes de branchements des électrodes sur la carte électronique. En effet, nous pouvons faire un branchement « classique » ou « différentiel ». Dans les deux cas, nous avons réussis à obtenir des résultats concluants.

Branchement classique :

Chaque électrode est branchée sur son pin associé par le logiciel en positif, et une oreille servant de référence est branché sur Bias+. Ainsi, on mesure la différence entre la référence et l’électrode pour chaque canal.

Branchement en différentiel :

Pour chaque canal pair, on mesure la différence entre chaque paire d’électrodes. L’une est branchée sur le pin positif et l’autre sur le pin négatif. Cela permet d’avoir des courbes plus propres et qui caractérise mieux l’activité locale.

Finalement, le logiciel est assez intuitif et bien fait. Il permet l’exportation de résultats en temps réel vers d’autres logiciels ou l’ajout de plugins permettant d’ajouter des fonctionnalités. Plusieurs plugins Open Source sont disponibles sur Internet, programmés en majorité en Python. Ils permettent une analyse plus spécifique des données ou alors transformer ces dernières en valeurs plus exploitables.

Test du casque

Lors de notre premier test du casque, il nous est tout de suite apparu un problème d’ergonomie. En effet, il fallait dévisser les électrodes afin de pouvoir passer notre tête, puis les revisser afin de pouvoir capter le signal.

Exemple des électrodes :

Électrodes avec piques

Le casque n’étant pas collé à la tête fait qu’à chaque mouvement, il y a des perturbations du signal. Et par le poids des piles à l’arrière, le casque à une certaine tendance à reculer vers l’arrière.

Nous avons réussi à observer des résultats « satisfaisant » pour les mouvements suivants :
• Clignement des yeux/d’un œil
• Serrer les dents
• Hocher la tête (oui/non)
• Sourire
• Bailler
• Hausser les sourcils
• Lever un ou deux bras

Exemple des résultats observés pour un certain mouvement :

Pour conclure, lors de ce projet, nous avons pu découvrir l’outil d’OpenBCI qui est très intéressant avec des points forts. Le potentiel du casque et du logiciel est énorme, et pourrait permettre de nombreuses utilisations différentes.
Néanmoins, il possède pour le moment plusieurs points négatifs. Le rapport entre l’intensité du bruit et l’intensité du signal est très mauvais. Pour conclure, ce fut un projet très intéressant qui a permis de découvrir d’autres spécificités que celles rencontrées dans la formation. Ce qui nous a permis d’enrichir notre culture scientifique dans d’autres domaines.

Nous remercions ainsi notre encadrant Hassan Bouljroufi de nous avoir permis de réaliser ce projet.

Annexe

Vidéo montrant l’acquisition des données :

Rapport détaillé du projet OpenBCI :

Polytech Angers – Projets PEIP2

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

Archives de catégorie : 2020-2021