Image sequence programming

Hey everyone,

I have a sketch I’m working on using a number of bitmaps that will play in particular sequences to display an pseudo-animation.

I’ll preface this by saying that I’m fairly new to arduino, but that I’ve done quite a bit of research to get to this point. I’m planning to have an intro sequence, which when the button is pressed, shuffles between several bitmaps until it selects one at random and plays the corresponding sequence to that bitmap. I believe I have the code all sorted expect I can’t figure out how to stop the two starting images from looping and to wait for the user input to continue. After researching online, I’ve considered and tried many options, some I’m not sure how to do, but they range from moving code to the setup, while(), millis(), etc.

Any explanations on what the problem is, and possible solutions would be incredibly helpful!

I’ve also considered using progmem to upload to flash so that I don’t have to compromise on the number of images due to the RAM currently crashing. Could this be an option for this sketch or do the bitmaps need to be converted into data arrays for it to work?

Thanks so much!

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1351.h>
#include <SD.h>
#include <SPI.h>

#define sclk 13
#define mosi 11
#define cs   10
#define rst  9
#define dc   8
#define SD_CS 4 

#define	BLACK           0x0000
#define	BLUE            0x001F
#define	RED             0xF800
#define	GREEN           0x07E0
#define CYAN            0x07FF
#define MAGENTA         0xF81F
#define YELLOW          0xFFE0  
#define WHITE           0xFFFF

Adafruit_SSD1351 tft = Adafruit_SSD1351(cs, dc, rst);

File bmpFile;

const int buttonPin = 2;

int bmpWidth, bmpHeight;
uint8_t bmpDepth, bmpImageoffset;

char* introImage [] = {"02.bmp", "03.bmp", "04.bmp"};
char* alienImage [] = {"05.bmp", "06.bmp", "07.bmp", "08.bmp", "09.bmp", "10.bmp", "11.bmp"};

void setup(void) {
  Serial.begin(9600);
  
  pinMode(cs, OUTPUT);
  digitalWrite(cs, HIGH);   
  pinMode(buttonPin, INPUT);
  digitalWrite(buttonPin, HIGH);
  
 
  tft.begin();

  Serial.println("init");
  
  tft.fillScreen(BLACK);
  
  delay(500);
  Serial.print("Initializing SD card...");

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

}

void loop() {

  
    bmpDraw("00.bmp", 16, 0);
    delay(3000);  
    bmpDraw("01.bmp", 16, 0);
    delay(0);
    
  int buttonState = 0;
  buttonState = digitalRead(buttonPin);
  if (buttonState ==LOW) {
      
      for (int introNum = 0; introNum < 3; introNum++){
        bmpDraw(introImage[introNum], 16, 0);
        delay(500);
      }
      
      for (int imgNum = 0; imgNum < 7; imgNum++){
        bmpDraw(alienImage[imgNum], 39, 11);
        delay(500);
      }
      
      int imgNum = random(0,6);
        bmpDraw(alienImage[imgNum], 39, 11);
      
      switch (imgNum) {
      case 0:    // 05.bmp
        bmpDraw("12.bmp", 16, 0);
        break;
      case 1:    // 06.bmp
        bmpDraw("13.bmp", 16, 0);
        break;
      case 2:    // 07.bmp
        bmpDraw("14.bmp", 16, 0);
        break;
      case 3:    // 08.bmp
        bmpDraw("15.bmp", 16, 0);
        break;
      case 4:    // 09.bmp
        bmpDraw("16.bmp", 16, 0);
        break;
      case 5:    // 10.bmp
        bmpDraw("17.bmp", 16, 0);
        break;
      case 6:    // 11.bmp
        bmpDraw("18.bmp", 16, 0);
        break;
       }
    delay(1);        // delay in between reads for stability

  }
} 

#define BUFFPIXEL 20

  

void bmpDraw(char *filename, uint8_t x, uint8_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("Loading image '");
  Serial.print(filename);
  Serial.println('\'');

  // Open requested file on SD card
  if ((bmpFile = SD.open(filename)) == NULL) {
    Serial.print("File not found");
    return;
  }

  // Parse BMP header
  if(read16(bmpFile) == 0x4D42) { // BMP signature
    Serial.print("File size: "); Serial.println(read32(bmpFile));
    (void)read32(bmpFile); // Read & ignore creator bytes
    bmpImageoffset = read32(bmpFile); // Start of image data
    Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
    // Read DIB header
    Serial.print("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("Bit Depth: "); Serial.println(bmpDepth);
      if((bmpDepth == 24) && (read32(bmpFile) == 0)) { // 0 = uncompressed

        goodBmp = true; // Supported BMP format -- proceed!
        Serial.print("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;



        // 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;

        for (row=0; row<h; row++) { // For each scanline...
          tft.goTo(x, y+row);

          // 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
          }

          // optimize by setting pins now
          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++];

            tft.drawPixel(x+col, y+row, tft.Color565(r,g,b));
            // optimized!
            //tft.pushColor(tft.Color565(r,g,b));
          } // end pixel
        } // end scanline
        Serial.print("Loaded in ");
        Serial.print(millis() - startTime);
        Serial.println(" ms");
      } // end goodBmp
    }
  }

  bmpFile.close();
  if(!goodBmp) Serial.println("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;
}

Not completely sure I understand your objective (or your code)...

Your intro is 00.bmp and 01.bmp with a 3 second delay between 00 and 01?

Then a delay(0)? Not sure what that accomplishes, maybe something specific to your display.

My suggestion is to add the variable buttonAction - global and equal to to 2.

Put your intro in an if statement

if (buttonAction == 2) {
// intro here
buttonAction = 1;
}
// rest of your main loop code
// only happens when a button is pressed
buttonAction = 2; // play intro again after your other images are displayed

Maybe I don't understand your objective. What arduino are you using? You can try a MEGA or DUE for more memory...