Efficient Pixel Control System without Blink

[JinLuckyboy]

I want Efficient Pixel Control System without Blink.
For example, see following code.

#include <TFT_eSPI.h>
TFT_eSPI tft = TFT_eSPI();

class Sprite : public TFT_eSprite {
  uint16_t* tft_buffer;
  bool buffer_loaded = false;
public:
  TFT_eSPI* _tft;
  Sprite(TFT_eSPI* tft) : TFT_eSprite(tft) {
    _tft = tft;
  }
  
  void drawSprite(int x, int y) {
    background(x, y);
  
    pushSprite(x, y, TFT_TRANSPARENT);
  }

  void background(int x, int y) {
    // Bounding box parameters
    static int16_t min_x;
    static int16_t min_y;
    static int16_t max_x;
    static int16_t max_y;
  
    if (buffer_loaded) {
      // Paste back the original needle free image area
      _tft->pushRect(min_x, min_y, 1 + max_x - min_x, 1 + max_y - min_y, tft_buffer);
//      free(tft_buffer);
    } else {
      // Grab a copy of the area before needle is drawn
      tft_buffer = (uint16_t*) malloc( (width() + 1) * (height() + 1) * 2 );
      buffer_loaded = true;
    }
    
    min_x = x;
    min_y = y;
    max_x = x + width() - 1;
    max_y = y + height() - 1;
    
    _tft->readRect(min_x, min_y, 1 + max_x - min_x, 1 + max_y - min_y, tft_buffer);
  }
};

Sprite spr(&tft);

void setup() {  
  tft.begin();
  tft.setRotation(0);
  tft.fillScreen(TFT_GREEN);
  
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);
  
  spr.createSprite(200, 50);
  spr.setTextColor(TFT_BLACK);
}

int x = 10, y = 10; // sprite location
void loop() {
  spr.fillSprite(TFT_TRANSPARENT);
  spr.setCursor(0, 0);
  spr.print(String(millis()));
  spr.drawSprite(x, y);
}

This code always draw green background on LCD, before draw the sprite.
So, it blink.
Only required pixels should change.

I have simple idea.

int screen[width][height];
int screenPrevious[width][height];
void setPixel(int x, int y, int color) {
  screen[x][y] = color;
}
void draw() {
  for(int x = 0; x < width; ++x) {
    for(int y = 0; y < height; ++y) {
      if(screen[x][y] != screenPrevious[x][y]) {
        tft.drawPixel(x, y, screen[x][y]);
      }
    }
  }
  screenPrevious = screen;
}

[Bodmer]

I think a paged sprite update approach will achieve what you wish to do.

Essentially a small sprite is used and drawn at successive positions down the screen. The whole screen is then drawn in the sprite with an offset as the sprite position moves down the screen. Tricky to explain so here is an example the demonstrates the approach. You will have to analyse the sketch to see how it works.

Paged_Sprite.zip

On my test screen (ILI9488 320x480 pixels) it only takes ~16ms to render the updated area (200 x 320 area as an example only) to the TFT. If you try to read the TFT screen it will be much slower.

[JinLuckyboy]

Thank you! This Approach works well. But when I use a large sprite, TFT_eSprite::pushSprite() doesn't work. My device is ESP32.

#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();
TFT_eSprite screen = TFT_eSprite(&tft);

void setup() {
    Serial.begin(115200);
    
    pinMode(TFT_BL, OUTPUT);
    digitalWrite(TFT_BL, HIGH);
    
    tft.init();
    tft.setRotation(1);
    
    bool error = true;
    
    if(error) screen.createSprite(320, 197);
    else screen.createSprite(320, 196);
    screen.fillSprite(TFT_RED);
    screen.pushSprite(0, 0);
}

void loop() {}

[Bodmer]

The ESP32 does not have enough RAM For such a large sprite unless your board is fitted with PSRAM and you enable it in the IDE. This is fully explained here .