drawPixel for 480x320 BMP image producing vertical white lines

[Christopher9Ernest]

I have 480x320 TFT touch Screen that uses ILI9488 display chip and XPT2046 touchscreen. I have connected it to Arduino mega 2560 and connected it to SD card. I have written a code to read a 480x320 BMP file in the card and display it on the screen using TFT_eSPI library. When I run the code, the image appears on the screen with vertical white lines. How can I remove the vertical lines?
I have supplied the original code and the photo of the display.

Thanks
Chris.

#include <TFT_eSPI.h>
#include <SPI.h>
#include <SD.h>
#include <XPT2046_Touchscreen.h>
#define SD_CS 6 // SD card chip select
#define TS_CS 7 //Touch Screen Chip Select
//TFT chip select no 53

TFT_eSPI tft = TFT_eSPI();
XPT2046_Touchscreen ts(TS_CS);

int tftWidth, tftHeight;

class BitmapHandler
{
private:
bool fileOK = false;
File bmpFile;
String bmpFilename;

uint8_t read8Bit()
{
  if (!this->bmpFile) 
  {
   return 0;
  }
  else 
  {
    return this->bmpFile.read();
  }
}

uint16_t read16Bit()
{
  uint16_t lsb, msb;
  if (!this->bmpFile) 
  {
   return 0;
  }
  else 
  {
    lsb = this->bmpFile.read();
    msb = this->bmpFile.read();
    return (msb<<8) + lsb;
  }
}

uint32_t read32Bit()
{
  uint32_t lsb, b2, b3, msb;
  if (!this->bmpFile) 
  {
   return 0;
  }
  else 
  {
    lsb = this->bmpFile.read();
    b2 = this->bmpFile.read();
    b3 = this->bmpFile.read();
    msb = this->bmpFile.read();
    return (msb<<24) + (b3<<16) + (b2<<8) + lsb;
  }
}

public:

// BMP header fields
uint16_t headerField;
uint32_t fileSize;
uint32_t imageOffset;
// DIB header
uint32_t headerSize;
uint32_t imageWidth;
uint32_t imageHeight;
uint16_t colourPlanes;
uint16_t bitsPerPixel;
uint32_t compression;
uint32_t imageSize;
uint32_t xPixelsPerMeter;
uint32_t yPixelsPerMeter;
uint32_t totalColors;
uint32_t importantColors;

BitmapHandler(String filename)
{
  this->fileOK = false;
  this->bmpFilename = filename;
  this->bmpFile = SD.open(this->bmpFilename, FILE_READ);
  if (!this->bmpFile) 
  {
    Serial.print(F("BitmapHandler : Unable to open file "));
    Serial.println(this->bmpFilename);
    this->fileOK = false;
  }
  else 
  {
    if (!this->readFileHeaders())
    {
      Serial.println(F("Unable to read file headers"));
      this->fileOK = false;
    }
    else 
    {
      if (!this->checkFileHeaders())
      {
        Serial.println(F("Not compatible file"));
        this->fileOK = false;
      }
      else 
      {
        // all OK
        Serial.println(F("BMP file all OK"));
        this->fileOK = true;
      }       
    }
    // close file
    this->bmpFile.close();
  }
}

bool readFileHeaders()
{
  if (this->bmpFile) 
  {
    // reset to start of file
    this->bmpFile.seek(0);
    
    // BMP Header
    this->headerField = this->read16Bit();
    this->fileSize = this->read32Bit();
    this->read16Bit(); // reserved
    this->read16Bit(); // reserved
    this->imageOffset = this->read32Bit();

    // DIB Header
    this->headerSize = this->read32Bit();
    this->imageWidth = this->read32Bit();
    this->imageHeight = this->read32Bit();
    this->colourPlanes = this->read16Bit();
    this->bitsPerPixel = this->read16Bit();
    this->compression = this->read32Bit();
    this->imageSize = this->read32Bit();
    this->xPixelsPerMeter = this->read32Bit();
    this->yPixelsPerMeter = this->read32Bit();
    this->totalColors = this->read32Bit();
    this->importantColors = this->read32Bit();
    tftWidth=this->imageWidth;
    tftHeight=this->imageHeight;

    // close file
    return true;
  }
  else 
  {
    return false;
  }
}

bool checkFileHeaders()
{

  // BMP file id
  if (this->headerField != 0x4D42)
  {
    return false;
  }
  // must be single colour plane
  if (this->colourPlanes != 1)
  {
    return false;
  }
  // only working with 24 bit bitmaps
  if (this->bitsPerPixel != 24)
  {
    return false;
  }
  // no compression
  if (this->compression != 0)
  {
    return false;
  }
  // all ok
  return true;
}

void serialPrintHeaders() 
{
  Serial.print(F("filename : "));
  Serial.println(this->bmpFilename);
  // BMP Header
  Serial.print(F("headerField : "));
  Serial.println(this->headerField, HEX);
  Serial.print(F("fileSize : "));
  Serial.println(this->fileSize);
  Serial.print(F("imageOffset : "));
  Serial.println(this->imageOffset);
  Serial.print(F("headerSize : "));
  Serial.println(this->headerSize);
  Serial.print(F("imageWidth : "));
  Serial.println(this->imageWidth);      
  Serial.print(F("imageHeight : "));
  Serial.println(this->imageHeight);      
  Serial.print(F("colourPlanes : "));
  Serial.println(this->colourPlanes);
  Serial.print(F("bitsPerPixel : "));
  Serial.println(this->bitsPerPixel);
  Serial.print(F("compression : "));
  Serial.println(this->compression);
  Serial.print(F("imageSize : "));
  Serial.println(this->imageSize);
  Serial.print(F("xPixelsPerMeter : "));
  Serial.println(this->xPixelsPerMeter);
  Serial.print(F("yPixelsPerMeter : "));
  Serial.println(this->yPixelsPerMeter);
  Serial.print(F("totalColors : "));
  Serial.println(this->totalColors);
  Serial.print(F("importantColors : "));
  Serial.println(this->importantColors);
}

void renderImage(TFT_eSPI screen, int screenX, int screenY)
{
 digitalWrite(53,HIGH); //Deselect TFT
 digitalWrite(TS_CS,HIGH); //Deselect TFT
 digitalWrite(SD_CS, LOW); //select SD

  // read from sd card in blocks
  uint8_t pixelBuffer[3 * 80];
  uint8_t pixelBufferCounter = sizeof(pixelBuffer);
  
  int bytesPerRow;
  int displayedWidth, displayedHeight;
  int pixelRow, pixelCol;
  uint32_t pixelRowFileOffset;
  uint8_t r,g,b;

  // check if file OK
  if (!this->fileOK) 
  {
    return false;
  }

  // make sure screenX, screenY is on screen
  if((screenX < 0) || (screenX >= tftWidth) 
    || (screenY < 0) || (screenY >= tftHeight))
  {
    return false;
  }

  // get dimensions of displayed image - crop if needed
  displayedWidth = this->imageWidth;
  displayedHeight = this->imageHeight;
  if (displayedWidth > (tftWidth - screenX))
  {
    displayedWidth = tftWidth - screenX;
  }
  if (displayedHeight > (tftHeight - screenY))
  {
    displayedHeight = tftHeight - screenY;
  }

  // bytes per row rounded up to next 4 byte boundary
  bytesPerRow = (3 * this->imageWidth) + ((4 - ((3 * this->imageWidth) % 4)) % 4);

  // open file
  this->bmpFile = SD.open(this->bmpFilename, FILE_READ);

  Serial.print(F("screenX : "));
  Serial.println(screenX);
  Serial.print(F("screenY : "));
  Serial.println(screenY);
  Serial.print(F("displayedWidth : "));
  Serial.println(displayedWidth);
  Serial.print(F("displayedHeight : "));
  Serial.println(displayedHeight);
  // set up tft byte write area
  digitalWrite(TS_CS,HIGH); //Deselect Touch Screen
  digitalWrite(53,LOW); //Select TFT
  digitalWrite(SD_CS, HIGH); //Deselect SD

  screen.setAddrWindow(screenX, screenY, displayedWidth, displayedHeight);

  for (pixelRow = 0; pixelRow < displayedHeight; pixelRow ++) 
  {
    // image stored bottom to top, screen top to bottom
    pixelRowFileOffset = this->imageOffset + ((this->imageHeight - pixelRow -1) * bytesPerRow);

    // move file pointer to start of row pixel data
    // turn off pixel stream while acxcessing sd card
    digitalWrite(TS_CS,HIGH); //Deselect Touch Screen
    digitalWrite(53,HIGH); //Deselect TFT
    digitalWrite(SD_CS, LOW); //select SD

    this->bmpFile.seek(pixelRowFileOffset);

              // reset buffer
    pixelBufferCounter = sizeof(pixelBuffer);

    // output pixels in row
    for (pixelCol = 0; pixelCol < displayedWidth; pixelCol ++) 
    {

      if (pixelBufferCounter >= sizeof(pixelBuffer))
      {
        // need to read more from sd card
     //turn of pixel stream while acxcessing sd card
        digitalWrite(TS_CS,HIGH); //Deselect Touch Screen
        digitalWrite(53,HIGH); //Deselect TFT
        digitalWrite(SD_CS, LOW); //select SD

        this->bmpFile.read(pixelBuffer, sizeof(pixelBuffer));
        pixelBufferCounter = 0;
    
      }

    // get next pixel colours
    b = pixelBuffer[pixelBufferCounter++];
    g = pixelBuffer[pixelBufferCounter++];
    r = pixelBuffer[pixelBufferCounter++];

    digitalWrite(TS_CS,HIGH); //Deselect Touch Screem
    digitalWrite(53,LOW); //Select TFT
    digitalWrite(SD_CS, HIGH); //Deselect SD

    // send pixel to tft
    screen.drawPixel(pixelCol,pixelRow,screen.color565(r,g,b));

    } // pixelCol
    
  } // pixelRow
 // turn off pixel stream
 digitalWrite(TS_CS,HIGH); //Deselect TFT
 digitalWrite(53,HIGH); //Deselect TFT
 digitalWrite(SD_CS, LOW); //select SD
 this->bmpFile.close();
}

};

void setup()
{
// put your setup code here, to run once:
Serial.begin(115200);
while (!Serial) delay(10);

// TFT init

tft.init();
tft.setRotation(3); // 480x320 landscape
tft.fillScreen(TFT_BLACK);
tft.setTextColor(TFT_WHITE);
tft.setTextSize(2);
tft.drawString("BMP Test", 20, 20);

ts.begin();
ts.setRotation(3);

if(!SD.begin(SD_CS))
{
Serial.println("SD Card Initialization Failed!!");
while(true)
{
;
}
}
else
{
Serial.println("SD Card OK!!");
}
BitmapHandler bmh = BitmapHandler("480x320.bmp");
bmh.serialPrintHeaders();
bmh.renderImage(tft, 0, 0);
}

void loop()
{
// put your main code here, to run repeatedly:

}

SD_Card_Image_Code.docx
OriginalImage.bmp