L’article Affichage publicitaire avec Arduino (1) vous a montré comment réaliser un mobilier urbain publicitaire avec un mini-écran couleur de 0,95 pouce ayant une résolution de 96 par 64 pixels. L’écran pouvait être utilisé pour un affichage horizontal ou vertical. En fait, de nos jours, les affichages publicitaires utilisent en majorité des écrans verticaux ; cet article va donc vous montrer comment on peut obtenir un tel mobilier urbain en utilisant un écran dont la résolution est 80 par 160 pixels.
Affichage publicitaire
Affichage publicitaire avec Arduino (2)
Affichage publicitaire vertical
.
Par : ,
DIFFICULTÉ :★★☆
Si vous n’avez pas encore lu l’article Affichage publicitaire avec Arduino (1), c’est le moment de le faire car nous y ferons souvent référence, histoire de ne pas répéter ce que nous avons déjà dit. Vous y trouverez ce qui caractérise un écran et comment celui-ci doit être connecté à une carte Arduino. Pour réaliser notre affichage vertical, nous utiliserons les mêmes principes mais avec un écran différent.
Choix de l’écran
L’écran utilisé dans cet article est un écran couleur TFT [1] de 0,96 pouce, connecté en SPI, de résolution 160 x 80 [2], affichant 65536 couleurs en RGB [3], et avec un contrôleur ST7735 (figure 1).
- Figure 1
- L’écran utilisé dans cet article (source EstarDyn).
Cet écran peut se trouver sur internet pour moins de deux euros : voici un lien vers AliExpress mais vous êtes libre d’acheter l’écran chez un autre revendeur. Les dimensions du circuit imprimé sont 24 mm par 30 mm pour une épaisseur de 2.8 mm. L’écran fait 10.8 mm de large pour 21.7 mm de haut, ce qui fait une diagonale de 24.2 mm (0.96 pouce).
La firme Adafruit produit également un tel écran appelé Adafruit Mini TFT Breakout qui a l’avantage d’avoir son lecteur de carte micro-SD incorporé ainsi qu’un régulateur de tension abaissant le 5 V d’Arduino à 3,3 V nécessaires au contrôleur ST7735 et un adaptateur de signaux logiques 5V -> 3.3V pour le bus SPI. Un tel concentré de technologie a évidemment un coût plus élevé. Adafruit a de plus produit les bibliothèques nécessaires à l’utilisation de ses produits et également un tutoriel (en anglais) pour découvrir ce mini écran.
Nous avons fait le choix de l’écran d’origine asiatique et c’est là que les ennuis ont commencé ; si cet article est écrit, c’est que nous les avons résolus et nous allons vous expliquer comment.
Connexion de l’écran à la carte Arduino
L’écran contient un régulateur de tension incorporé 3.3 V et du coup, sa broche VCC peut donc être reliée au +5 V d’une carte Arduino Uno ou Nano. La question se pose pour le bus SPI : celui d’Arduino est en 5 V et celui du contrôleur ST7735 en 3.3 V. Un rapide coup d’œil à la notice du ST7735 nous dit que le voltage de la logique d’entrée accepte jusqu’à VDDI + 0.3 V avec VDDI qui désigne l’alimentation de la logique et qui peut aller jusqu’à 4.6 V. On arrive donc à 4.9 V et comme le constructeur a dû se ménager une petite marge, on peut penser qu’on peut relier notre écran au bus SPI d’une carte Arduino Uno ou Nano ; d’ailleurs, tous les tutos trouvés sur internet font ainsi. Effectivement, si nous avions acheté la carte Adafruit, nous n’aurions pas ce problème et nous n’aurions pas à risquer deux euros pour vérifier que notre écran survivra !
L’écran ayant effectivement survécu, nous l’avons donc relié à une carte Arduino (Uno ou Nano) selon le plan de montage donné dans l’article précédent. Nous rappelons le branchement des sorties avec le tableau ci-dessous, sans oublier qu’il faut aussi connecter le lecteur de carte micro-SD au bus SPI.
| Couleur | Uno | Ecran | Carte SD |
|---|---|---|---|
| Rouge | 5 V | Vcc | Vcc |
| Noir | GND | GND | GND |
| Vert | D4 | - | CS |
| Vert | D8 | D/C (DC) | - |
| Gris | D9 | RES | - |
| Violet | D10 | CS | - |
| Orange | D11 | DIN (SDA) | COPI (MOSI) |
| Jaune | D12 | - | CIPO (MISO) |
| Bleu | D13 | CLK (SCL) | SCK |
Bibliothèques utilisées
Ce sont quasiment les mêmes que dans les programmes donnés dans l’article Affichage publicitaire avec Arduino (1), sauf celle qui concerne le contrôleur de l’écran. Nous avons utilisé la bibliothèque Adafruit_ST7735 qu’il faut au préalable installer dans l’IDE grâce au gestionnaire de bibliothèque ; cette fois, vous pouvez installer la version la plus récente (1.9.3 à la date d’écriture de l’article). Cette bibliothèque sert également au contrôleur ST7789, comme on le voit dans son titre quand on l’installe. Bien sûr, nous utilisons également les bibliothèques Adafruit_GFX, SPI et SD, comme dans l’article précédent.
Le programme
Il est conçu selon le même principe que les programmes donnés dans l’article Affichage publicitaire avec Arduino (1) : nous avons utilisé la même fonction d’affichage d’images bitmap appelée « bmpDraw ». Auparavant, il a fallu instancier l’écran : ceci est fait à la ligne 19 du programme grâce à :
// Ecran 0.96" controleur ST7735 - For 0.96" TFT with ST7735 use
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);Les arguments de la fonction sont les numéros de broches servant à sélectionner l’écran (TFT_CS), à envoyer les ordres de contrôle (TFT_DC) et au reset (TFT_RST). Ces broches sont déclarées par des #define et sont les mêmes que dans l’article précédent.
Il faut initialiser l’écran dans le setup et ceci est fait à la ligne 34 du programme grâce à :
tft.initR(INITR_MINI160x80);
Enfin, dans la fonction bmpDraw, la ligne qui envoie les pixels colorés à l’écran est aussi un peu différente :
tft.pushColor(tft.color565(r,g,b));
Voilà, les quatre modifications ont été faites : bibliothèque pour le ST7735, instanciation de l’écran, initialisation de l’écran et fonction bmpDraw. Les programmes sont donnés dans l’archive située en fin d’article.
Création des images à afficher
La méthode a été largement décrite dans l’article Affichage publicitaire avec Arduino (1) avec le logiciel « Paint ». On rappelle que les images doivent être au format bitmap 24 bits. L’écran étant fait pour une utilisation verticale (même s’il est possible de l’utiliser à l’horizontale), les dimensions de l’image doivent être de 80 x 160 (et non l’inverse). Il faut donc partir d’une partie d’image dont la hauteur est deux fois la largeur.
Nous avons donc repris l’image trouvée sur internet de la petite robe noire (parfum de Guerlain) pour en faire une image verticale à la bonne dimension, et nous l’avons enregistrée au bon format et copiée sur notre carte micro-SD.
Premier essai, première déception
L’image s’affiche sur l’écran, mais les couleurs ne correspondent pas. En fait, les tons rosés de l’image sont remplacés par des tons verts, donnant l’impression que l’image est affichée en négatif (la bonne époque des pellicules photos en couleur). Pour le vérifier, nous décidons de créer l’image en négatif grâce au logiciel gratuit Gimp (menu Couleurs > Inverser) : l’affichage sur l’écran ne donne pas un positif mais présente des teintes qui ne correspondent pas non plus aux couleurs d’origine (le problème aurait été trop simple à résoudre !). Il faut donc se plonger dans la documentation du contrôleur ST7735 pour essayer de comprendre et faire quelques essais.
Le codage des couleurs
Le codage des couleurs est expliqué dans la documentation de la bibliothèque Adafruit_GFX. Chaque point de l’image (pixel) est représenté par un mot de 16 bits non signé, codant chaque canal de couleur (RGB pour rouge, vert, bleu) comme le montre la figure 2. Les cinq bits les plus significatifs représentent la couleur rouge, les six bits du milieu la couleur verte et les cinq bits les moins significatifs la couleur bleue, soit seize bits au total. Ce codage est souvent référencé par 565 comme on le verra dans le programme avec la fonction qui envoie les couleurs à l’écran. La couleur verte a un bit de plus parce que nos yeux sont plus sensibles au vert.
- Figure 2
- Le codage des couleurs en 16 bits (source Adafruit).
Si maintenant, on étudie la notice du ST7735, on voit que celui-ci peut fonctionner dans deux modes : l’ordre des canaux peut être R, G, B ou bien B, G, R. Nous en avons donc conclu qu’il pourrait bien y avoir une inversion des canaux R et B. En fait, la bibliothèque a été écrite pour des produits Adafruit et donc l’initialisation se fait certainement très bien pour un écran Adafruit, peut-être moins bien pour un écran d’une autre marque.
Nous avons donc fait quelques essais, en affichant une page rouge dans le setup. Et bien nous avons obtenu une page jaune ! De la même manière, si on veut une page jaune, on en obtient une rouge.
D’après la figure 2, un pixel rouge serait codé 11111 000000 00000 (il n’y a que du rouge). Un pixel jaune lui serait un mélange de rouge et de vert ; il serait codé 11111 111111 00000 (il y a du rouge et du vert). La figure 3 permet de comprendre : la première ligne représente ce qu’on veut (du rouge), la deuxième ce qu’on obtient (du jaune). Considérons la couleur jaune et commençons par inverser tous les bits de chacun des canaux : nous obtenons la ligne 3 de la figure 3. Maintenant, échangeons le canal R avec le canal B : nous obtenons la ligne 4 qui est identique à la ligne 1. Nous sommes partis du jaune et nous obtenons du rouge.
- Figure 3
Dans la fonction bmpDraw, nous avons donc modifié l’instruction qui envoie les couleurs à l’écran de la façon suivante :
// Convert pixel from BMP to TFT format, push to display
b = sdbuffer[buffidx++];
g = sdbuffer[buffidx++];
r = sdbuffer[buffidx++];
// L'instruction suivante a ete modifiee car probleme affichage de couleurs.
// (A l'origine, l'instruction etait : tft.pushColor(tft.color565(r,g,b));)
tft.pushColor(tft.color565(~b,~g,~r));Ceci est d’ailleurs expliqué en commentaire : par rapport à l’instruction initiale, on a interverti les canaux R et B et on a inversé tous les bits grâce au caractère tilde (opérateur bitwise not). Les programmes fournis dans l’archive en fin d’article sont opérationnels pour un écran acheté sur le marché asiatique et vous n’avez donc rien à modifier. Si toutefois vous aviez des problèmes d’affichage de couleur, la première chose à faire serait de remettre l’instruction telle qu’elle figure dans la fonction de la bibliothèque GFX.
Programmes et images
L’archive ci-dessous contient deux programmes et quelques échantillons d’images qu’il faudra copier sur la carte micro-SD (à la racine, c’est-à-dire pas dans un dossier).
Programmes et images
Le programme Diaporama_demo_80x160.ino affiche trois images verticales et une image horizontale pour ceux qui veulent utiliser l’écran horizontalement (attention, cette image se regarde à l’horizontale mais ses dimensions sont tout de même 80 de large pour 160 de haut).
Le programme Diaporama_publicitaire_80x160.ino affiche huit images publicitaires ; c’est ce programme que vous utiliserez pour votre montage.
Retrait des marges disgracieuses
L’affichage des images fournies dans l’archive se fait sans problème, cependant on constate une petite marge sur le bord droit de l’écran (tenu verticalement avec le connecteur à gauche), ainsi que sur le bord inférieur. Il faut vraiment une loupe pour voir cela et beaucoup de spectateurs ne s’en rendraient même pas compte, mais tout de même. Voici la méthode pour régler ce problème.
Ce qui suit oblige à aller modifier un fichier de la bibliothèque Adafruit_ST7735, ce qui n’est pas anodin pour le fonctionnement de la bibliothèque si vous ne faites pas exactement ce qu’il faut. Suivez bien les explications et pensez avant tout à faire une copie du fichier à modifier, afin de pouvoir le restaurer en cas de problèmes. Sinon, vous aurez à désinstaller la bibliothèque et à la réinstaller en totalité.
Allez dans le dossier où sont stockées les différentes bibliothèques (généralement Documents > Arduino > libraries). Ouvrez le dossier Adafruit_ST7735_and_ST7789_Library. Cherchez le fichier Adafruit_7735.cpp et ouvrez-le avec un éditeur de programmes comme Notepad++ ou bien Atmel Studio 7 [4]. Cherchez le texte montré par la figure 4 : on le reconnaît grâce à INITR_MINI160x80 (flèche rouge sur la figure). Entrez 26 et 1 (l’encadré rouge) à la place de 24 et 0. Enregistrez votre modification : la bibliothèque a été modifiée.
- Figure 4
- Extrait du fichier Adafruit_ST7735.cpp et changements à faire.
Il faut maintenant recompiler le programme et le téléverser à nouveau dans votre carte Arduino. La compilation se fera avec la bibliothèque modifiée et les marges disgracieuses disparaîtront de l’écran, comme le montre la figure 5. Cela n’était pas si compliqué !
- Figure 5
- Un exemple d’affichage : une publicité pour la série "The Crown" de Netflix.
Conclusion
Avec les deux articles, vous avez maintenant la possibilité de reproduire un mobilier urbain publicitaire en choisissant la forme et les dimensions de l’écran. De nos jours, la forme verticale est la plus fréquente, mais si vous préférez utiliser votre écran horizontalement, son rapport dimensionnel égal à deux en fait presque un écran de cinémascope. Sympathique non ?
[1] TFT LCD : Thin Film Transistor Liquid Crystal Display.
[2] C’est ce qu’indiquent les sites de vente, mais comme nous allons utiliser l’écran en orientation portrait (verticalement), la résolution est en fait 80 pixels de large et 160 pixels de haut, soit 80 x 160, comme l’indique l’inscription sur le circuit imprimé (figure 1).
[3] Red-Green-Blue ou si vous préférez Rouge-Vert-Bleu.
[4] Notepad++ est gratuit, ainsi qu’Atmel Studio 7 mais ce dernier n’existe que pour Windows
11 Messages
-
Affichage publicitaire avec Arduino (2) 1er octobre 2022 16:07, par Jean-claude
Bonjour
J’utilise un raspberry pi pico, ce qui permet de se passer du lecteur SD.
Avec un Teensy4.0 l’affichage est instantané (mais c est plus cher)Merci à locoduino qui m’a fait découvrir de DIY pour le DCC
Voir en ligne : Letraindejc
-
Merci Jean-Claude pour ce partage : j’incite les lecteurs à aller voir ton site en ligne et à récupérer les fichiers STL du socle car c’est un peu ce qui manque à LOCODUINO : l’intégration d’un montage dans un décor à l’échelle pour que ce soit beau. Et ton socle est vraiment super.
Oui, l’utilisation d’un PI pico, ou bien de l’écran Adafruit, permet d’avoir le lecteur SD incorporé : au final, le prix ne doit pas être très supérieur au matériel asiatique pour une qualité bien supérieure. A méditer si on doit acheter tous les composants pour réaliser ce montage.-
Le Pi PICO a beaucoup de mémoire et les images peuvent être stockées en variable.
Il faut cependant convertir en JPG en string... des logiciels le font.Avec un Teensy 4.0 (qui est très rapide) on peut même faire des "transitions"
Quand j’ai fait ma maquette je ne connaissais pas l’arduino.. encore merci à votre site que se soient les projets que la vulgarisation.
ps j’ai découvert le pico dans une de vos rubriques.
Jean-Claude
-
-
-
Affichage publicitaire avec Arduino (2) 7 mars 2023 12:15, par Besseyre Guy
bonjour à tous
je possède un écran ips TFT de 1.14 " de marque Greatzt, ré
solution 135X240 controleur ST 7789
puis-je l’utiliser dans cette appli ?
merci-
Cet article est écrit pour un écran qui fait 80 x 160 et qui utilise un contrôleur ST7785. Il risque d’y avoir pas mal d’adaptation à faire si vous utilisez un écran qui a une résolution différente et un contrôleur différent. Mais tout est possible pour quelqu’un qui a déjà un peu d’expérience et qui est capable de chercher des solutions sur le net.
Vous ne dites rien de votre niveau d’expertise : si vous êtes débutant, je vous déconseille d’utiliser un autre écran, surtout au prix où on trouve l’écran cité dans l’article.
-
-
Affichage publicitaire avec Arduino (2) 20 mars 2023 21:41, par Besseyre Guy
bonsoir
je ne trouve pas la référence de la carte lecteur de micro SD
utilisée dans l’application (dans aliexpress)
merci pour l’info
bonne soirée-
C’est exact, dans le premier article, nous n’avons simplement dit que "le montage utilise un lecteur de carte SD relié également au bus SPI" mais nous n’avons donné aucune référence. Vous pouvez utiliser n’importe quelle carte lecteur de SD ou de micro-SD. Pour en trouver une, il suffit de taper dans le moteur de recherche de votre navigateur carte micro-SD SPI Arduino : tout ce qui compte, c’est de pouvoir la relier à la carte Arduino via le bus SPI.
-
-
Affichage publicitaire avec Arduino (2) 28 avril 2023 18:50, par Besseyre guy
bonjour Christian
J’ai réalisé l’application décrite dans l’article (figure 7), après avoir approvisionné l’écran chez
Aliexpress ,conforme a la photo n°5, ainsi que le lecteur de micro-sd, pilotage par Arduino Nano ;
l’écran s’allume mais aucune image n’apparait ; essai sur un deuxième montage ,même chose
je ne vois pas ou est l’erreur, ci-joint le sketch ;
bon week-end
// Diaporama_demo_80x160.ino
// -------------------------#include <Adafruit_GFX.h> // Bibliotheque graphique - Core graphics library
#include <Adafruit_ST7735.h> // Bibliotheque specifique ST7735 - Hardware-specific library for ST7735
#include <SPI.h>
#include <SD.h>#define dureeAffichage 7500 // Duree d’affichage
#define TFT_RST 9 // Ligne de Reset - Reset line for TFT
#define TFT_CS 10 // Selection de l’ecran - Chip select line for TFT display
#define TFT_DC 8 // Commande donnees pour ecran - Data/command line for TFT
#define SD_CS 4 // Selection du lecteur carte SD - Chip select line for SD card
//D11 -> MOSI SD + SDA TFT
//D12 -> MISO SD
//D13 -> SCK SD + SCL TFT// Ecran 0.96" controleur ST7735 - For 0.96" TFT with ST7735 use
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST) ;void setup(void)
Serial.begin(9600) ;while (!Serial)
delay(10) ; // wait for serial console
pinMode(TFT_CS, OUTPUT) ;
digitalWrite(TFT_CS, HIGH) ;
pinMode(SD_CS, OUTPUT) ;
digitalWrite(SD_CS, HIGH) ;// Initialisation de l’ecran 0.96" 160x80 TFT
tft.initR(INITR_MINI160x80) ;tft.fillScreen(ST77XX_RED) ; // En fait, affichera jaune
delay(3000) ;Serial.print("Initializing SD card...") ;
if (!SD.begin(SD_CS))
Serial.println("failed !") ;
return ;
Serial.println("OK !") ;File root = SD.open("/") ;
printDirectory(root, 0) ;
root.close() ;void loop()
// Affichage
// Changer les noms des fichiers - change the names here !
bmpDraw("RN80x160.BMP", 0, 0) ;
delay(dureeAffichage) ;
bmpDraw("Defense.BMP", 0, 0) ;
delay(dureeAffichage) ;
bmpDraw("AirFranc.BMP", 0, 0) ;
delay(dureeAffichage) ;
bmpDraw("Locoduin.BMP", 0, 0) ;
delay(dureeAffichage) ;
// This function opens a Windows Bitmap (BMP) file and
// displays it at the given coordinates. It’s sped up
// by reading many pixels worth of data at a time
// (rather than pixel by pixel). Increasing the buffer
// size takes more of the Arduino’s precious RAM but
// makes loading a little faster. 20 pixels seems a
// good balance.#define BUFFPIXEL 20
void bmpDraw(char *filename, uint8_t x, uint16_t y)
File bmpFile ;
int bmpWidth, bmpHeight ; // W+H in pixels
uint8_t bmpDepth ; // Bit depth (currently must be 24)
uint32_t bmpImageoffset ; // Start of image data in file
uint32_t rowSize ; // Not always = bmpWidth ; may have padding
uint8_t sdbuffer[3*BUFFPIXEL] ; // pixel buffer (R+G+B per pixel)
uint8_t buffidx = sizeof(sdbuffer) ; // Current position in sdbuffer
boolean goodBmp = false ; // Set to true on valid header parse
boolean flip = true ; // BMP is stored bottom-to-top
int w, h, row, col ;
uint8_t r, g, b ;
uint32_t pos = 0, startTime = millis() ;if((x >= tft.width()) || (y >= tft.height())) return ;
Serial.println() ;
Serial.print(F("Loading image ’")) ;
Serial.print(filename) ;
Serial.println(’\’’) ;// Open requested file on SD card
if ((bmpFile = SD.open(filename)) == NULL)
Serial.print(F("File not found")) ;
return ;
// Parse BMP header
if(read16(bmpFile) == 0x4D42) // BMP signature
Serial.print(F("File size : ")) ; Serial.println(read32(bmpFile)) ;
(void)read32(bmpFile) ; // Read & ignore creator bytes
bmpImageoffset = read32(bmpFile) ; // Start of image data
Serial.print(F("Image Offset : ")) ; Serial.println(bmpImageoffset, DEC) ;
// Read DIB header
Serial.print(F("Header size : ")) ; Serial.println(read32(bmpFile)) ;
bmpWidth = read32(bmpFile) ;
bmpHeight = read32(bmpFile) ;
if(read16(bmpFile) == 1) // # planes — must be ’1’
bmpDepth = read16(bmpFile) ; // bits per pixel
Serial.print(F("Bit Depth : ")) ; Serial.println(bmpDepth) ;
if((bmpDepth == 24) && (read32(bmpFile) == 0)) // 0 = uncompressedgoodBmp = true ; // Supported BMP format — proceed !
Serial.print(F("Image size : ")) ;
Serial.print(bmpWidth) ;
Serial.print(’x’) ;
Serial.println(bmpHeight) ;// BMP rows are padded (if needed) to 4-byte boundary
rowSize = (bmpWidth * 3 + 3) & 3 ;// If bmpHeight is negative, image is in top-down order.
// This is not canon but has been observed in the wild.
if(bmpHeight < 0)
bmpHeight = -bmpHeight ;
flip = false ;
// Crop area to be loaded
w = bmpWidth ;
h = bmpHeight ;
if((x+w-1) >= tft.width()) w = tft.width() - x ;
if((y+h-1) >= tft.height()) h = tft.height() - y ;// Set TFT address window to clipped image bounds
tft.setAddrWindow(x, y, x+w-1, y+h-1) ;for (row=0 ; row<h ; row++) // For each scanline...
// Seek to start of scan line. It might seem labor-
// intensive to be doing this on every line, but this
// method covers a lot of gritty details like cropping
// and scanline padding. Also, the seek only takes
// place if the file position actually needs to change
// (avoids a lot of cluster math in SD library).
if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize ;
else // Bitmap is stored top-to-bottom
pos = bmpImageoffset + row * rowSize ;
if(bmpFile.position() != pos) // Need seek ?
bmpFile.seek(pos) ;
buffidx = sizeof(sdbuffer) ; // Force buffer reload
for (col=0 ; col<w; col++) { // For each pixel...
// Time to read more pixel data?
if (buffidx >= sizeof(sdbuffer)) // Indeed
bmpFile.read(sdbuffer, sizeof(sdbuffer)) ;
buffidx = 0 ; // Set index to beginning
// Convert pixel from BMP to TFT format, push to display
b = sdbuffer[buffidx++] ;
g = sdbuffer[buffidx++] ;
r = sdbuffer[buffidx++] ;
// La ligne suivante a ete modifiee car probleme affichage de couleurs.
// (A l’origine, la ligne etait : tft.pushColor(tft.color565(r,g,b)) ;)
tft.pushColor(tft.color565( b, g, r)) ;
// end pixel
// end scanline
Serial.print(F("Loaded in ")) ;
Serial.print(millis() - startTime) ;
Serial.println(" ms") ;
// end goodBmp
bmpFile.close() ;
if(!goodBmp) Serial.println(F("BMP format not recognized.")) ;
// These read 16- and 32-bit types from the SD card file.
// BMP data is stored little-endian, Arduino is little-endian too.
// May need to reverse subscript order if porting elsewhere.uint16_t read16(File f)
uint16_t result ;
((uint8_t *)&result)[0] = f.read() ; // LSB
((uint8_t *)&result)[1] = f.read() ; // MSB
return result ;
uint32_t read32(File f)
uint32_t result ;
((uint8_t *)&result)[0] = f.read() ; // LSB
((uint8_t *)&result)[1] = f.read() ;
((uint8_t *)&result)[2] = f.read() ;
((uint8_t *)&result)[3] = f.read() ; // MSB
return result ;
void printDirectory(File dir, int numTabs)
while (true)File entry = dir.openNextFile() ;
if (! entry)
// no more files
break ;
for (uint8_t i = 0 ; i < numTabs ; i++)
Serial.print(’\t’) ;
Serial.print(entry.name()) ;
if (entry.isDirectory())
Serial.println("/") ;
printDirectory(entry, numTabs + 1) ;
else
// files have sizes, directories do not
Serial.print("\t\t") ;
Serial.println(entry.size(), DEC) ;
entry.close() ;
-
Inutile de remettre un programme si vous ne l’avez pas modifié et dans ce cas, ne mettez que ce que vous avez modifié !
Je constate tout de même qu’il manque deux accolades fermantes en fin de programme.
La première question est donc : êtes-vous certain que votre carte Nano soit bien programmée ?
La deuxième question est : êtes-vous certain que votre écran comporte un contrôleur ST7735 ? En effet, il y a pléthore d’écrans vendus sur le marché asiatique et ce n’est pas parce qu’il ressemble à la photo 5 que c’est le même. Sa résolution est-elle bien 80 x 160 ?
Enfin, êtes-vous certain d’avoir enregistré les fichiers images sur votre carte SD ? Et d’avoir bien installé la carte SD dans le lecteur ?
Bref, trop peu d’informations pour que je puisse vous répondre alors que vous mettez un programme qui ne me sert à rien (et qui est difficilement exploitable vu le format d’édition).
Avez-vous observé quelque chose qui soit écrit dans le moniteur de l’IDE ? Ce serait déjà une indication intéressante pour savoir ce qu’il se passe.
Dernière question : avez-vous modifié la bibliothèque comme nous l’avons préconisé dans l’article ? Si oui, êtes-vous certain de ne rien avoir modifié d’autre que ce qui est écrit ?
Une fois de plus, il n’y a aucune raison que cela marche chez le ou les auteurs, et pas chez vous : vous avez sans doute oublié une étape. Recommencez tout en prenant votre temps et en vérifiant les points que je viens de mentionner.
Enfin, l’aide sur un montage se fait via le forum : relisez l’article https://www.locoduino.org/spip.php?...
Cdlt.-
bonjour Christian
bien reçu le message pour le forum, je vais donc aller y voir.
désolé pour les informations incomplètes ,j’y veillerais a l’avenir.
donc :- le programme "diaporama publicitaire " a bien été chargé sur le NANO (et sur un UNO), sans modif
- l’écran est bien strictement celui de la photo, avec ST7735
les diapos ont été chargées sur carte micro SD et c’est là OU EST LE PROBLEME ! selon la marque des
cartes , ça fonctionne ou pas !exemple : transcend OK Sandisk NON
merci pour l’aide-
Peut-être essayer de changer le lecteur de carte SD.
Est-ce que les fichiers sur la carte SD peuvent être relus avec un ordinateur ?
Sinon, l’aide du forum permettra sans doute de trouver une solution.
Cdlt.
-
-