Revision 12:1cf4e83eb240, committed 2023-10-24

Comitter:

info@bausano.net

Date:

Tue Oct 24 23:32:54 2023 +0200

Parent:

11:f94024581a44

Commit message:

Added compatibility with parallel interface TFT

Changed in this revision

--- a/SPI_TFT_ILI9341.cpp	Wed May 26 18:42:58 2021 +0000
+++ b/SPI_TFT_ILI9341.cpp	Tue Oct 24 23:32:54 2023 +0200
@@ -18,20 +18,90 @@
 #include "SPI_TFT_ILI9341.h"
 #include "mbed.h"
 
-#define BPP         16                  // Bits per pixel    
-            
+
+//#ifdef PARA_TFT      
+    SPI_TFT_ILI9341::SPI_TFT_ILI9341(PinName TFT_D0, PinName TFT_D1, PinName TFT_D2, PinName TFT_D3,
+    PinName TFT_D4, PinName TFT_D5, PinName TFT_D6, PinName TFT_D7, PinName rd, PinName wr,
+    PinName cs, PinName dc, PinName res, const char *name) : GraphicsDisplay(name), _cs(cs), _dc(dc),
+    _TFT_D0(TFT_D0),
+    _TFT_D1(TFT_D1),
+    _TFT_D2(TFT_D2),
+    _TFT_D3(TFT_D3),
+    _TFT_D4(TFT_D4),
+    _TFT_D5(TFT_D5),
+    _TFT_D6(TFT_D6),
+    _TFT_D7(TFT_D7),
+    _rd(rd),
+    _wr(wr),
+    _res(res),
+    _spi(D11, D12, D13)
+{
+    iTypeTFT = PARA_TFT_;
+
+    if(strcmp(name, "PARA") == 0)
+    {
+        iTypeTFT = PARA_TFT_; 
+    }
+
+    orientation = 1;
+    char_x = 0;
+    char_x = 0;
 
-//extern Serial pc;
-//extern DigitalOut xx;     // debug !!
+    _TFT_D0 = 1;
+    _TFT_D1 = 1;
+    _TFT_D2 = 1;
+    _TFT_D3 = 1;
+    _TFT_D4 = 1;
+    _TFT_D5 = 1;
+    _TFT_D6 = 1;
+    _TFT_D7 = 1;  
+
+    _rd = 1;
+    _wr = 1; 
+    _cs = 1;
+    _dc = 1;      
+    _res = 1; 
+
+    tft_reset(0);
+}
 
+//#else
 SPI_TFT_ILI9341::SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset, PinName dc, int spiSpeed, const char *name)
-    : GraphicsDisplay(name), _spi(mosi, miso, sclk), _cs(cs), _dc(dc)
+    : GraphicsDisplay(name), _spi(mosi, miso, sclk), _cs(cs), _dc(dc),
+    _TFT_D0(NC),
+    _TFT_D1(NC),
+    _TFT_D2(NC),
+    _TFT_D3(NC),
+    _TFT_D4(NC),
+    _TFT_D5(NC),
+    _TFT_D6(NC),
+    _TFT_D7(NC),
+    _rd(NC),
+    _wr(NC),
+    _res(NC)
 {
+    if(strcmp(name, "SEEED") == 0)
+    {
+        iTypeTFT = SEEED_TFT_; 
+    }
+
+    if(strcmp(name, "ADA") == 0)
+    {
+        iTypeTFT = ADA_TFT_; 
+    }
+
     orientation = 0;
     char_x = 0;
+    char_x = 0;
+
+    _cs = 1;
+    _dc = 1;
+
     _reset = reset;
     tft_reset(spiSpeed);
 }
