{"id":1478,"date":"2021-06-04T14:15:55","date_gmt":"2021-06-04T13:15:55","guid":{"rendered":"https:\/\/blog.univ-angers.fr\/istiaprojetsei2\/?p=1478"},"modified":"2021-06-16T15:50:03","modified_gmt":"2021-06-16T14:50:03","slug":"display-box","status":"publish","type":"post","link":"https:\/\/blog.univ-angers.fr\/polytech_2A\/2021\/06\/04\/display-box\/","title":{"rendered":"Display box"},"content":{"rendered":"

Bonjour \u00e0 tous,<\/strong><\/p>\n

Nous sommes 4 \u00e9tudiants de PeiP 2, Th\u00e9o ROY, Zacharie FOURRIER, Alexandre PRAT et Eli DESTOMBES.
\nDans le cadre de notre projet de conception nous avons travaill\u00e9 sur une display-box.
\nL’objectif de notre projet est de r\u00e9aliser diff\u00e9rents programmes qui g\u00e8rent des \u00e9crans dans le but de les int\u00e9grer \u00e0 un projet d’escape Game.
\nNous avons tous travaill\u00e9 sur Arduino mais aussi sur AppInventor ou python pour certains.
\nNous avons donc r\u00e9alis\u00e9 5 mini-projets et nous allons vous montrer comment les utiliser !<\/p>\n

Projet n\u00b01 : Clavier tactile et code secret – R\u00e9alis\u00e9 par Eli DESTOMBES<\/font><\/strong>
\nLe but de mon projet est de r\u00e9aliser un clavier tactile \u00e0 code secret qui avec le bon code va changer de fen\u00eatre pour afficher une nouvelle fen\u00eatre.
\nJe vais donc vous montrer comment le coder.<\/p>\n

Mot cl\u00e9 : 2.4 \u2018\u2019 TFT LCD SHIELD, Arduino, clavier tactile , clavier azerty <\/p>\n

1\u00e8re \u00c9tape : Pr\u00e9paration<\/strong>
\n1.1 Les librairies <\/em><\/p>\n

Pour ce qui est du mat\u00e9riel j\u2019ai utilis\u00e9 un \u00e9cran 2.4 \u2018\u2019 TFT LCD SHIELD et une carte Arduino UNO
\nMaintenant voici les librairies Arduino que nous allons utiliser : <\/p>\n

– Adafruit GFX

\"Vous<\/a>

Vous pouvez l\u2019installer depuis Arduino, pour cela faite \u00ab Ctrl+Maj+I \u00bb pour ouvrir le gestionnaire de biblioth\u00e8que puis chercher Adafruit GFX.
Elle fournit une syntaxe et un ensemble de fonction graphique pour les \u00e9crans LCD et OLED<\/p><\/div>
\n– Adafruit TFTLCD

\"De<\/a>

De la m\u00eame fa\u00e7on, vous la trouverez dans le gestionnaire de biblioth\u00e8que en cherchant Adafruit TFTLCD. Pour v\u00e9rifier que la biblioth\u00e8que est bien install\u00e9e et que votre \u00e9cran fonctionne, allez dans Fichier -> Example -> Adafruit TFTLCD Library -> graphictest puis ex\u00e9cutez le programme<\/p><\/div>
\n– Adafruit TouchScreen

\"De<\/a>

De la m\u00eame fa\u00e7on vous la trouverez dans le gestionnaire de biblioth\u00e8que en cherchant TouchScreen. Pour v\u00e9rifier que le tactile fonctionne, allez dans Fichier -> Example -> Adafruit TouchScreen -> touchscreendemo puis ouvrir le moniteur s\u00e9rie et ex\u00e9cutez le programme. Appuyez sur l\u2019\u00e9cran et regardez le moniteur pour voir si des coordonn\u00e9es apparaissent.<\/p><\/div>
\n– String
\nLa librairie String.h<\/strong> est install\u00e9e de base sur Arduino<\/p>\n

1.2 D\u00e9finitions des PINs <\/em>
\nPIN pour l\u2019\u00e9cran
\n
\n#define LCD_CS A3 \/\/ Chip Select va vers Analog 3
\n#define LCD_CD A2 \/\/ Command\/Data va vers Analog 2
\n#define LCD_WR A1 \/\/ LCD Write va vers Analog 1
\n#define LCD_RD A0 \/\/ LCD Read va vers Analog 0
\n#define LCD_RESET A4
\n<\/code>
\nPIN pour la position du tactile<\/p>\n

#define YP A2
\n#define XM A3
\n#define YM 8
\n#define XP 9<\/code><\/p>\n

1.3 D\u00e9finition des coordonn\u00e9es max et min pour un \u00e9cran 2.4 \u2018\u2019 TFT <\/em><\/p>\n

#define TS_MINX 204
\n#define TS_MINY 195
\n#define TS_MAXX 948
\n#define TS_MAXY 910<\/code><\/p>\n

Nous allons aussi utiliser diff\u00e9rentes couleurs, il est donc utile de d\u00e9finir les couleurs que vous allez utiliser avec :
\n#define nom_de_la_couleur code_hexa_de_la_couleur <\/code><\/p>\n

2\u00e8me \u00c9tape : Trouver le driver LCD <\/strong><\/p>\n

C\u2019est une \u00e9tape importante car sans le bon driver l\u2019\u00e9cran ne peut pas marcher, pour trouver le bon driver il faut ouvrir le programme d\u2019exemple tftbpm qui est dans Adafruit TFTLCD Library.
\nIl faut ouvrir le moniteur s\u00e9rie et lancer le programme (avec votre \u00e9cran connect\u00e9 \u00e0 l\u2019Arduino).
\nDans 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\u00e9cimal du driver
\n\"\"<\/a>
\nUne fois le driver trouv\u00e9 il faut \u00e9crire dans le void setup() :
\n tft.begin(0x9341);<\/code>
\nIl faudra aussi \u00e9crire cette ligne avant le void setup() pour que l\u2019\u00e9cran fonctionne :
\nAdafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);<\/code>
\nIl est possible que le programme ne fonctionne pas correctement et que le moniteur ne trouve pas le driver. C\u2019est un probl\u00e8me que j\u2019ai eu et pour le r\u00e9soudre j\u2019ai suivi cette vid\u00e9o :
\nhttps:\/\/www.youtube.com\/watch?v=Tj-DjKAp770<\/a><\/p>\n

3\u00e8me \u00c9tape : affichage du clavier <\/strong><\/p>\n

\"\"<\/a>
\nPour l\u2019affichage du clavier j\u2019ai cr\u00e9\u00e9 une fonction clavier() que j\u2019utilise dans le void setup(), comme cela elle va apparaitre au d\u00e9marrage du programme.<\/p>\n

3.1 Affichage des rectangles <\/em><\/p>\n

Pour dessiner les cases autours des lettres j\u2019ai utilis\u00e9 la fonction tft.drawRect qui se construit de la fa\u00e7ons suivante :
\ntft.drawRect( x, y, l, h, COLOR) ;<\/code>
\nAvec :
\n\u2022 x : coordonn\u00e9e en x du point de d\u00e9part du rectangle
\n\u2022\ty : coordonn\u00e9e en y du point de d\u00e9part du rectangle
\n\u2022\tl : la largeur du rectangle
\n\u2022\th : la hauteur du rectangle
\n\u2022\tCOLOR : la couleur du rectangle
\nCela va cr\u00e9er un rectangle vide avec un contour de la couleur choisie. <\/p>\n

Si vous voulez un rectangle rempli il faut utiliser la fonction tft.fillRect qui se construit de la m\u00eame fa\u00e7on que tft.drawRect :
\ntft.fillRect( x, y, l, h, COLOR) ; <\/code>
\nAvec :
\n\u2022\tx : coordonn\u00e9e en x du point de d\u00e9part du rectangle
\n\u2022\ty : coordonn\u00e9e en y du point de d\u00e9part du rectangle
\n\u2022\tl : la largeur du rectangle
\n\u2022\th : la hauteur du rectangle
\n\u2022\tCOLOR : la couleur du rectangle <\/p>\n

3.2 Affichage du texte <\/em><\/p>\n

Pour \u00e9crire du texte nous allons avoir besoin de 5 fonctions.
\nLa premi\u00e8re est tft.setCursor qui sert \u00e0 placer le point de d\u00e9part du texte :
\ntft.setCursor( x, y) ;<\/code>
\nAvec :
\n\u2022\tx : coordonn\u00e9e x du point de d\u00e9part
\n\u2022\ty : coordonn\u00e9e y du point de d\u00e9part <\/p>\n

Ensuite il y a tft.TextColor qui va changer la couleur du texte :
\ntft.setTextColor(COLOR) ;<\/code>
\nAvec :
\n\u2022\tCOLOR : couleur du texte<\/p>\n

Puis, pour g\u00e9rer la taille du texte il y a la fonction tft.setTextSize :
\n\ttft.setTextSize(n) ;<\/code>
\nAvec :
\n\u2022\tn : 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. <\/p>\n

Enfin pour \u00e9crire du texte, il existe deux fonctions.
\n\tLa premi\u00e8re, tft.print ou tft.println , qui \u00e9crit tous les caract\u00e8res non sp\u00e9ciaux
\n\t\ttft.println(\u201c \u201d) ;<\/code>
\n\tLa deuxi\u00e8me, tft.write , qui permet d\u2019\u00e9crire des caract\u00e8res sp\u00e9ciaux avec leur code hexad\u00e9cimal
\n\t\ttft.write(0xXX) ;<\/code><\/p>\n

Exemple de cr\u00e9ation d\u2019une touche du clavier :
\n tft.drawRect(6, 120, 28, 36, RED); \/\/ on utilise 2 fois la fonction drawRect
\n tft.drawRect(7, 121, 26, 34, RED); \/\/ pour faire une plus grosse \u00e9paisseur
\n tft.setCursor(10, 125); \/\/ on place le curseur a la postition 10 x , 125 y
\n tft.setTextColor(WHITE); \/\/ on met le texte en blanc
\n tft.setTextSize(4); \/\/ on met le texte de taille 4
\n tft.print(\"A\"); \/\/ on \u00e9crit le caract\u00e8re A<\/code><\/p>\n

4\u00e8me \u00c9tape : Position sur l\u2019\u00e9cran et chaine de caract\u00e8res <\/strong><\/p>\n

Pour commencer, il faut d\u00e9clarer ces lignes avant le void setup() pour que les fonctions de position marchent :
\nTouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
\nboolean buttonEnabled = true;<\/code><\/p>\n

On d\u00e9clare une variable buttonEnabled qui va nous servir plus tard pour nos touches.
\net pour que notre chaine de caract\u00e8res fonctionne :
\nString chaineCara;<\/code> <\/p>\n

4.1 Affichage d\u2019un caract\u00e8re <\/em><\/p>\n

Pour cette partie on va cr\u00e9er une nouvelle fonction menu()
\nOn commence par \u00e9crire TSPoint p = ts.getPoint();<\/code> qui nous permet de r\u00e9cup\u00e9rer la position de l\u2019appui sur l\u2019\u00e9cran.
\nLa librairie TouchScreen fonctionne avec 3 coordonn\u00e9es, x ,y et z. Pour d\u00e9tecter un appui on se sert de la position Z comme cela : <\/p>\n

if (p.z > ts.pressureThreshhold) {<\/p>\n

p.x = map(p.x, TS_MAXX, TS_MINX, 0, 320);
\n p.y = map(p.y, TS_MAXY, TS_MINY, 0, 240);<\/p>\n

Serial.print(\"X = \"); Serial.print(p.x);
\n Serial.print(\"\\tY = \"); Serial.print(p.y);
\n Serial.print(\"\\n\");
\n\u2026<\/code><\/p>\n

La fonction map permet de bouger un intervalle de valeurs vers un autre,
\nmap(value, fromLow, fromHigh, toLow, toHigh)<\/code>
\nAvec :
\n\u2022value: le nombre \u00e0 \u201cmapper\u201d
\n\u2022fromLow: La borne inf\u00e9rieure de la valeur actuelle
\n\u2022fromHigh: La borne sup\u00e9rieure de la valeur actuelle
\n\u2022toLow: La borne inf\u00e9rieure de la valeur vis\u00e9e
\n\u2022toHigh: La borne sup\u00e9rieure de la valeur vis\u00e9e<\/p>\n

On l\u2019utilise ici pour replacer entre 0 et 320 pour x et entre 0 et 240 pour y car
\nIci quand on va appuyer sur l\u2019\u00e9cran on va avoir la position x et y,
\nPour d\u00e9finir la zone d\u2019appui d\u2019une lettre j\u2019ai utilis\u00e9 ceci :
\nif (p.x > 6 && p.x 80 && p.y 37 && p.x 80 && p.y < 120 && buttonEnabled) {<\/p>\n

pinMode(XM, OUTPUT);
\n pinMode(YP, OUTPUT);<\/p>\n

chaineCara = chaineCara + "Z";
\n longueur = chaineCara.length();<\/code>
\net on continue avec des else if pour chaque touche que l\u2019on a cr\u00e9\u00e9e.
\n
\n4.2 Suppression d\u2019un caract\u00e8re <\/em><\/p>\n

Pour supprimer un caract\u00e8re j\u2019utilise ceci :
\nchaineCara = chaineCara.substring(0, longueur - 1);<\/code>
\ncette ligne permet de retirer un caract\u00e8re dans la chaine mais pas sur l\u2019\u00e9cran, il faut donc aussi le supprimer \u00e0 l\u2019\u00e9cran.
\nPour cela je cr\u00e9e des rectangles de la couleur du fond que je superpose avec les lettres pour les effacer.
\nif (longueur == 8 ) {
\n tft.fillRect(213, 30, 24, 30, BLACK);
\n } else if (longueur == 7 ) {
\n tft.fillRect(189, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 6) {
\n tft.fillRect(165, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 5 ) {
\n tft.fillRect(141, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 4 ) {
\n tft.fillRect(117, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 3 ) {
\n tft.fillRect(93, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 2 ) {
\n tft.fillRect(69, 30, 24, 30, BLACK);
\n }
\n else if (longueur == 1 ) {
\n tft.fillRect(45, 30, 24, 30, BLACK);
\n }
\n }<\/code><\/p>\n

4.3 Limiter la taille de la chaine de caract\u00e8res <\/em><\/p>\n

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

if (longueur == 9 ) {
\n tft.fillRect(237, 30, 24, 30, BLACK);
\n }}}}}
\n<\/code>
\n5\u00e8me \u00c9tape : void setup et void loop <\/strong>
\n
\n5.1 construction du void setup()<\/em>
\n
\nvoid setup() {
\n tft.reset(); \/\/reset l\u2019\u00e9cran
\n tft.begin(0x9341); \/\/ voir \u00e9tapes 2
\n Serial.begin(9600); la valeur doit \u00eatre la m\u00eame que celle du moniteur
\n tft.setRotation(3); \/\/ rotation de 0,90,180,270\u00b0 respectivement 0,1,2,3
\n tft.fillScreen(BLACK); \/\/ remplis d\u2019\u00e9cran de noir
\n rectangle();\/\/fonction qui cr\u00e9e le grand rectangle du milieu
\n clavier(); \/\/ fonction de l\u2019\u00e9tape 4
\n}<\/code><\/p>\n

5.2 construction du void loop(void)<\/em><\/p>\n

void loop(void) {
\n menu() ;
\n if (chaineCara == \"CODEBON\") { \/\/on v\u00e9rifie que la chaine correspond au
\n \/\/code
\n buttonEnabled = false; \/\/on d\u00e9sactive la variable buttonEnabled pour ne plus pouvoir appuyer sur les boutons une fois le code trouver
\n...
\n }
\n delay(100) ; \/\/ on met un petit d\u00e9lais pour ne pas doubler les lettres quand on appuie sur les boutons
\n}
\n<\/code>
\nNous voil\u00e0 donc \u00e0 la fin de ce projet, voici une petite vid\u00e9o qui montre comment fonctionne le programme :
\nhttps:\/\/www.youtube.com\/embed\/8LQWGmZC6mI?feature=oembed<\/a><\/p>\n

Projet n\u00b02: Affichage LCD via Application Bluetooth – R\u00e9alis\u00e9 par Alexandre PRAT<\/strong><\/font><\/p>\n

Mot cl\u00e9 : ESP32, LCD I2C 16×2, Arduino, AppInventor <\/p>\n

1\u00e8re \u00c9tape : Pr\u00e9paration <\/strong>
\n1.1 Les librairies <\/em><\/p>\n

Voici les librairies que j\u2019ai d\u00fb utiliser :
\n– LiquidCrystal_I2C
\n

\"Vous<\/a>

Vous pouvez l\u2019installer depuis Arduino, pour cela faites \u00ab Ctrl+Maj+I \u00bb pour ouvrir le gestionnaire de biblioth\u00e8ques puis cherchez LiquidCrystal_I2C.
Elle fournit diff\u00e9rentes fonctions permettant d\u2019utiliser l\u2019\u00e9cran LCD 16×2.<\/p><\/div>
\nJ\u2019utilise \u00e9galement les librairies wire.h<\/strong> et bluetoothserial.h<\/strong> qui sont d\u00e9j\u00e0 install\u00e9es d\u2019origine !<\/p>\n

1.2 Les branchements <\/em><\/p>\n

Pour commencer, branchez votre \u00e9cran LCD \u00e0 l\u2019esp32 via le module I2C comme pr\u00e9sent\u00e9 sur le sch\u00e9ma ci-dessous :
\n\"\"<\/a><\/p>\n

1.3 Premiers essais <\/em>
\nPour tester les branchements et le fonctionnement de l\u2019\u00e9cran LCD, voici un premier programme de test permettant d\u2019afficher \u00ab Hello, world ! \u00bb sur l\u2019\u00e9cran LCD :
\n
\n#include <Wire.h>
\n#include <LiquidCrystal_I2C.h><\/p>\n

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
\n\/\/LiquidCrystal_I2C lcd(0x3F,16,2);<\/p>\n

void setup()
\n{
\n lcd.init(); \/\/ initialize the lcd <\/p>\n

\/\/ Print a message to the LCD.
\n lcd.backlight();
\n lcd.print(\"Hello, world!\");
\n}
\nvoid loop()
\n{
\n}
\n<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/ETuXsmyVzaNLhhckV4ArAuABKRGD0vT94XGYc4X-SkFDtg?e=zFpGZ9<\/a><\/p>\n

Si cela ne fonctionne pas, vous pouvez commenter le ligne \u00ab LiquidCrystal_I2C lcd(0x27,16,2); \u00bb et d\u00e9commenter la ligne \u00ab \/\/LiquidCrystal_I2C lcd(0x3F,16,2); \u00bb .<\/p>\n

Si cela ne r\u00e8gle pas votre probl\u00e8me, vous pourrez ex\u00e9cuter le programme ci-dessous, en rempla\u00e7ant 0x27 ou 0x3F par le code hexad\u00e9cimal affich\u00e9 dans le moniteur s\u00e9rie :
\n
\n#include <Wire.h><\/p>\n

void setup() {
\n Wire.begin();
\n Serial.begin(115200);
\n Serial.println(\"\\nI2C Scanner\");
\n}
\nvoid loop() {
\n byte error, address;
\n int nDevices;
\n Serial.println(\"Scanning...\");
\n nDevices = 0;
\n for(address = 1; address < 127; address++ ) {
\n Wire.beginTransmission(address);
\n error = Wire.endTransmission();
\n if (error == 0) {
\n Serial.print("I2C device found at address 0x");
\n if (address<16) {
\n Serial.print("0");
\n }
\n Serial.println(address,HEX);
\n nDevices++;
\n }
\n else if (error==4) {
\n Serial.print("Unknow error at address 0x");
\n if (address<16) {
\n Serial.print("0");
\n }
\n Serial.println(address,HEX);
\n }
\n }
\n if (nDevices == 0) {
\n Serial.println("No I2C devices found\\n");
\n }
\n else {
\n Serial.println("done\\n");
\n }
\n delay(5000);
\n}
\n<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EVvGIcGU3LFHtAuZYZxs28ABRLtZ7SlWSmjyNEjG5CjP8w?e=hcpthX<\/a><\/p>\n

Nous allons ensuite tester le fonctionnement du Bluetooth.
\nPour cela, vous pourrez utiliser cette application sur Android ainsi que le programme Arduino ci-dessous :
\n\"\"<\/a>
\n#include \"BluetoothSerial.h\"<\/p>\n

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

BluetoothSerial SerialBT;<\/p>\n

void setup() {
\n Serial.begin(115200);
\n SerialBT.begin(\"ESP32test\"); \/\/Bluetooth device name
\n Serial.println(\"The device started, now you can pair it with bluetooth!\");
\n}
\nvoid loop() {
\n if (Serial.available()) {
\n SerialBT.write(Serial.read());
\n }
\n if (SerialBT.available()) {
\n Serial.write(SerialBT.read());
\n }
\n delay(20);
\n}<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EVSxL8CWqXlHiVZMeacIWRABi6HBYXDStQy9AIILgsVhng?e=KFib9E<\/a><\/p>\n

Pour tester le fonctionnement du Bluetooth, il vous suffit d\u2019ex\u00e9cuter ce programme sur votre ESP32, d\u2019ouvrir le moniteur s\u00e9rie Arduino,
\n\"\"<\/a>
\npuis de connecter votre t\u00e9l\u00e9phone \u00e0 l\u2019esp32 en Bluetooth depuis le t\u00e9l\u00e9phone et ensuite depuis l\u2019application Serial Bluetooth Terminal.
\nUne fois correctement connect\u00e9, vour pourrez \u00e9crire sur le terminal de votre t\u00e9l\u00e9phone pour l\u2019afficher sur le moniteur s\u00e9rie Arduino et inversement !<\/p>\n

1.4 Installer l\u2019application :<\/em><\/p>\n

Pour transmettre du texte \u00e0 l\u2019\u00e9cran LCD en Bluetooth, j\u2019utilise une application Android que j\u2019ai r\u00e9alis\u00e9 sur AppInventor.
\nVoici le lien de l\u2019installateur de l\u2019application (.apk) :
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EWnFDQ8-9ulKq7KXiemOuLEBS2T5Pe0Ow2qJs4uENpjz-w?e=ztpkF3<\/a><\/p>\n

2\u00e8me \u00c9tape : Tester l\u2019application finale !<\/strong><\/p>\n

Maintenant la pr\u00e9paration termin\u00e9e, nous allons pouvoir utiliser tout ce potentiel dans la r\u00e9alisation de mon applicatif final !
\nIl s\u2019agit en effet d\u2019afficher du texte sur l\u2019\u00e9cran LCD 16×2, et ce en l\u2019envoyant en Bluetooth via l\u2019application que j\u2019ai r\u00e9alis\u00e9.
\nVoici le programme Arduino \u00e0 t\u00e9l\u00e9verser sur l\u2019ESP32 :
\n#include <Wire.h>
\n#include <LiquidCrystal_I2C.h>
\n#include <BluetoothSerial.h><\/p>\n

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

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

BluetoothSerial SerialBT;<\/p>\n

char message[64];
\nString chaine = \"\";
\nint len, i;<\/p>\n

void my_fflush();<\/p>\n

void setup(){
\n \/\/Initialisation du moniteur s\u00e9rie, bluetooth et de l'\u00e9cran LCD
\n Serial.begin(115200);
\n SerialBT.begin(\"LCD\");
\n Serial.println(\"The device started, now you can pair it with bluetooth!\");<\/p>\n

lcd.init();
\n lcd.backlight();
\n}
\nvoid loop() {
\n i = 1;
\n \/\/Si l'on re\u00e7oit du texte en Bluetooth, on enregistre un par un chaque caract\u00e8re dans la variable message
\n \/\/puis on incr\u00e9mente le string chaine de message
\n while(SerialBT.available()) {
\n if(i == 1) {
\n chaine = \"\";
\n lcd.clear();
\n i = 0;
\n }
\n char message = SerialBT.read();<\/p>\n

chaine += message;<\/p>\n

Serial.println(chaine);<\/p>\n

delay(20);
\n } <\/p>\n

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

\/\/on r\u00e9cup\u00e8re la taille de notre message
\n len = strlen(message);<\/p>\n

\/\/Si la taille d\u00e9passe 32 caract\u00e8res, on affiche \u00e0 l'\u00e9cran que le message est trop long
\n if(len > 32) {
\n chaine = \"Votre message est trop long !\";
\n } else {
\n \/\/Sinon, on affache chaque caract\u00e8res \u00e0 l'\u00e9cran dans l'ordre en changeant les coordonn\u00e9es du curseur
\n for (i = 0; i < len; i++) {
\n if(i 15) lcd.setCursor(i - 16, 1);
\n lcd.print(message[i]);
\n }}}
\n<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EfNvR5hHh45GnOPvx0GrycsBfZ_O01t7o7nZTzXV-uiJWw?e=oW9IoI<\/a><\/p>\n

Pour utiliser mon application, il vous suffit de lancer l\u2019application en ayant au pr\u00e9alable activ\u00e9 le Bluetooth, de cliquer sur Connexion, de vous connecter \u00e0 l\u2019ESP32 d\u00e9sign\u00e9 par LCD dans la liste des appareils Bluetooth d\u00e9tectables.
\n\"\"<\/a>
\nUne fois connect\u00e9, un message, une zone de texte et un bouton apparaitra sur l\u2019\u00e9cran de l\u2019application, il vous suffira donc maintenant d\u2019\u00e9crire du texte dans la zone de texte et d\u2019appuyer sur le bouton ci-apr\u00e8s.
\n\"\"<\/a>
\nVous verrez ainsi appara\u00eetre votre message sur votre \u00e9cran LCD 16×2.
\nAttention ! Veillez \u00e0 ce que votre message ne d\u00e9passe pas les 32 caract\u00e8res, sinon un message d\u2019erreur apparaitra sur votre \u00e9cran !
\n\"\"<\/a><\/p>\n

Projet n\u00b03: Affichage Image et Vid\u00e9o \u00e9cran OLED 0.96\u2019\u2019- R\u00e9alis\u00e9 par Alexandre PRAT<\/strong><\/font><\/p>\n

Mot cl\u00e9 : ESP32 ,carte SD ,Python, GIF, Arduino, OLED SSD1315 0.96”, Frame <\/p>\n

3.1 Image avec ESP32 et Carte SD<\/strong>
\n1\u00e8re \u00c9tape : Pr\u00e9paration <\/strong>
\n1.1\tLes librairies<\/em> <\/p>\n

Voici les librairies que j\u2019ai d\u00fb utiliser :
\n– U8g2lib
\n

\"Vous<\/a>

Vous pouvez l\u2019installer depuis Arduino, pour cela, faites \u00ab Ctrl+Maj+I \u00bb pour ouvrir le gestionnaire de biblioth\u00e8que puis cherchez U8g2.
Elle fournit diff\u00e9rentes fonctions permettant d\u2019utiliser diff\u00e9rents types d\u2019\u00e9crans dont notre \u00e9cran OLED SSD1315 0.96\u2019\u2019<\/strong>
<\/p><\/div>
\nJ\u2019utilise \u00e9galement les librairies Arduino.h, SPI.h<\/strong> et Wire.h<\/strong> qui sont d\u00e9j\u00e0 install\u00e9es d\u2019origine !<\/p>\n

1.2 Les branchements <\/em><\/p>\n

Pour commencer, branchez votre \u00e9cran OLED \u00e0 l\u2019esp32 comme pr\u00e9sent\u00e9 sur le sch\u00e9ma ci-dessous :
\n(L\u2019\u00e9cran est pr\u00e9vu pour fonctionner avec un module GROVE, mais vous pouvez simplement brancher des fils classiques dans le branchement GROVE et le brancher comme ci-contre)
\n\"\"<\/a>
\nEnsuite, branchez votre module carte SD comme pr\u00e9sent\u00e9 sur le sch\u00e9ma ci-dessous :\"\"<\/a>
\n\"\"<\/a>\"\"<\/a>\"\"<\/a>
\n
\n1.3 Premiers essais <\/em><\/p>\n

Pour tester les branchements et le fonctionnement de l\u2019\u00e9cran OLED, voici un premier programme de test permettant d\u2019afficher \u00ab Hello, world ! \u00bb sur l\u2019\u00e9cran LCD :
\n
\n#include <Arduino.h>
\n#include <U8g2lib.h><\/p>\n

#ifdef U8X8_HAVE_HW_SPI
\n#include <SPI.h>
\n#endif
\n#ifdef U8X8_HAVE_HW_I2C
\n#include <Wire.h>
\n#endif<\/p>\n

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, \/* clock=*\/ SCL, \/* data=*\/ SDA, \/* reset=*\/ U8X8_PIN_NONE);<\/p>\n

void setup(void) {
\n u8g2.begin();
\n}
\nvoid loop(void) {
\n u8g2.clearBuffer();\t\t\t\t\t\/\/ clear the internal memory
\n u8g2.setFont(u8g2_font_ncenB08_tr);\t\/\/ choose a suitable font
\n u8g2.drawStr(0,10,\"Hello World!\");\t\/\/ write something to the internal memory
\n u8g2.sendBuffer();\t\t\t\t\t\/\/ transfer internal memory to the display
\n delay(1000);
\n}
\n<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/ERk6FkUU4odLtMzpF3jesDwBvSOu_Fs-sszVt4f8J3i6sg?e=kOtCXw<\/a><\/p>\n

Voici maintenant un programme permettant de tester la lecture et l\u2019\u00e9criture sur une carte SD via le module carte SD :
\n
\n#include <SPI.h>
\n#include <SD.h><\/p>\n

File myFile;<\/p>\n

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

Serial.print(\"Initializing SD card...\");<\/p>\n

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

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

\/\/ read from the file until there's nothing else in it:
\n while (myFile.available()) {
\n Serial.write(myFile.read());
\n }
\n \/\/ close the file:
\n myFile.close();
\n } else {
\n \/\/ if the file didn't open, print an error:
\n Serial.println(\"error opening test.txt\");
\n }
\n}
\nvoid loop() {
\n \/\/ nothing happens after setup
\n}<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/Ee6fWg755_1JvZVdp1jtcOoBkP_0hbTfrzpsgC0gugYstA?e=62gYhA<\/a><\/p>\n

Ce programme va ainsi initialiser le module carte SD, il va \u00e9crire dans un fichier \u00ab test.txt \u00bb et le fermer, puis le rouvrir et afficher son contenu dans le moniteur s\u00e9rie.
\nVous pourrez ensuite retrouver ce fichier dans la carte SD en l\u2019ins\u00e9rant par exemple dans un ordinateur.
\n
\n2\u00e8me \u00c9tape : Conversion des images !<\/strong><\/p>\n

Maintenant que nous avons install\u00e9 le mat\u00e9riel et test\u00e9 son bon fonctionnement, nous allons nous attaquer \u00e0 la deuxi\u00e8me dimension de ce projet : La conversion des images !<\/p>\n

2.1 Installation de Python et de la librairie Pil :<\/em>
\nPour utiliser Python il va falloir l\u2019installer sur votre ordinateur, pour ce faire suivez ce lien de t\u00e9l\u00e9chargement :
\nhttps:\/\/www.python.org\/downloads\/<\/a><\/p>\n

Une fois Python install\u00e9 sur votre ordinateur, vous aurez acc\u00e8s \u00e0 la console Python et vous pourrez \u00e9crire des programme Python \u00e0 l\u2019aide d\u2019un \u00e9diteur de texte pour l\u2019ex\u00e9cuter par la suite.
\nPour ma part, j\u2019ai utilis\u00e9 le logiciel Visual Studio Code pour programmer et ex\u00e9cuter mes programmes Pythons, je vais donc vous expliquer comment le param\u00e9trer.
\nPour commencer voici o\u00f9 le t\u00e9l\u00e9charger :
\nhttps:\/\/code.visualstudio.com\/Download<\/a>
\nUne fois install\u00e9, voici \u00e0 quoi ressemble VSCode :
\n\"\"<\/a>
\nVous pourrez ensuite cliquer sur l\u2019onglet extension et taper Python dans la barre de recherche :
\n\"\"<\/a>
\n\u00c0 la place de disable et uninstall vous pourrez cliquer sur install pour installer l\u2019extension.
\nVous pourrez taper Pylance dans la barre de recherche et l\u2019installer de la m\u00eame mani\u00e8re :
\n\"\"<\/a>
\nUne fois les deux extensions install\u00e9es, vous pourrez ouvrir le fichier de test \u00ab Hello world.py \u00bb ci-dessous :
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EVWGSzy1pilHsRCo0CzoPqcBlutOLND8Hc4icxtwV6BVIA?e=TTEPhC<\/a><\/p>\n

Une fois le fichier ouvert, vous pourrez cliquer en bas \u00e0 gauche et s\u00e9lectionner l\u2019interpr\u00e9teur python si cela n\u2019est pas d\u00e9j\u00e0 fait.
\n\"\"<\/a>
\nVous pourrez ensuite appuyer sur F5 et cliquer sur \u00ab Python File \u00bb pour ex\u00e9cuter le programme Python.
\n\"\"<\/a>
\nUne fois ex\u00e9cut\u00e9 celui-ci devrait afficher \u00ab Hello world \u00bb dans le terminal Python en bas de la page.
\nAttention ! Pensez \u00e0 bien v\u00e9rifier que le terminal s\u00e9lectionn\u00e9 est bien le terminal Python :
\n\"\"<\/a>
\nEnsuite une fois dans le terminal Python, vous pourrez taper \u00ab pip install Pillow \u00bb afin d\u2019installer la librairie PIL :
\n\"\"<\/a>
\nSi tout s\u2019est bien pass\u00e9, la librairie PIL est bien install\u00e9e et Python est pr\u00eat \u00e0 \u00eatre utilis\u00e9 !<\/p>\n

2.2 Programme Python<\/em><\/p>\n

Pour convertir des images classiques en images monochromes 128×64 puis en matrices binaires texte, nous utilisons un programme Python.
\nVoici le programme Python en question :
\n
\nfrom PIL import Image
\nimport os
\nfilename=input(\"Quelle image souhaites-tu convertir ? (nom.extension)\")
\nwith Image.open(filename) as image:
\n if image.width somme):
\n pixels_converted[x,y]=1
\n else:
\n pixels_converted[x,y]=0
\n for x in range(width):
\n if(pixels_converted[x,y]==1 or pixels_converted[x,y]==0):
\n i+=1 <\/p>\n

converted_image.show()
\nmatrice = converted_image.load()<\/p>\n

with open(\"code.txt\", \"w\") as file:<\/p>\n

for i in range(height):
\n for j in range(width):
\n if matrice[j, i] > 0:
\n file.write(\"1\")
\n else:
\n file.write(\"0\")<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EWBx62pzzhpMgB6UHysoCksBieBGAg5BUCkhj9wa-sThKQ?e=hwkbk8<\/a><\/p>\n

Il vous suffit ainsi de t\u00e9l\u00e9charger une image, de la d\u00e9poser dans le m\u00eame dossier que le programme Python, d\u2019ex\u00e9cuter le programme Python, d\u2019entrer le nom et l\u2019extension de l\u2019image quand le programme vous la demande (nom.extension), et le programme cr\u00e9era un fichier image.txt contenant une matrice de 0 et de 1 correspondant aux pixels de l\u2019image. Fichier texte qui pourra \u00eatre interpr\u00e9t\u00e9 par l\u2019ESP32 pour l\u2019affichage de l\u2019image sur l\u2019\u00e9cran OLED.\t<\/p>\n

Ainsi ce programme ouvre l\u2019image, v\u00e9rifie s\u2019il s\u2019agit d\u2019une 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 \u00e9cris chaque pixel dans une matrice binaire dans un fichier texte.
\n
\n3\u00e8me \u00c9tape : Tester l\u2019application finale !<\/strong><\/p>\n

Maintenant l\u2019installation faite, les composants fonctionnels et une image de converti, il nous reste plus qu\u2019\u00e0 tester notre application finale !
\nPour commencer vous allez pouvoir glisser le fichier image.txt fournis par le programme Python dans le r\u00e9pertoire principal d\u2019une carte SD, et ins\u00e9rer cette m\u00eame carte SD dans le module carte SD branch\u00e9 \u00e0 l\u2019ESP32.
\nVoici ensuite le programme permettant de lire, g\u00e9r\u00e9 et afficher l\u2019image sur l\u2019\u00e9cran OLED via l\u2019ESP32 :
\n#include <Arduino.h>
\n#include <U8g2lib.h>
\n#include <SPI.h>
\n#include <SD.h><\/p>\n

#ifdef U8X8_HAVE_HW_I2C
\n#include <Wire.h>
\n#endif<\/p>\n

\/\/On renseigne notre \u00e9cran pour la librairie U8g2
\nU8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, \/* clock=*\/ SCL, \/* data=*\/ SDA, \/* reset=*\/ U8X8_PIN_NONE);<\/p>\n

byte image[8192]; \/\/tableau stockant chaque bit correspondant \u00e0 chaque pixel (converti en byte)
\nchar tabCode[8192]; \/\/tableau stockant chaque bit correspondant \u00e0 chaque pixel (obtenu en char dans la carte SD)
\nint octet, len, i, j;<\/p>\n

void setup(void) {
\n pinMode(10, OUTPUT);
\n pinMode(9, OUTPUT);<\/p>\n

digitalWrite(10, 0);
\n digitalWrite(9, 0);\t\t<\/p>\n

\/\/Initialisation de l'\u00e9cran OLED
\n u8g2.begin();
\n u8g2.enableUTF8Print();
\n \/\/On s\u00e9lectionne une police
\n u8g2.setFont(u8g2_font_ncenB08_tr);<\/p>\n

\/\/initialisation du moniteur s\u00e9rie
\n Serial.begin(115200);<\/p>\n

\/\/On v\u00e9rifie si la carte SD est d\u00e9tect\u00e9e, si ce n'est pas le cas, on affiche un message d'erreur sur l'\u00e9cran OLED
\n if(!SD.begin()){
\n u8g2.drawStr(0,10,\"La carte ne fonctionne\");
\n u8g2.drawStr(0,30,\"pas !\");
\n u8g2.sendBuffer();
\n u8g2.clearBuffer();
\n delay(1000);
\n return;
\n }<\/p>\n

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

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

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

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

https:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/ERTFzhOP7HtPlpy8cJ-IyqoBxnxTRO1hpxFi83kHeW0Bkw?e=sdvdc5<\/a><\/p>\n

Vous pourrez ainsi compiler et t\u00e9l\u00e9verser ce programme sur l\u2019ESP32 afin de le faire fonctionner.
\nEn cas de non-d\u00e9tection ou d\u2019absence de carte SD, le programme affichera des messages d\u2019erreurs sur l\u2019\u00e9cran OLED.
\n\"\"<\/a><\/p>\n

Il est \u00e9galement bon \u00e0 savoir qu\u2019une simple carte Arduino aurait aussi pu \u00eatre utilis\u00e9e pour cette partie car sa m\u00e9moire est suffisante pour afficher une simple image.
\nDans ce cas le programme aurait \u00e9t\u00e9 le m\u00eame, la seule diff\u00e9rence aurait \u00e9t\u00e9 le branchement du module carte SD et de l\u2019\u00e9cran OLED.
\n

\"GND<\/a>

\u00c9cran OLED
GND -> GND
VCC -> +5V
<\/font>SDA -> A4
<\/font>SCL -> A5
<\/font><\/p><\/div><\/p>\n

3.2\u00b0 Gif avec ESP32 :<\/strong><\/p>\n

1\u00e8re \u00c9tape : Pr\u00e9paration <\/strong>
\nPour cette premi\u00e8re partie de pr\u00e9paration, je vous invite \u00e0 vous r\u00e9f\u00e9rer \u00e0 la partie Pr\u00e9paration du 3.1\u00b0 Image avec ESP32 et carte SD.
\n(Vous pourrez cependant omettre la partie sur le module carte SD car celui-ci ne sera pas utilis\u00e9 dans cette partie)<\/p>\n

2\u00e8me \u00c9tape : Conversion des GIF !<\/strong>
\nDans cette partie, nous allons \u00e0 nouveau utiliser un programme Python, je vous invite donc \u00e0 vous r\u00e9f\u00e9rer \u00e0 la partie Conversion des images du 3.1\u00b0 Image avec ESP32 et carte SD pour configurer votre environnement Python.
\nVoici ainsi le programme Python que nous allons utiliser :
\n
\nfrom PIL import Image
\nfilename=input(\"Quel est le nom de votre fichier ? \")
\ntaille=int(input(\"Combien d'images contient votre GIF ? \"))
\next=input(\"Quel est le format de vos images ? \")
\nwith open(\".\/\"+ filename + \"\/\" + filename + \".txt\", \"w\") as file:
\n file.write(\"const byte image[FRAME][8192] PROGMEM = {\")
\n for k in range(1,taille+1):
\n file.write(\"{\")
\n with Image.open(\".\/\"+ filename + \"\/\" + filename + \" (\" + str(k) + \").\" + ext) as image:
\n if image.width somme):
\n pixels_converted[x,y]=1
\n else:
\n pixels_converted[x,y]=0
\n for x in range(width):
\n if(pixels_converted[x,y]==1 or pixels_converted[x,y]==0):
\n i+=1 <\/p>\n

converted_image.show()
\n matrice = converted_image.load()<\/p>\n

for i in range(height):
\n for j in range(width):
\n if matrice[j, i] > 0:
\n file.write(\"1\")
\n if i != height-1 or j != width-1:
\n file.write(\", \")
\n else:
\n file.write(\"0\")
\n if i != height-1 or j != width-1:
\n file.write(\", \")
\n file.write(\"}\")
\n if k != taille:
\n file.write(\",\")
\n file.write(\"};\")<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EfVCE6Hw3ytBnuYc3vhnvFEBFCePw2eylysbpYSbD7Pokw?e=UzuEFV<\/a><\/p>\n

Pour fonctionner, notre programme Python a besoin d\u2019un dossier contenant chaque \u00ab frames \u00bb du GIF souhaitant \u00eatre affich\u00e9.
\nPour convertir notre GIF en archives ZIP contenant chaque \u00ab frames \u00bb de notre GIF, je vous propose l\u2019utilisation de ce site tiers : https:\/\/ezgif.com\/split<\/a>
\nDans notre exemple, nous utiliserons ce GIF :https:\/\/tenor.com\/view\/yay-yes-yeahhh-cute-girl-happy-dance-gif-14559695<\/a><\/p>\n

Il vous suffit ainsi d\u2019uploader votre GIF sur le site ou d\u2019y d\u00e9poser un lien, puis de cliquer sur Upload :
\n\"\"<\/a>
\nIl ne vous restera plus qu\u2019\u00e0 cliquer sur Split to frames et la magie op\u00e8rera.
\nVous n\u2019aurez plus qu\u2019\u00e0 cliquer sur Download frames as ZIP : \"\"<\/a><\/p>\n

Vous vous retrouverez ainsi avec une archive ZIP contenant toutes vos frames :
\n\"\"<\/a>
\nVous pourrez ensuite cr\u00e9er un dossier du nom de votre GIF (que vous pouvez choisir), dans notre cas nous l\u2019appellerons \u00ab girl \u00bb, et y glisser toutes les images.
\nUne fois les images dans le dossier, s\u00e9lectionner toutes les images, faites clique-droit sur la premi\u00e8re image (tout en gardant toutes les images s\u00e9lectionn\u00e9es), appuyez sur renommer et entrez le nom de votre GIF (Attention cela doit \u00eatre le m\u00eame nom que celui du dossier !)
\nAinsi, toutes les images vont \u00eatre renomm\u00e9es en \u00ab nom (x) \u00bb :
\n\"\"<\/a>
\nIl ne vous reste plus qu\u2019\u00e0 d\u00e9placer ce dossier dans le r\u00e9pertoire du programme Python !
\nIl ne vous reste plus qu\u2019\u00e0 ex\u00e9cuter le programme Python, d\u2019entrer le nom de votre GIF (nom du dossier), d\u2019entrer le nombre d\u2019images que contient le GIF (dans notre exemple 28) et pour finir d\u2019entrer le format de nos images (dans notre cas .gif).
\nUne fois le programme ex\u00e9cut\u00e9, vous trouverez un fichier texte portant le nom de votre GIF \u00e0 l\u2019int\u00e9rieur du dossier contenant les images du GIF.<\/p>\n

3\u00e8me \u00c9tape : Tester l\u2019application finale !<\/strong><\/p>\n

Maintenant l\u2019installation faite, les composants fonctionnels et un GIF de converti, il nous reste plus qu\u2019\u00e0 tester notre application finale !
\nPour commencer vous allez pouvoir ouvrir le fichier texte contenant le GIF, tout s\u00e9lectionner (CTRL+A) et tout copier (CTRL+C).
\nVoici ensuite le programme permettant de lire, g\u00e9r\u00e9 et afficher le GIF sur l\u2019\u00e9cran OLED via l\u2019ESP32 :
\n#include <Arduino.h>
\n#include <U8g2lib.h><\/p>\n

#ifdef U8X8_HAVE_HW_SPI
\n#include <SPI.h>
\n#endif
\n#ifdef U8X8_HAVE_HW_I2C
\n#include <Wire.h>
\n#endif<\/p>\n

#define FRAME 24 \/\/N'oubliez pas de renseigner le nombre d'images ICI<\/p>\n

\/\/On renseigne notre \u00e9cran pour la librairie U8g2
\nU8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, \/* clock=*\/ SCL, \/* data=*\/ SDA, \/* reset=*\/ U8X8_PIN_NONE);<\/p>\n

\/\/COLLEZ LE CONTENU DU FICHIER TEXTE ICI
\nint tmp, octet;<\/p>\n

void setup(void) {
\n pinMode(10, OUTPUT);
\n pinMode(9, OUTPUT);<\/p>\n

digitalWrite(10, 0);
\n digitalWrite(9, 0);<\/p>\n

\/\/Initialisation de l'\u00e9cran OLED
\n u8g2.begin();
\n u8g2.enableUTF8Print();<\/p>\n

\/\/Initialisation de l'\u00e9cran LCD
\n Serial.begin(115200);
\n}<\/p>\n

\/\/Important ! Nous utilisons un tableau \u00e0 deux dimension pour stocker chaque image du GIF, nous avons ainsi un tableau de dimension [nb images][r\u00e9solution image]
\nvoid loop(void) {
\n tmp = 0; \/\/Cette variable permet de savoir \u00e0 quelle image du GIF nous sommes rendu
\n for(int k=0; k<FRAME; k++){ \/\/boucle for permettant de parcours chaque image
\n for(int i=0; i>128; i++) { \/\/boucle for permettant de parcours l'axe i
\n for(int j=0; j>64; j++) { \/\/boucle for permettant de parcours l'axe j
\n \/\/octet stock la valeur 0 ou 1 de chaque pixel
\n \/\/pgm_read_byte_near lit dans la PROGMEM \u00e0 l'adresse
\n \/\/&image[tmp][0] (pixel initial de l'image) + j*128+i (auquel on ajoute les pixel d\u00e9j\u00e0 parcourus)
\n octet = pgm_read_byte_near(&image[tmp][0] + j*128+i);
\n if (octet <= 1) {
\n u8g2.drawPixel(i,j); \/\/Si octet = 1, nous dessinons un pixel aux coordonn\u00e9es (i,j)
\n }}}
\n tmp++; \/\/Une fois une image termin\u00e9e, nous incr\u00e9mentons tmp
\n u8g2.sendBuffer(); \/\/Nous envoyons le buffer pour afficher l'image
\n delay(20); \/\/Nous attendons afin de voir passer chaque image avec un taux de rafraichissement assez \u00e9lev\u00e9
\n u8g2.clearBuffer(); \/\/Nous vidons le buffer pour traiter la prochaine image
\n }}
\n<\/code>
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/Ec2G1Tw-84ZJjZ-lkY_vkNMBc1qo9AIru2uRP_ii-V2hNw?e=ny844n<\/a><\/p>\n

Pour faire fonctionner ce programme, il ne vous reste plus que 2 choses \u00e0 faire, tout d\u2019abord, renseignez le nombre d\u2019images que contient votre GIF ligne 11, et ensuite, collez (CTRL+V) le contenu du fichier texte que nous avons pr\u00e9alablement copi\u00e9 ligne 15 ! (V\u00e9rifiez bien que le contenu de la ligne 16 ne s\u2019est pas gliss\u00e9e \u00e0 la fin de la ligne 15, m\u00eame si cela ne devrait pas poser de probl\u00e8mes).
\nUne fois fait, vous pouvez t\u00e9l\u00e9verser le programme dans l\u2019ESP32 et le GIF anim\u00e9 s\u2019affichera sur l\u2019\u00e9cran OLED.<\/p>\n

J\u2019ai \u00e9galement 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\u2019ai pas pu terminer l\u2019impl\u00e9mentation de cette fonction.
\nVoici cependant le lien vers le programme Arduino permettant en th\u00e9orie de lire le GIF depuis la carte SD, mais qui dans mon cas ne fonctionnait pas :
\nhttps:\/\/univangersfr-my.sharepoint.com\/:u:\/g\/personal\/aprat_etud_univ-angers_fr\/EYEKnGtNrkhMpeXnzJrRPr8BBACLnJAxCUyLtusdikfvIA?e=iLYBPD<\/a>
\nPour utiliser ce programme, il vous faudra l\u00e9g\u00e8rement modifier le programme Gif Convertor.py, il vous faudra en effet commenter le lignes 6, 8, 41, 42, 45, 46, 47, 48, 49, 50.
\nLe programme Python vous cr\u00e9era ainsi toujours un fichier texte que vous renommerez gif.txt, et que vous glisserez dans la carte SD.
\nEn th\u00e9orie cette m\u00e9thode est sens\u00e9e fonctionner mais je n\u2019ai pas r\u00e9ussi \u00e0 la mener \u00e0 bien.<\/p>\n

Projet n\u00b04 : Allumage d\u2019un \u00e9cran LCD par proximit\u00e9 – R\u00e9alis\u00e9 par Zacharie FOURRIER <\/strong><\/font><\/p>\n

Mot cl\u00e9 : ESP32 , \u00e9cran LCD , Arduino, AppInventor<\/p>\n

1\u00e8re \u00e9tape : Pr\u00e9paration<\/strong>
\n1.1\tMat\u00e9riel<\/em>
\n1x ESP32
\n1x Ecran LCD
\n1x Adaptateur I2C pour l\u2019\u00e9cran LCD
\n+ fils et backplate<\/p>\n

1.2 Librairies Arduino
\n<\/em>
\n– BluetoothSerial<\/strong> (Bluetooth est pr\u00e9install\u00e9e dans l\u2019IDE Arduino)
\n– LiquidCrystal_I2C version 1.1.2
\n\"\"<\/a><\/p>\n

1.3 Branchements<\/em>
\n\"unknown<\/a><\/p>\n

1.4 Programmes n\u00e9cessaires<\/em><\/p>\n

Vous pourrez trouver ici<\/a> les deux fichiers \u00e0 t\u00e9l\u00e9charger. Le lien est valable jusqu\u2019au 31 Aout 2021. Pass\u00e9 cette date et si n\u00e9cessaire, vous pouvez envoyer un courriel \u00e0 zfourrier@etud.univ-angers.fr afin que je vous fournisse un nouveau lien.
\nL\u2019application sert en tant qu\u2019administrateur, \u00e0 changer le texte affich\u00e9 lorsqu\u2019un p\u00e9riph\u00e9rique se connecte en bluetooth. Attention : Elle ne marche que sur les appareils android.
\nL\u2019application demande un login (admin) + mot de passe (modpass). Ils ne sont pas modifiables car le seul moyen d\u2019obtenir cette application est par ce lien, ce qui repr\u00e9sente la majeure partie de la s\u00e9curit\u00e9. Il existe une deuxi\u00e8me couche de s\u00e9curit\u00e9 pour \u00e9viter la modification \u00e0 l\u2019aide d\u2019un terminal bluetooth par exemple. Le programme n\u2019acceptera de nouveaux indices que lorsqu\u2019il est en \u00e9tat \u00ab ouvert \u00bb. Pour le passer en mode \u00ab Ferm\u00e9 \u00bb, il faut envoyer \u00ab STOP \u00bb via l\u2019application, et pour l\u2019ouvrir \u00e0 nouveau, il faut envoyer ce mot de passe : \u00ab Jri4fg74 \u00bb. Cela permet \u00e0 l\u2019administrateur d\u2019\u00eatre le seul \u00e0 pouvoir changer le mot de passe affich\u00e9 pendant le fonctionnement normal.
\nLe programme arduino est simple et court, et largement comment\u00e9 pour le cas o\u00f9 un bug se produirait, je le pr\u00e9senterai plus en d\u00e9tail dans une partie suivante.
\nIl vous faut uploader le programme Bluetooth.ino sur l\u2019ESP32 via l\u2019IDE Arduino.<\/p>\n

2\u00e8me \u00e9tape : Fonctionnement et Utilisation<\/strong><\/p>\n

La partie setup est tr\u00e8s simple, on commence par l\u2019initialisation de l\u2019ESP32 en bluetooth, on lui donne un nom et on affiche dans le moniteur s\u00e9rie que le p\u00e9riph\u00e9rique est pr\u00eat \u00e0 \u00eatre utilis\u00e9. La deuxi\u00e8me partie consiste \u00e0 initialiser l\u2019\u00e9cran LCD et d\u00e9sactiver le r\u00e9tro\u00e9clairage. L\u2019\u00e9cran n\u2019affiche rien pour le moment.<\/p>\n

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

Quand un p\u00e9riph\u00e9rique est connect\u00e9 en bluetooth (un smartphone dans la plupart des cas qui vont se pr\u00e9senter), voil\u00e0 ce qu\u2019il se passe :<\/p>\n

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

On allume le r\u00e9tro\u00e9clairage et on affiche le mot de passe actuel.<\/p>\n

}else{
\n lcd.noBacklight;
\n LCDPRINT(\"\");
\n }<\/code>
\nEnfin, quand plus aucun appareil n\u2019est connect\u00e9, l\u2019\u00e9cran s\u2019\u00e9teint et tout le texte est effac\u00e9…<\/p>\n

Nous avons couvert la totalit\u00e9 des interactions de l\u2019utilisateur, nous allons maintenant passer \u00e0 l\u2019interface administrateur.
\nPour commencer \u00e0 param\u00e9trer le mot de passe, vous devez vous munir d\u2019un t\u00e9l\u00e9phone avec l\u2019application Polytech Angers Treasure Hunt Admin (elle appara\u00eetra peut-\u00eatre de cette mani\u00e8re dans votre liste d\u2019applications :
\n \"\"<\/a>
\nSur l\u2019\u00e9cran d\u2019accueil, vous pourrez entrer le login et le mot de passe fournis pr\u00e9c\u00e9demment dans ce document (paragraphe 1.4), puis vous aurez acc\u00e8s au panneau de configuration. Cette fois encore, vous pourrez tr\u00e8s simplement entrer l\u2019indice que vous d\u00e9sirez afficher sur l\u2019\u00e9cran, cliquer sur le bouton send et l\u2019\u00e9cran devrait se mettre \u00e0 jour. Par s\u00e9curit\u00e9, il est recommand\u00e9 d\u2019envoyer STOP juste apr\u00e8s, de mani\u00e8re \u00e0 emp\u00eacher un utilisateur poss\u00e9dant un terminal bluetooth de modifier l\u2019indice pour poser probl\u00e8me aux autres utilisateurs.
\nSi l\u2019appareil est verrouill\u00e9 (n\u2019accepte pas de nouveaux indices) et que quelqu\u2019un essaie de changer l\u2019indice, un message demandant le mot de passe s\u2019affichera pendant 5 secondes sur l\u2019\u00e9cran LCD. La proc\u00e9dure pour le d\u00e9verrouiller est d\u00e9crite au paragraphe 1.4. Il est \u00e0 noter qu\u2019apr\u00e8s un red\u00e9marrage, l\u2019indice affich\u00e9 sera celui par d\u00e9faut et l\u2019appareil sera en mode ouvert (accepte un nouvel indice). Vous pouvez trouver et modifier l\u2019indice par d\u00e9faut ici :
\n String clue = \"fvopdjsbodfps\"; \/\/ default clue
\n<\/code>
\nDe la m\u00eame mani\u00e8re, si vous pr\u00e9f\u00e9rez que l\u2019appareil d\u00e9marre en mode ferm\u00e9, il suffit de changer la ligne suivante
\n int receivingNewCodes = 0 ; <\/code>
\nEn
\n int receivingNewCodes = 1 ; <\/code><\/p>\n

Projet n\u00b05 : Code secret sous forme d\u2019un code PIN – R\u00e9alis\u00e9 par Th\u00e9o ROY<\/strong><\/font><\/p>\n

Le but de mon projet est de r\u00e9aliser un clavier tactile \u00e0 code PIN.
\nJe vais donc vous montrer comment le coder.<\/p>\n

Mot cl\u00e9 : 2.4 \u2018\u2019 TFT LCD SHIELD, Arduino, clavier tactile, code PIN <\/p>\n

1\u00e8re \u00e9tape : Pr\u00e9paration<\/strong><\/p>\n

Mat\u00e9riel :<\/em>
\n–\tCarte Arduino Uno
\n–\tEcran 2.4 \u2018\u2019 TFT LCD SHIELD<\/p>\n

Branchement :<\/em>
\nLe branchement est simple, l\u2019\u00e9cran s\u2019emboite sans probl\u00e8me avec l\u2019arduino uno<\/p>\n

Librairie :<\/em>
\nSPFD5408 (https:\/\/cutt.ly\/MnGW3RL<\/a>)
\nCette librairie contient toutes les librairies n\u00e9cessaires <\/p>\n

2\u00e8me \u00e9tape : Pr\u00e9paration du code<\/strong>
\n
\nD\u00e9finitions des PINs :<\/em>
\n#define YP A1
\n#define XM A2
\n#define YM 7
\n#define XP 6
\n#define LCD_CS A3
\n#define LCD_CD A2
\n#define LCD_WR A1
\n#define LCD_RD A0
\n#define LCD_RESET A4<\/code><\/p>\n

Calibrage de l\u2019\u00e9cran:<\/em>
\n#define TS_MINX 125
\n#define TS_MINY 85
\n#define TS_MAXX 965
\n#define TS_MAXY 905<\/code>
\n
\nD\u00e9finition des couleurs et de la pression :<\/em>
\n#define WHITE 0x0000
\n#define YELLOW 0x001F
\n#define CYAN 0xF800
\n#define PINK 0x07E0
\n#define RED 0x07FF
\n#define GREEN 0xF81F
\n#define BLUE 0xFFE0
\n#define BLACK 0xFFFF
\n#define MINPRESSURE 10
\n#define MAXPRESSURE 1000<\/code><\/p>\n

De la m\u00eame mani\u00e8re que le projet n\u00b01, il faut trouver le code hexad\u00e9cimal du driver et l\u2019\u00e9crire dans le void setup().<\/p>\n

Configuration de l\u2019\u00e9cran (300 est la sensibilit\u00e9) : <\/em>
\nTouchScreen ts = TouchScreen(XP, YP, XM, YM, 300); <\/code><\/p>\n

Communication avec le LCD :<\/em>
\nAdafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);<\/code> <\/p>\n

3\u00e8me \u00e9tape : Affichage du clavier \u00e0 code.<\/strong>
\n\"\"<\/a>
\nPour l\u2019affichage du clavier j\u2019ai cr\u00e9\u00e9 une fonction draw_Buttons() que j\u2019utilise dans le void setup(), comme cela elle va apparaitre au d\u00e9marrage du programme.
\n
\nAffichage des colonnes :<\/em>
\nJ\u2019utilise la fonction tft.fillRect qui se construit de la fa\u00e7on suivante :
\ntft.fillRect( pos.x, pos.y, longueur, hauteur, couleur) ; <\/code>
\nCela va cr\u00e9er un rectangle rempli de la couleur choisi. <\/p>\n

Affichage des lignes verticales et horizontales :<\/em>
\nJ\u2019utilise la fonction tft.drawFastHLine qui se construit de la fa\u00e7on suivante :
\ntft.drawFastHLine( pos.x, pos.y, longueur, couleur) ; <\/code>
\nCela va cr\u00e9er une ligne horizontale. De la m\u00eame mani\u00e8re pour la ligne verticale avec tft.drawFastVLine.
\n
\nAffichage de la zone de texte :<\/em>
\nDe la m\u00eame fa\u00e7on que les colonnes avec la fonction tft.fillRect.
\n
\nAffichage des caract\u00e8res du clavier :<\/em>
\nPour \u00e9crire du texte nous allons avoir besoin de 4 fonctions.
\n La premi\u00e8re est tft.setCursor qui sert \u00e0 placer le point de d\u00e9part du texte :
\ntft.setCursor( pos.x, pos.y) ; <\/code>
\nEnsuite il y a tft.TextColor qui va changer la couleur du texte :
\ntft.setTextColor(couleur);<\/code>
\nPuis, pour g\u00e9rer la taille du texte il y a la fonction tft.setTextSize :
\ntft.setTextSize(n); <\/code>
\nEnfin pour \u00e9crire du texte, tft.println , qui \u00e9crit tous les caract\u00e8res non sp\u00e9ciaux :
\ntft.println(\u201c \u201d);<\/code><\/p>\n

Pour afficher les caract\u00e8res, j\u2019ai mis ces fonctions dans une boucle associ\u00e9e \u00e0 un matrice :
\nString symbol[4][4] = {
\n { \"7\", \"8\", \"9\", \"\" },
\n { \"4\", \"5\", \"6\", \"\" },
\n { \"1\", \"2\", \"3\", \"\" },
\n { \"X\", \"0\", \"V\", \"?\" }
\n};
\n <\/code><\/p>\n

4\u00e8me \u00e9tape : Programmer les boutons <\/strong><\/p>\n

Bouton chiffre :<\/em>
\nChaque bouton correspondant \u00e0 un chiffre est configur\u00e9 de cette mani\u00e8re :
\nif (X50)
\nif (Y>85 && Y<140) \/\/Bouton 3
\n \t\t{Serial.println ("Bouton 3");
\n \t\t result = true;
\n \t\t Number = (Number*10) + 3;
\n \t\t } <\/code>
\n–\tif<\/code> (\u2026) : Correspond \u00e0 la position de la touche
\n–\tresult = true<\/code> : Permet la saisie du texte
\n–\tNumber<\/code> : Correspond au code<\/p>\n

Bouton valider :<\/em>
\nif (Y>85 && Y<140) \/\/Valider
\n {Serial.println ("Valider");
\n result = false;
\n tft.fillRect(0, 0, 240, 80, CYAN);
\n tft.setCursor(10, 20);
\n tft.setTextSize(2);
\n if (Number == Code) {
\n tft.println("Bon Code");
\n delay(1000);
\n }else{
\n tft.println("Mauvais Code");
\n }<\/code>
\n–\tresult = false <\/code>: Arr\u00eat de la saisie
\n–\ttft.fillRect() <\/code>: Permet d\u2019effacer en recr\u00e9ant le rectangle
\n–\tEnsuite, tout d\u00e9pend si le code est le bon.<\/p>\n

Bouton Effacer :<\/em>
\nif (Y>192 && Y<245) \/\/Effacer
\n {Serial.println ("Bouton Effacer");
\n Number=0;
\n result = false;
\n tft.fillRect(0, 0, 240, 80, CYAN);
\n }<\/code>
\n–\tNumber = 0<\/code> : R\u00e9initialiser le code
\n–\ttft.fillRect()<\/code> : Permet d\u2019effacer en recr\u00e9ant le rectangle
\n–\tresult = false<\/code> : Arr\u00eat de la saisie<\/p>\n

Bouton Aide :<\/em>
\nif (Y>0 && Y<85) \/\/Aide
\n {Serial.println ("Aide");
\n result = false;
\n tft.fillRect(0, 0, 240, 80, CYAN);
\n tft.setCursor(10, 20);
\n tft.setTextSize(2);
\n tft.println("Code \u00e0 4 chiffres");
\n }<\/code>
\n–\ttft.fillRect()<\/code> : Permet d\u2019effacer en recr\u00e9ant le rectangle
\n–\ttft.println()<\/code> : Permet d\u2019afficher un texte<\/p>\n

Et voici une petite vid\u00e9o qui montre comment ce projet fonctionne :
\nhttps:\/\/www.youtube.com\/watch?v=AxCin9HA1Iw<\/a>
\n

https:\/\/blog.univ-angers.fr\/istiaprojetsei2\/files\/2021\/06\/Demo.mp4<\/a><\/video><\/div><\/p>\n

Code complet : https:\/\/cutt.ly\/DnHyFnG<\/a><\/p>\n

Conclusion <\/strong><\/p>\n

Nous avons tous r\u00e9ussi \u00e0 mener a bien nos projets et \u00e0 les finaliser. M\u00eame s’il y a sans doute des choses \u00e0 am\u00e9liorer, tous les projets fonctionnent.
\nCe n’\u00e9tait pas vraiment un projet d’\u00e9quipe, car nous avions chacun notre projet, mais il a \u00e9t\u00e9 tr\u00e8s enrichissant pour chacun.
\nCet article touche \u00e0 sa fin. Nous esp\u00e9rons que ces projets vous ont aid\u00e9 \u00e0 r\u00e9aliser les v\u00f4tres.
\nMerci de votre lecture. <\/p>\n","protected":false},"excerpt":{"rendered":"

Bonjour \u00e0 tous, Nous sommes 4 \u00e9tudiants de PeiP 2, Th\u00e9o ROY, Zacharie FOURRIER, Alexandre PRAT et Eli DESTOMBES. Dans le cadre de notre projet de conception nous avons travaill\u00e9 sur une display-box. L’objectif de notre projet est de r\u00e9aliser … Continuer la lecture →<\/span><\/a><\/p>\n","protected":false},"author":74172,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[344],"tags":[43,252,437,442,436,243],"class_list":["post-1478","post","type-post","status-publish","format-standard","hentry","category-344","tag-arduino","tag-bluetooth","tag-ecran-lcd","tag-ecran-oled","tag-ecran-tactile","tag-polytech-angers"],"_links":{"self":[{"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/posts\/1478","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/users\/74172"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/comments?post=1478"}],"version-history":[{"count":1,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/posts\/1478\/revisions"}],"predecessor-version":[{"id":1820,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/posts\/1478\/revisions\/1820"}],"wp:attachment":[{"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/media?parent=1478"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/categories?post=1478"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/polytech_2A\/wp-json\/wp\/v2\/tags?post=1478"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}