Reading a .hex file from an SDcard and displaying it on screen TFT , and ESP32

[davidmonterocrespo24]

You can read a BPM file that was on a sdcard and display it on a TFT screen with an esp32. I could notice that it is somewhat slow and takes about 4 or 6 seconds to finish. However, the same photo converted to hexadecimal and put into an array is displayed on the screen in less than a second.

How to read a hex file of a photo on the SD card, and convert it to an array to be able to render it on the TFT screen with an esp32?

Something like this
`
#include <Adafruit_ST7735.h>
#include <SD.h>

// Declare the TFT object
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

// Declare the image array
uint8_t image[100000];

void setup() {
tft.begin(); // Initialize the TFT
SD.begin(SD_CS);
File myFile = SD.open("imagen.hex", FILE_READ);
if (myFile) {
int i = 0;
while (myFile.available()) {
image[i] = myFile.read();
i++;
}
myFile.close();
}
}

void loop() {
tft.pushImage(0, 0, 128, 128, image); // Display the image at position (0, 0) //with a size of 128x128
}
`

[davidmonterocrespo24]

The problem is because I want to make an animation with several images and the reading of the image is very slow. Could the PSram of the esp32 be used? How can it be used?
Something like this

` // Open BMP file from SD card
File bmpFile = SD.open("/image.bmp");

// Read data from the BMP file and store it in a buffer in PSRAM memory
uint32_t filesize = bmpFile.size();
uint8_t* buffer = (uint8_t*)ps_malloc(filesize);
bmpFile.read(buffer, filesize);

// Display the image on the TFT screen
tft.pushImage(0, 0, tft.width(), tft.height(), buffer);

// Close the file and free the PSRAM memory
bmpFile.close();
ps_free(buffer);`

[mcbp223]

Hi, what board, display and wiring do you have?

Depending on this you can estimate how many full-screen images you can fit in memory. In your case and if using 16 bits per pixel as in RGB565, one frame, excluding the BMP header would require 320 x 240 x 2 = 153600 bytes = 150kB. An ESP32 with 520kB of SRAM would fit three frames in theory and have 70kB remaining, but in practice two and leave more RAM for the program and wifi tasks.
If you have PSRAM you can load more frames, it's not as fast as processor SRAM, but not as slow as SD card access either.
You can use this library to store images in memory in an array of sprites, the class TFT_eSprite checks if PSRAM is available and allocates memory from it if possible. Here is an example of pre-allocation:

#include <TFT_eSPI.h>
#include <vector>

TFT_eSPI tft;

std::vector<std::shared_ptr<TFT_eSprite>> sprites;

#define DWIDTH  320
#define DHEIGHT 240
#define MAX_NUM_FRAMES_TO_TRY 16

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

  tft.init();

  for(unsigned i = 0; i < MAX_NUM_FRAMES_TO_TRY; i++) {
    std::shared_ptr<TFT_eSprite> sptr(new TFT_eSprite(&tft));
    if(sptr->createSprite(DWIDTH, DHEIGHT) != nullptr)
      Serial.printf("Successfully allocated memory for sprite[%d]\r\n", i);
    else
      break;
    
    sprites.push_back(sptr);
  }

}

Then you can use the sprites vector in a circular buffer manner, load as many frames as you can from the SD card before starting pushing them to the display. (I have tested the limits and after a certain number of sprites created the display is black, even if the allocation was successful, so try with small numbers first).

Note that for some boards there is a missing define in ESP-IDF for CONFIG_SPIRAM_SUPPORT that TFT_eSprite uses to determine availability. You can check for this issue by adding a test in the sketch:

#if defined(BOARD_HAS_PSRAM)
  #ifndef CONFIG_SPIRAM_SUPPORT
    #warning "BOARD_HAS_PSRAM defined but CONFIG_SPIRAM_SUPPORT not defined"
  #elif !CONFIG_SPIRAM_SUPPORT
    #warning "BOARD_HAS_PSRAM defined but CONFIG_SPIRAM_SUPPORT is 0"
  #endif
#else
  #warning "BOARD_HAS_PSRAM not defined"
#endif

If you get one of those warnings, currently TFT_eSprite will not allocate from PSRAM, you'd have to manage allocation yourself.

How to read a hex file of a photo on the SD card, and convert it to an array to be able to render it on the TFT screen with an esp32?

The HEX is a C source code that gets compiled in a memory array and stored in flash along with your program, it's not an image format.

[davidmonterocrespo24]

How can I load a BPM image that is stored on an sdcard into a TFT_eSprite object?

I don't want to use an array for the images, I want to see the possibility of loading several dynamic images from an sdcard

I try to make a robot with animated eyes with various expressions. I would create several folders to store the emotions and each folder would have about three images for the animation of the expression

I am using an esp32 wroom and a TFT ILI9486 screen

[mcbp223]

The WROOM modules don't have PSRAM, you would need to use the WROVER module if it's ESP32, or better yet go for an ESP32S3, look for the variant with 8MB PSRAM if you need to preload many frames, chip ESP32-S3R8, or module with N8R8 suffix or N16R8, where N16 stands for 16MB flash and R8 for 8MB PSRAM.

I don't have a quick example for loading a BMP into sprite, but in the generic examples from this library you can get an idea from ESP32_SDcard_jpeg, it opens the SD card just like you did, but loads and interprets a JPEG instead, and for BMP reading TFT_SPIFFS_BMP.
To draw the BMP into a sprite instead of display, replace the tft reference with the sprite you want to load into, like sprite.pushImage(x,y, w,h, buffer);
Given the speed of the SD card access, it may be advantageous to use JPEG instead of BMP, since they're smaller and would make the loading faster. But once decompressed in the Sprite memory the size is going to be the same. In your case, without PSRAM you can keep only one full screen frame in RAM, the size is 320 x 480 x 2 = 307200 = 300kB, not enough space for even 2 sprites in an ESP32 with 520kB.