+//#endif
+
 
 int SPI_TFT_ILI9341::width()
 {
@@ -50,19 +120,20 @@
 void SPI_TFT_ILI9341::set_orientation(unsigned int o)
 {
     orientation = o;
-    wr_cmd(0x36);                     // MEMORY_ACCESS_CONTROL
-    switch (orientation) {
+    wr_cmd(0x36);                               // memory acces control             
+    switch (orientation) 
+    {
         case 0:
-            _spi.write(0x48);
+            wr_dat(0x48);
             break;
         case 1:
-            _spi.write(0x28);
+            wr_dat(0x28);
             break;
         case 2:
-            _spi.write(0x88);
+            wr_dat(0x88);
             break;
         case 3:
-            _spi.write(0xE8);
+            wr_dat(0xE8);
             break;
     }
     _cs = 1; 
@@ -70,179 +141,208 @@
 } 
 
 
-// write command to tft register
-
-void SPI_TFT_ILI9341::wr_cmd(unsigned char cmd)
+void SPI_TFT_ILI9341::wr_cmd(unsigned char cmd)         // write command to tft register
 {
     _dc = 0;
     _cs = 0;
-    _spi.write(cmd);      // mbed lib
+    wr_dat(cmd);   
     _dc = 1;
 }
 
 
-
 void SPI_TFT_ILI9341::wr_dat(unsigned char dat)
 {
-   _spi.write(dat);      // mbed lib
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    {
+        if (dat & 0x01)
+            _TFT_D0 = 1;
+        else
+            _TFT_D0 = 0;  
+
+        if (dat & 0x02)
+            _TFT_D1 = 1;
+        else
+            _TFT_D1 = 0;
+
+        if (dat & 0x04)
+            _TFT_D2 = 1;
+        else
+            _TFT_D2 = 0;
+
+        if (dat & 0x08)
+            _TFT_D3 = 1;
+        else
+            _TFT_D3 = 0;
+
+        if (dat & 0x10)
+            _TFT_D4 = 1;
+        else
+            _TFT_D4 = 0;
+
+        if (dat & 0x20)
+            _TFT_D5 = 1;
+        else
+            _TFT_D5 = 0; 
+
+        if (dat & 0x40)
+            _TFT_D6 = 1;
+        else
+            _TFT_D6 = 0;
+
+        if (dat & 0x80)
+            _TFT_D7 = 1;
+        else
+            _TFT_D7 = 0;
+
+        _wr = 0;
+        _wr = 1;
+    }
+    else
+    {
+        _spi.write(dat);                            // mbed lib
+    }
+
 }
 
 
-
-// the ILI9341 can read - has to be implemented later
-// A read will return 0 at the moment
-
-//unsigned short SPI_TFT_ILI9341::rd_dat (void)
-//{
-//    unsigned short val = 0;
-
-    //val = _spi.write(0x73ff);                /* Dummy read 1           */
-    //val   = _spi.write(0x0000);              /* Read D8..D15           */
-//    return (val);
-//}
-
-
-
-// Init code based on MI0283QT datasheet
-
-void SPI_TFT_ILI9341::tft_reset(int spiSpeed)
+void SPI_TFT_ILI9341::tft_reset(int spiSpeed)       // Init TFT
 {
-    _spi.format(8,0);                  // 8 bit spi mode 0
-    _spi.frequency(spiSpeed);          // SPI clock
-    _cs = 1;                           // cs high
-    _dc = 1;                           // dc high 
-    if (_reset != NC)
-    {
-        DigitalOut rst(_reset);
-        rst = 0;                       // display reset
-        wait_us(50);
-        rst = 1;                       // end hardware reset
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    {  
+        _res = 0;                           // display hw reset
+        wait_us(50);                        //
+        _res = 1;                           //
     }
-    #if (MBED_MAJOR_VERSION != 2)
-        ThisThread::sleep_for(5ms);
-    #else
-        wait_ms(5);        
-    #endif    
-     
-    wr_cmd(0x01);                     // SW reset 
-    
-    #if (MBED_MAJOR_VERSION != 2)
-        ThisThread::sleep_for(5ms);
-    #else
-        wait_ms(5);        
-    #endif        
-    
-    wr_cmd(0x28);                     // display off  
+    else
+    {
+        _spi.format(8,0);                   // 8 bit spi mode 0
+        _spi.frequency(spiSpeed);           // SPI clock    
+        if (_reset != NC)
+        {
+            DigitalOut _res(_reset);
+            _res = 0;                       // display hw reset
+            wait_us(50);
+            _res = 1;                       //
+        }
+    }
+
+    ThisThread::sleep_for(5ms); 
+    wr_cmd(0x01);                           // SW reset 
+    ThisThread::sleep_for(5ms);
+    wr_cmd(0x28);                           // display off  
 
     /* Start Initial Sequence ----------------------------------------------------*/
      wr_cmd(0xCF);                     
-     _spi.write(0x00);
-     _spi.write(0x83);
-     _spi.write(0x30);
+     wr_dat(0x00);
+     wr_dat(0x83);
+     wr_dat(0x30);
      _cs = 1;
      
      wr_cmd(0xED);                     
-     _spi.write(0x64);
-     _spi.write(0x03);
-     _spi.write(0x12);
-     _spi.write(0x81);
+     wr_dat(0x64);
+     wr_dat(0x03);
+     wr_dat(0x12);
+     wr_dat(0x81);
      _cs = 1;
      
      wr_cmd(0xE8);                     
-     _spi.write(0x85);
-     _spi.write(0x01);
-     _spi.write(0x79);
+     wr_dat(0x85);
+     wr_dat(0x01);
+     wr_dat(0x79);
      _cs = 1;
      
      wr_cmd(0xCB);                     
-     _spi.write(0x39);
-     _spi.write(0x2C);
-     _spi.write(0x00);
-     _spi.write(0x34);
-     _spi.write(0x02);
+     wr_dat(0x39);
+     wr_dat(0x2C);
+     wr_dat(0x00);
+     wr_dat(0x34);
+     wr_dat(0x02);
      _cs = 1;
            
      wr_cmd(0xF7);                     
-     _spi.write(0x20);
+     wr_dat(0x20);
      _cs = 1;
            
      wr_cmd(0xEA);                     
-     _spi.write(0x00);
-     _spi.write(0x00);
+     wr_dat(0x00);
+     wr_dat(0x00);
      _cs = 1;
      
      wr_cmd(0xC0);                     // POWER_CONTROL_1
-     _spi.write(0x26);
+     wr_dat(0x26);
      _cs = 1;
  
      wr_cmd(0xC1);                     // POWER_CONTROL_2
-     _spi.write(0x11);
+     wr_dat(0x11);
      _cs = 1;
      
      wr_cmd(0xC5);                     // VCOM_CONTROL_1
-     _spi.write(0x35);
-     _spi.write(0x3E);
+     wr_dat(0x35);
+     wr_dat(0x3E);
      _cs = 1;
      
      wr_cmd(0xC7);                     // VCOM_CONTROL_2
-     _spi.write(0xBE);
+     wr_dat(0xBE);
      _cs = 1; 
      
      wr_cmd(0x36);                     // MEMORY_ACCESS_CONTROL
-     _spi.write(0x48);
+     wr_dat(0x48);
+
+     wr_dat(0xC8);
+
      _cs = 1; 
      
      wr_cmd(0x3A);                     // COLMOD_PIXEL_FORMAT_SET
-     _spi.write(0x55);                 // 16 bit pixel 
+     wr_dat(0x55);                      // 16 bit pixel 
      _cs = 1;
      
      wr_cmd(0xB1);                     // Frame Rate
-     _spi.write(0x00);
-     _spi.write(0x1B);               
+     wr_dat(0x00);
+     wr_dat(0x1B);               
      _cs = 1;
      
      wr_cmd(0xF2);                     // Gamma Function Disable
-     _spi.write(0x08);
+     wr_dat(0x08);
      _cs = 1; 
      
      wr_cmd(0x26);                     
-     _spi.write(0x01);                 // gamma set for curve 01/2/04/08
+     wr_dat(0x01);                 // gamma set for curve 01/2/04/08
      _cs = 1; 
      
      wr_cmd(0xE0);                     // positive gamma correction
-     _spi.write(0x1F); 
-     _spi.write(0x1A); 
-     _spi.write(0x18); 
-     _spi.write(0x0A); 
-     _spi.write(0x0F); 
-     _spi.write(0x06); 
-     _spi.write(0x45); 
-     _spi.write(0x87); 
-     _spi.write(0x32); 
-     _spi.write(0x0A); 
-     _spi.write(0x07); 
-     _spi.write(0x02); 
-     _spi.write(0x07);
-     _spi.write(0x05); 
-     _spi.write(0x00);
+     wr_dat(0x1F); 
+     wr_dat(0x1A); 
+     wr_dat(0x18); 
+     wr_dat(0x0A); 
+     wr_dat(0x0F); 
+     wr_dat(0x06); 
+     wr_dat(0x45); 
+     wr_dat(0x87); 
+     wr_dat(0x32); 
+     wr_dat(0x0A); 
+     wr_dat(0x07); 
+     wr_dat(0x02); 
+     wr_dat(0x07);
+     wr_dat(0x05); 
+     wr_dat(0x00);
      _cs = 1;
      
      wr_cmd(0xE1);                     // negativ gamma correction
-     _spi.write(0x00); 
-     _spi.write(0x25); 
-     _spi.write(0x27); 
-     _spi.write(0x05); 
-     _spi.write(0x10); 
-     _spi.write(0x09); 
-     _spi.write(0x3A); 
-     _spi.write(0x78); 
-     _spi.write(0x4D); 
-     _spi.write(0x05); 
-     _spi.write(0x18); 
-     _spi.write(0x0D); 
-     _spi.write(0x38);
-     _spi.write(0x3A); 
-     _spi.write(0x1F);
+     wr_dat(0x00); 
+     wr_dat(0x25); 
+     wr_dat(0x27); 
+     wr_dat(0x05); 
+     wr_dat(0x10); 
+     wr_dat(0x09); 
+     wr_dat(0x3A); 
+     wr_dat(0x78); 
+     wr_dat(0x4D); 
+     wr_dat(0x05); 
+     wr_dat(0x18); 
+     wr_dat(0x0D); 
+     wr_dat(0x38);
+     wr_dat(0x3A); 
+     wr_dat(0x1F);
      _cs = 1;
      
      WindowMax ();
@@ -254,55 +354,55 @@
      //_cs = 1;
       
      wr_cmd(0xB7);                       // entry mode
-     _spi.write(0x07);
+     wr_dat(0x07);
      _cs = 1;
      
      wr_cmd(0xB6);                       // display function control
-     _spi.write(0x0A);
-     _spi.write(0x82);
-     _spi.write(0x27);
-     _spi.write(0x00);
+     wr_dat(0x0A);
+     wr_dat(0x82);
+     wr_dat(0x27);
+     wr_dat(0x00);
      _cs = 1;
      
      wr_cmd(0x11);                     // sleep out
      _cs = 1;
      
-    #if (MBED_MAJOR_VERSION != 2)
-        ThisThread::sleep_for(100ms);
-    #else
-        wait_ms(100);        
-    #endif         
+    ThisThread::sleep_for(100ms);
+           
+    wr_cmd(0x29);                     // display on
+    _cs = 1;
      
-     wr_cmd(0x29);                     // display on
-     _cs = 1;
-     
-    #if (MBED_MAJOR_VERSION != 2)
-        ThisThread::sleep_for(100ms);
-    #else
-        wait_ms(100);        
-    #endif     
+    ThisThread::sleep_for(100ms);
  }
 
 
 void SPI_TFT_ILI9341::pixel(int x, int y, int color)
 {
     wr_cmd(0x2A);
-    _spi.write(x >> 8);
-    _spi.write(x);
+    wr_dat(x >> 8);
+    wr_dat(x);
     _cs = 1;
+
     wr_cmd(0x2B);
-    _spi.write(y >> 8);
-    _spi.write(y);
+    wr_dat(y >> 8);
+    wr_dat(y);
     _cs = 1;
-    wr_cmd(0x2C);  // send pixel
-    #if defined TARGET_KL25Z  // 8 Bit SPI
-    _spi.write(color >> 8);
-    _spi.write(color & 0xff);
-    #else 
-    _spi.format(16,0);                              // switch to 16 bit Mode 0
-    _spi.write(color);                              // Write D0..D15
-    _spi.format(8,0);
-    #endif
+
+    wr_cmd(0x2C);                                   // send pixel
+
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    {  
+        wr_dat(color >> 8);
+        wr_dat(color & 0xff);
+    
+    }
+    else
+    {                                       // 16 bit SPI transfer
+        _spi.format(16,0);                              
+        _spi.write(color);                              
+        _spi.format(8,0);                          
+    }
+
     _cs = 1;
 }
 
@@ -310,17 +410,17 @@
 void SPI_TFT_ILI9341::window (unsigned int x, unsigned int y, unsigned int w, unsigned int h)
 {
     wr_cmd(0x2A);
-    _spi.write(x >> 8);
-    _spi.write(x);
-    _spi.write((x+w-1) >> 8);
-    _spi.write(x+w-1);
-    
+    wr_dat(x >> 8);
+    wr_dat(x);
+    wr_dat((x+w-1) >> 8);
+    wr_dat(x+w-1);  
     _cs = 1;
+
     wr_cmd(0x2B);
-    _spi.write(y >> 8);
-    _spi.write(y);
-    _spi.write((y+h-1) >> 8);
-    _spi.write(y+h-1);
+    wr_dat(y >> 8);
+    wr_dat(y);
+    wr_dat((y+h-1) >> 8);
+    wr_dat(y+h-1);
     _cs = 1;
 }
 
@@ -331,26 +431,30 @@
 }
 
 
-
 void SPI_TFT_ILI9341::cls (void)
 {
     int pixel = ( width() * height());
     WindowMax();
-    wr_cmd(0x2C);  // send pixel
-    #if defined TARGET_KL25Z  // 8 Bit SPI
-    unsigned int i;
-    for (i = 0; i < ( width() * height()); i++){
-        _spi.write(_background >> 8);
-        _spi.write(_background & 0xff);
+    wr_cmd(0x2C);                                   // send pixel
+
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    {  
+        unsigned int i;
+        for (i = 0; i < ( width() * height()); i++)
+        {
+            wr_dat(_background >> 8);
+            wr_dat(_background & 0xff);
         }
-    
-    #else 
-    _spi.format(16,0);                            // switch to 16 bit Mode 0
-    unsigned int i;
-    for (i = 0; i < ( width() * height()); i++)
-        _spi.write(_background);
-    _spi.format(8,0);    
-    #endif                         
+    }
+    else   
+    {                                       // 16 bit SPI transfer
+        _spi.format(16,0);                          
+        unsigned int i;
+        for (i = 0; i < ( width() * height()); i++)
+            _spi.write(_background);
+        _spi.format(8,0);    
+    } 
+
     _cs = 1; 
 }
 
@@ -371,7 +475,6 @@
         }
         if (e2 > x) err += ++x*2+1;
     } while (x <= 0);
-
 }
 
 void SPI_TFT_ILI9341::fillcircle(int x0, int y0, int r, int color)
