Probleme pour afficher un BMP sur un tft 2.4

Bonsoir tout le monde,
tout d’abord pardonnez mon incompétence, ça fait tres longtemps que j’ai pas touché un Arduino…
Voila j’essais désespérément d’afficher des images à la suite sur mon écran 2.4 pouces piloté par un UNO.
j’ai essayé plusieurs librairie et j’en ai enfin trouvé une qui fonctionne mais voila, je sais pas m’en servir…
j’ai trouvé un code qui fonctionne, il me fait afficher des images avec un jolie effet décalé mais moi ce que je voudrai c’est dans un premier temps faire afficher une image pendant 5 seconde puis une autre durant 5 secondes. ( c’est pour essayer de comprendre comment utiliser la bibliothèque).
J’ai donc repéré dans le code la ligne qui affiche l’image, je l’ai dupliqué pour en afficher une autre et j’ai essayé d’effacer le reste, mais ça marche pas…
quelqu’un pourrait m’expliquer pourquoi ça marche pas??
je vous mets le code qui fonctionne c’est le bmpincabon.ino et le code tronqué qui ne fonctionne pas, c’est le bmpincapasbon.ino
lors de la compilation il me marque :
‘bmpDraw’ was not declared in this scope

Le code tronqué qui fonctionne pas:

// BMP-loading example specifically for the TFTLCD breakout board.
// If using the Arduino shield, use the tftbmp_shield.pde sketch instead!
// If using an Arduino Mega make sure to use its hardware SPI pins, OR make
// sure the SD library is configured for 'soft' SPI in the file Sd2Card.h.

#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
#include <SD.h>
#include <SPI.h>

// The control pins for the LCD can be assigned to any digital or
// analog pins...but we'll use the analog pins as this allows us to
// double up the pins with the touch screen (see the TFT paint example).
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0

// When using the BREAKOUT BOARD only, use these 8 data lines to the LCD:
// For the Arduino Uno, Duemilanove, Diecimila, etc.:
//   D0 connects to digital pin 8  (Notice these are
//   D1 connects to digital pin 9   NOT in order!)
//   D2 connects to digital pin 2
//   D3 connects to digital pin 3
//   D4 connects to digital pin 4
//   D5 connects to digital pin 5
//   D6 connects to digital pin 6
//   D7 connects to digital pin 7
// For the Arduino Mega, use digital pins 22 through 29
// (on the 2-row header at the end of the board).

// For Arduino Uno/Duemilanove, etc
//  connect the SD card with DI going to pin 11, DO going to pin 12 and SCK going to pin 13 (standard)
//  Then pin 10 goes to CS (or whatever you have set up)
#define SD_CS 10     // Set the chip select line to whatever you use (10 doesnt conflict with the library)

// In the SD card, place 24 bit color BMP files (be sure they are 24-bit!)
// There are examples in the sketch folder

// our TFT wiring
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, A4);

void setup()
{
  Serial.begin(9600);

  tft.reset();

  uint16_t identifier = tft.readID();

    if(identifier == 0x9325) {
    Serial.println(F("Found ILI9325 LCD driver"));
  } else if(identifier == 0x9327) {
    Serial.println(F("Found ILI9327 LCD driver"));
  } else if(identifier == 0x9328) {
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if(identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
  } else if(identifier == 0x9341) {
    Serial.println(F("Found ILI9341 LCD driver"));
  } else if(identifier == 0x8357) {
    Serial.println(F("Found HX8357D LCD driver"));
  } else if(identifier == 0x0154) {
    Serial.println(F("Found S6D0154 LCD driver"));
  } else if(identifier == 0x9488) {
    Serial.println(F("Found ILI9488 LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
    Serial.println(F("If using the Adafruit 2.8\" TFT Arduino shield, the line:"));
    Serial.println(F("  #define USE_ADAFRUIT_SHIELD_PINOUT"));
    Serial.println(F("should appear in the library header (Adafruit_TFT.h)."));
    Serial.println(F("If using the breakout board, it should NOT be #defined!"));
    Serial.println(F("Also if using the breakout, double-check that all wiring"));
    Serial.println(F("matches the tutorial."));
    return;
  }

  tft.begin(identifier);

  Serial.print(F("Initializing SD card..."));
  if (!SD.begin(SD_CS)) {
    Serial.println(F("failed!"));
    return;
  }
  Serial.println(F("OK!"));

  bmpDraw("inca01.bmp", 0, 0);
  delay(5000);
    bmpDraw("inca02.bmp", 0, 0);
  delay(5000);
}

void loop()
{
 
}

bmpincabon.ino (3.44 KB)

Le code qui fonctionne mais qui affiche des images qui se décalent:

bmpincabon.ino.ino (9.1 KB)

C'est étonnant que l'un fonctionne et pas l'autre, je pense qu'aucun ne devrait fonctionner.
En effet chacun des deux codes appelle la fonction bmpDraw qui n'est pas définie. Cette fonction se trouve dans l'exemple appelé 'tftbmp' de la bibliothèque TFTLCD. Il faut donc que tu utilises cette fonction : copie à partir de l'exemple 'tftbmp' (lien ci-dessus) dans ton code les lignes qui se trouvent après la loop. C'est à dire à partir de :

// 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, int x, int y) {

  File     bmpFile;
  int      bmpWidth, bmpHeight;   // W+H in pixels
...

jusqu'à la fin.

Merci Lesept :wink:
effectivement tu as raison je tronqué le programme juste après la ligne qui affiche l'image alors que l'appel de la fonction BmpDraw se situé apres... j'ai honte^^
Je vient de corriger et ça marche :wink:
Ma prochaine étape ça sera de trouver une solution pour mettre deux encodeurs rotatif (pour selectionner les images ) et une sortie analogique donner une info.
Vu qu'il ne me reste qu'un canal analogique et deux canaux numériques de libre , je crois que je suis mal barré, il va sans doute falloir que je prenne un autre arduino pour décoder les encodeurs et faire communiquer les deux arduino ....

Cool ! Maintenant, étudie le multiplexage...

c'est clair mais je sais pas si c'est faisable avec seulement 2 canaux :soit deux numériques soit un numérique et un analogique (il faut que je m'en réserve un pour pour envoyer une info si j'affiche une image spécifique )
Sinon j'avais pensé utiliser l'analogique pour lire des plages de tension (tout les 0.4Vpar exemple ) et les assigner à des images mais j'ai peur que ça soit source à problème....

Google 'arduino augmenter entrees sorties'

Je reviens vers vous pour vous faire part de mon évolution dans le programme mai aussi pour vous demander de l'aide:
Voila j'ai laissé tomber l'idée des encodeurs qui serait lu par un autre arduino et de faire communiquer les deux ensemble... je voudrais plus partir sur l'idée de changer d'image en appuyant sur des boutons poussoir...
le Hic ben c'est que j'y arrive pas loool
L'ecran tft me laisse que trois cannaux de libre TX et RX et A5
A5 je voudrais le garder pour l'utiliser en sorti et je voudrais utiliser TX et RX pour lire l’état des boutons poussoirs et la est ma question : es-ce que je peux faire ça??

voici mon code

incabmpbp01.ino (9.67 KB)

A priori TX et RX sont des broches qui servent pour la liaison série avec le PC : si tu les utilises pour autre chose, il faudra les débrancher lors du téléversement du code et tu ne pourras pas utiliser la console (en tout cas, c’est ma compréhension de ces broches).

Ton code :

void loop()
{
  etat_bp = digitalRead(bp_bmp);
  if ((etat_bp != memoire) && (etat_bp == HIGH))
  {
    nb_bmp++;
  }
  memoire = etat_bp;

  if (nb_bmp > 8)
  {
    nb_bmp = 0;
  }

  affiche(nb_bmp);
}

Ce que je comprends, c’est que tu veux incrémenter le compteur d’image à chaque appui sur le bouton poussoir. Il faudrait savoir comment il est branché pull-up ou pull-down.

Pull down
En pull down, si le BP est appuyé, on lit HIGH.

Pull up
En pull up, si le BP est appuyé on lit LOW.

Supposons un pull down : ceci devrait suffire

void loop()
{
  etat_bp = digitalRead(bp_bmp);
  if (etat_bp == HIGH)
  {
    nb_bmp = (nb_nmp+1)%9;
  }
  affiche(nb_bmp);
  delay(30);
}

Le “%9” calcule le reste de la division par 9. Si on passe à 9 on revient à 0.

J’ai enlevé le test avec ‘memoire’ que je ne comprends pas.

Encore merci Lesept,
je crois qu'au final je vais te devoir une sacré chandelle...
Effectivement je suis parti sur du pull down :slight_smile:
Je crois que j'ai eu chaud en essayant mon code avec ma carte Uno relié au pc, j’aurais pu me flamber mon usb ou mon arduino...
Je vais essayer ton bout de code, il me parait bien plus simple, je te teins au jus ;D
Petite question con, a quoi sert le delay(30); ??

C'est pour éviter les rebonds du BP. Il y a d'autres méthodes, peut-être le 30 n'est pas assez grand : à tester !

j’ai testé le code mais c’est bizarre les images font que changer comme si il y avait un signal parasite.
voici le looop :

void loop()
{
  etat_bp = digitalRead(bp_bmp);
  if (etat_bp == HIGH)
  {
    nb_bmp = (nb_bmp+1)%9;
  }
  if(nb_bmp >= 1)
  {
bmpDraw("inca01.bmp", 0, 0);
  }
  if(nb_bmp >= 2)
  {
bmpDraw("inca02.bmp", 0, 0);
  }
  if(nb_bmp >= 3)
  {
bmpDraw("inca03.bmp", 0, 0);
  }
 
  delay(30);
}

je me demande si c’est finalement possible d’utiliser TX et RX comme entrée pour lire un état…
pour initialiser ces deux canal en entrée j’ai ecrit :

const int bp_bmp = 0;
const int bp_color = 1;

et dans le setup :

pinMode(bp_bmp, INPUT);
pinMode(bp_color, INPUT);

je fait pas d’erreur la??

C’est tes tests qui ne sont pas bons. Regarde : si nb_bmp vaut 3, le premier test sera OK et affichera l’image inca01. Ensuite, le second test sera OK aussi et affichera l’image inca02 et idem pour le troisième test.
Change les >= par des ==

oups j'ai honte...
par contre je viens de modifier le code et j'ai toujours le même résultat :frowning:

Essaye de brancher les boutons sur d'autres broches que les 0 et 1. Elles sont utilisées par la liaison série (donc la console) avec le PC.

Sinon, peux-tu expliquer plus précisément "c'est bizarre les images font que changer comme si il y avait un signal parasite" ?