@@ -396,53 +499,68 @@
     w = x1 - x0 + 1;
     window(x0,y,w,1);
     wr_cmd(0x2C);  // send pixel
-    #if defined TARGET_KL25Z  // 8 Bit SPI
-    int j;
-    for (j=0; j<w; j++) {
-        _spi.write(color >> 8);
-        _spi.write(color & 0xff);
+
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    { 
+        int j;
+        for (j=0; j<w; j++) 
+        {
+            wr_dat(color >> 8);
+            wr_dat(color & 0xff);
+        } 
+
+    }
+    else
+    {                                          // 16 bit SPI transfer
+        _spi.format(16,0);                            
+        int j;
+        for (j=0; j<w; j++) 
+        {
+            _spi.write(color);
+        }
+        _spi.format(8,0);
     } 
-    #else 
-    _spi.format(16,0);                            // switch to 16 bit Mode 0
-    int j;
-    for (j=0; j<w; j++) {
-        _spi.write(color);
-    }
-    _spi.format(8,0);
-    #endif
     _cs = 1;
+    
     WindowMax();
     return;
 }
 
+
 void SPI_TFT_ILI9341::vline(int x, int y0, int y1, int color)
 {
     int h;
     h = y1 - y0 + 1;
     window(x,y0,1,h);
     wr_cmd(0x2C);  // send pixel
-    #if defined TARGET_KL25Z  // 8 Bit SPI
-    for (int y=0; y<h; y++) {
-        _spi.write(color >> 8);
-        _spi.write(color & 0xff);
-    } 
-    #else 
-    _spi.format(16,0);                            // switch to 16 bit Mode 0
-    for (int y=0; y<h; y++) {
-        _spi.write(color);
+    
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    { 
+        for (int y=0; y<h; y++) 
+        {
+            wr_dat(color >> 8);
+            wr_dat(color & 0xff);
+        } 
     }
-    _spi.format(8,0);
-    #endif
+    else
+    {                                          // 16 bit SPI transfer
+        _spi.format(16,0);                        
+        for (int y=0; y<h; y++) 
+        {
+            _spi.write(color);
+        }
+        _spi.format(8,0);
+    }
+
     _cs = 1;
+    
     WindowMax();
     return;
 }
 
 
-
 void SPI_TFT_ILI9341::line(int x0, int y0, int x1, int y1, int color)
 {
-    //WindowMax();
     int   dx = 0, dy = 0;
     int   dx_sym = 0, dy_sym = 0;
     int   dx_x2 = 0, dy_x2 = 0;
@@ -451,26 +569,31 @@
     dx = x1-x0;
     dy = y1-y0;
 
-    if (dx == 0) {        /* vertical line */
+    if (dx == 0)                                    // vertical line 
+     {                                 
         if (y1 > y0) vline(x0,y0,y1,color);
         else vline(x0,y1,y0,color);
         return;
     }
 
-    if (dx > 0) {
+    if (dx > 0) 
+    {
         dx_sym = 1;
     } else {
         dx_sym = -1;
     }
-    if (dy == 0) {        /* horizontal line */
+    if (dy == 0)                                    // horizontal line 
+    {       
         if (x1 > x0) hline(x0,x1,y0,color);
         else  hline(x1,x0,y0,color);
         return;
     }
 
-    if (dy > 0) {
+    if (dy > 0) 
+    {
         dy_sym = 1;
-    } else {
+    } else 
+    {
         dy_sym = -1;
     }
 
@@ -480,28 +603,37 @@
     dx_x2 = dx*2;
     dy_x2 = dy*2;
 
-    if (dx >= dy) {
+    if (dx >= dy) 
+    {
         di = dy_x2 - dx;
-        while (x0 != x1) {
+        while (x0 != x1) 
+        {
 
             pixel(x0, y0, color);
             x0 += dx_sym;
-            if (di<0) {
+            if (di<0) 
+            {
                 di += dy_x2;
-            } else {
+            } else 
+            {
                 di += dy_x2 - dx_x2;
                 y0 += dy_sym;
             }
         }
         pixel(x0, y0, color);
-    } else {
+    } 
+    else 
+    {
         di = dx_x2 - dy;
-        while (y0 != y1) {
+        while (y0 != y1) 
+        {
             pixel(x0, y0, color);
             y0 += dy_sym;
-            if (di < 0) {
+            if (di < 0) 
+            {
                 di += dx_x2;
-            } else {
+            } else 
+            {
                 di += dx_x2 - dy_x2;
                 x0 += dx_sym;
             }
@@ -531,7 +663,6 @@
 }
 
 
-
 void SPI_TFT_ILI9341::fillrect(int x0, int y0, int x1, int y1, int color)
 {
 
@@ -540,18 +671,24 @@
     int pixel = h * w;
     window(x0,y0,w,h);
     wr_cmd(0x2C);  // send pixel 
-    #if defined TARGET_KL25Z  // 8 Bit SPI
-    for (int p=0; p<pixel; p++) {
-        _spi.write(color >> 8);
-        _spi.write(color & 0xff);
-    }
-   #else
-    _spi.format(16,0);                            // switch to 16 bit Mode 0
-    for (int p=0; p<pixel; p++) {
-        _spi.write(color);
-    }
-    _spi.format(8,0);
-    #endif
+    if (iTypeTFT == PARA_TFT_) //PARA_TFT
+    { 
+        for (int p=0; p<pixel; p++) 
+        {
+            wr_dat(color >> 8);
+            wr_dat(color & 0xff);
+        }
+   }
+   else
+   {                                           // 16 bit SPI transfer
+        _spi.format(16,0);                      
+        for (int p=0; p<pixel; p++)
+        {
+            _spi.write(color);
+        }
+        _spi.format(8,0);
+    } 
+
     _cs = 1;
     WindowMax();
     return;
@@ -565,30 +702,30 @@
 }
 
 
-
 int SPI_TFT_ILI9341::columns()
 {
     return width() / font[1];
 }
 
 
-
 int SPI_TFT_ILI9341::rows()
 {
     return height() / font[2];
 }
 
 
-
 int SPI_TFT_ILI9341::_putc(int value)
 {
-    if (value == '\n') {    // new line
+    if (value == '\n') {                                // new line
         char_x = 0;
         char_y = char_y + font[2];
-        if (char_y >= height() - font[2]) {
+        if (char_y >= height() - font[2]) 
+        {
             char_y = 0;
         }
-    } else {
+    }
+    else
+    {
         character(char_x, char_y, value);
     }
     return value;
@@ -609,49 +746,73 @@
     vert = font[2];                      // get vert size of font
     bpl = font[3];                       // bytes per line
 
-    if (char_x + hor > width()) {
+    if (char_x + hor > width())
+    {
         char_x = 0;
         char_y = char_y + vert;
-        if (char_y >= height() - font[2]) {
+        if (char_y >= height() - font[2]) 
+        {
             char_y = 0;
         }
     }
-    window(char_x, char_y,hor,vert); // char box
-    wr_cmd(0x2C);  // send pixel
-    #ifndef TARGET_KL25Z  // 16 Bit SPI 
-    _spi.format(16,0);   
-    #endif                         // switch to 16 bit Mode 0
-    zeichen = &font[((c -32) * offset) + 4]; // start of char bitmap
-    w = zeichen[0];                          // width of actual char
-     for (j=0; j<vert; j++) {  //  vert line
-        for (i=0; i<hor; i++) {   //  horz line
+    window(char_x, char_y,hor,vert);                // char box
+    wr_cmd(0x2C);                                   // send pixel
+
+    if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+    {                                     // 16 Bit SPI transfer
+        _spi.format(16,0);   
+    }
+
+    zeichen = &font[((c -32) * offset) + 4];        // start of char bitmap
+    w = zeichen[0];                                 // width of actual char
+     for (j=0; j<vert; j++)                         //  vert line
+     {                       
+        for (i=0; i<hor; i++)                       //  horz line
+        {                     
             z =  zeichen[bpl * i + ((j & 0xF8) >> 3)+1];
             b = 1 << (j & 0x07);
-            if (( z & b ) == 0x00) {
-               #ifndef TARGET_KL25Z  // 16 Bit SPI 
-                _spi.write(_background);
-               #else
-                _spi.write(_background >> 8);
-                _spi.write(_background & 0xff);
-                #endif
-            } else {
-                #ifndef TARGET_KL25Z  // 16 Bit SPI
-                _spi.write(_foreground);
-                #else
-                _spi.write(_foreground >> 8);
-                _spi.write(_foreground & 0xff);
-                #endif
+            if (( z & b ) == 0x00) 
+            {
+                if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+                {                                  // 16 bit SPI transfer 
+                    _spi.write(_background);
+                }
+                else
+                {                               // 8 bit parallel transfer                
+                    wr_dat(_background >> 8);
+                    wr_dat(_background & 0xff);
+                }
+            } 
+            else 
+            {
+                if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+                {
+                    _spi.write(_foreground);
+                }
+                else
+                {                               // 8 bit parallel transfer
+                    wr_dat(_foreground >> 8);
+                    wr_dat(_foreground & 0xff);
+                }
             }
         }
     }
     _cs = 1;
-    #ifndef TARGET_KL25Z  // 16 Bit SPI
-    _spi.format(8,0);
-    #endif
+
+    if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+    {         
+        _spi.format(8,0);
+    }
+
     WindowMax();
-    if ((w + 2) < hor) {                   // x offset to next char
+    if ((w + 2) < hor)                              // x offset to next char
+    {                   
         char_x += w + 2;
-    } else char_x += hor;
+    } 
+    else
+    { 
+        char_x += hor;
+    }
 }
 
 
@@ -661,138 +822,60 @@
 }
 
 
-
 void SPI_TFT_ILI9341::Bitmap(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *bitmap)
 {
     unsigned int  j;
     int padd;
     unsigned short *bitmap_ptr = (unsigned short *)bitmap;
-    #if defined TARGET_KL25Z  // 8 Bit SPI
+
+    //#ifdef PARA_TFT                                 // 8 bit parallel transfer
         unsigned short pix_temp;
-    #endif
+    //#endif
     
     unsigned int i;
     
-    // the lines are padded to multiple of 4 bytes in a bitmap
-    padd = -1;
-    do {
+    padd = -1;                                      // the lines are padded to multiple of 4 bytes in a bitmap
+    do 
+    {
         padd ++;
-    } while (2*(w + padd)%4 != 0);
+    } 
+    while (2*(w + padd)%4 != 0);
     window(x, y, w, h);
     bitmap_ptr += ((h - 1)* (w + padd));
-    wr_cmd(0x2C);  // send pixel
-    #ifndef TARGET_KL25Z  // 16 Bit SPI 
-    _spi.format(16,0);
-    #endif                            // switch to 16 bit Mode 0
-    for (j = 0; j < h; j++) {         //Lines
-        for (i = 0; i < w; i++) {     // one line
-            #if defined TARGET_KL25Z  // 8 Bit SPI
+    wr_cmd(0x2C);                                   // send pixel
+
+    if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+    {        
+        _spi.format(16,0);
+    }
+
+    for (j = 0; j < h; j++)                         //Lines
+    {         
+        for (i = 0; i < w; i++)                     // one line
+        {     
+            if (iTypeTFT == PARA_TFT_) //PARA_TFT
+            {                 
                 pix_temp = *bitmap_ptr;
-                _spi.write(pix_temp >> 8);
-                _spi.write(pix_temp);
+                wr_dat(pix_temp >> 8);
+                wr_dat(pix_temp);
                 bitmap_ptr++;
-            #else
-                _spi.write(*bitmap_ptr);    // one line
+            }
+            else
+            {                                  // 16 bit SPI transfer
+                _spi.write(*bitmap_ptr);            // one line
                 bitmap_ptr++;
-            #endif
+            }
         }
         bitmap_ptr -= 2*w;
         bitmap_ptr -= padd;
     }
     _cs = 1;
-    #ifndef TARGET_KL25Z  // 16 Bit SPI 
-    _spi.format(8,0);
-    #endif
+
+    if (iTypeTFT != PARA_TFT_) //#ifndef PARA_TFT
+    {
+        _spi.format(8,0);                           
+    }
+
     WindowMax();
 }
 
-
-// local filesystem is not implemented in kinetis board
-#if DEVICE_LOCALFILESYSTEM
-
-int SPI_TFT_ILI9341::BMP_16(unsigned int x, unsigned int y, const char *Name_BMP)
-{
-
-#define OffsetPixelWidth    18
-#define OffsetPixelHeigh    22
-#define OffsetFileSize      34
-#define OffsetPixData       10
-#define OffsetBPP           28
-
-    char filename[50];
-    unsigned char BMP_Header[54];
-    unsigned short BPP_t;
-    unsigned int PixelWidth,PixelHeigh,start_data;
-    unsigned int    i,off;
-    int padd,j;
-    unsigned short *line;
-
-    // get the filename
-    LocalFileSystem local("local");
-    sprintf(&filename[0],"/local/");
-    i=7;
-    while (*Name_BMP!='\0') {
-        filename[i++]=*Name_BMP++;
-    }
-
-    fprintf(stderr, "filename : %s \n\r",filename);
-
-    FILE *Image = fopen((const char *)&filename[0], "rb");  // open the bmp file
-    if (!Image) {
-        return(0);      // error file not found !
-    }
-
-    fread(&BMP_Header[0],1,54,Image);      // get the BMP Header
-
-    if (BMP_Header[0] != 0x42 || BMP_Header[1] != 0x4D) {  // check magic byte
-        fclose(Image);
-        return(-1);     // error no BMP file
-    }
-
-    BPP_t = BMP_Header[OffsetBPP] + (BMP_Header[OffsetBPP + 1] << 8);
-    if (BPP_t != 0x0010) {
-        fclose(Image);
-        return(-2);     // error no 16 bit BMP
-    }
-
-    PixelHeigh = BMP_Header[OffsetPixelHeigh] + (BMP_Header[OffsetPixelHeigh + 1] << 8) + (BMP_Header[OffsetPixelHeigh + 2] << 16) + (BMP_Header[OffsetPixelHeigh + 3] << 24);
-    PixelWidth = BMP_Header[OffsetPixelWidth] + (BMP_Header[OffsetPixelWidth + 1] << 8) + (BMP_Header[OffsetPixelWidth + 2] << 16) + (BMP_Header[OffsetPixelWidth + 3] << 24);
-    if (PixelHeigh > height() + y || PixelWidth > width() + x) {
-        fclose(Image);
-        return(-3);      // to big
-    }
-
-    start_data = BMP_Header[OffsetPixData] + (BMP_Header[OffsetPixData + 1] << 8) + (BMP_Header[OffsetPixData + 2] << 16) + (BMP_Header[OffsetPixData + 3] << 24);
-
-    line = (unsigned short *) malloc (2 * PixelWidth); // we need a buffer for a line
-    if (line == NULL) {
-        return(-4);         // error no memory
-    }
-
-    // the bmp lines are padded to multiple of 4 bytes
-    padd = -1;
-    do {
-        padd ++;
-    } while ((PixelWidth * 2 + padd)%4 != 0);
-
-
-//fseek(Image, 70 ,SEEK_SET);
-    window(x, y,PixelWidth ,PixelHeigh);
-    wr_cmd(0x2C);  // send pixel 
-    _spi.format(16,3);                            // switch to 16 bit Mode 3
-    for (j = PixelHeigh - 1; j >= 0; j--) {               //Lines bottom up
-        off = j * (PixelWidth  * 2 + padd) + start_data;   // start of line
-        fseek(Image, off ,SEEK_SET);
-        fread(line,1,PixelWidth * 2,Image);       // read a line - slow !
-        for (i = 0; i < PixelWidth; i++) {        // copy pixel data to TFT
-            _spi.write(line[i]);                  // one 16 bit pixel
-        } 
-     }
-    _cs = 1;
-    _spi.format(8,3);
-    free (line);
-    fclose(Image);
-    WindowMax();
-    return(1);
-}
-#endif
\ No newline at end of file

--- a/SPI_TFT_ILI9341.h	Wed May 26 18:42:58 2021 +0000
+++ b/SPI_TFT_ILI9341.h	Tue Oct 24 23:32:54 2023 +0200
@@ -17,6 +17,14 @@
 #ifndef MBED_SPI_TFT_ILI9341_H
 #define MBED_SPI_TFT_ILI9341_H
 
+//#define ADA_TFT
+//#define SEEED_TFT
+//#define PARA_TFT 
+
+#define PARA_TFT_    1
+#define SEEED_TFT_   2
+#define ADA_TFT_    3
+
 #include "mbed.h"
 #include "GraphicsDisplay.h"
 
@@ -92,8 +100,16 @@
    * @param spiSpeed SPI Clock Frequency in Hz 
    * the IM pins have to be set to 1110 (3-0) 
    */ 
-  SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset, PinName dc, int spiSpeed = 27000000, const char* name ="TFT");
-    
+
+ 
+    //#ifdef PARA_TFT
+        SPI_TFT_ILI9341(PinName TFT_D0, PinName TFT_D1, PinName TFT_D2, PinName TFT_D3, PinName TFT_D4, PinName TFT_D5,
+        PinName TFT_D6, PinName TFT_D7, PinName rd, PinName wr, PinName cs, PinName dc, PinName res, const char* name);  // ="TFT");
+    //#else
+        SPI_TFT_ILI9341(PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset, PinName dc, int spiSpeed = 27000000, const char* name ="TFT");
+    //#endif
+
+
   /** Get the width of the screen in pixel
    *
    * @param 
@@ -231,28 +247,7 @@
    */    
   void Bitmap(unsigned int x, unsigned int y, unsigned int w, unsigned int h,unsigned char *bitmap);
     
-#if DEVICE_LOCALFILESYSTEM
-   /** paint a 16 bit BMP from local filesytem on the TFT (slow) 
-   *
-   * @param x,y : upper left corner 
-   * @param *Name_BMP name of the BMP file
-   * @returns 1 if bmp file was found and painted
-   * @returns -1 if bmp file was found not found
-   * @returns -2 if bmp file is not 16bit
-   * @returns -3 if bmp file is to big for screen 
-   * @returns -4 if buffer malloc go wrong
-   *
-   *   bitmap format: 16 bit R5 G6 B5
-   * 
-   *   use Gimp to create / load , save as BMP, option 16 bit R5 G6 B5
-   *   copy to internal file system            
-   * 
-   */      
-    
-  int BMP_16(unsigned int x, unsigned int y, const char *Name_BMP);  
-#endif
-    
-    
+
   /** select the font to use
    *
    * @param f pointer to font array 
@@ -275,16 +270,32 @@
    *
    */  
   void set_orientation(unsigned int o);
+
+//#ifdef PARA_TFT
+    DigitalOut _TFT_D0;
+    DigitalOut _TFT_D1;
+    DigitalOut _TFT_D2;
+    DigitalOut _TFT_D3;
+    DigitalOut _TFT_D4;
+    DigitalOut _TFT_D5;
+    DigitalOut _TFT_D6;
+    DigitalOut _TFT_D7;
+    DigitalOut _rd;
+    DigitalOut _wr; 
+    DigitalOut _res;   
+
+//#else
+    SPI _spi;
+    PinName _reset;
+//#endif
+
+    DigitalOut _cs; 
+    DigitalOut _dc;
     
-  SPI _spi;
-  DigitalOut _cs; 
-  PinName _reset;
-  DigitalOut _dc;
-  unsigned char* font;
-  
-  
-  
-   
+    unsigned char* font;
+
+    int iTypeTFT;
+
 protected:
 
   /** Set draw window region to whole screen
@@ -334,8 +345,8 @@
    * @param dat data written to LCD controller
    * 
    */   
-  //void wr_dat(unsigned int value);
   void wr_dat(unsigned char value);
+
     
   /** Write a command the LCD controller 
    *