ESP32-S3 ST7796 Parallel

[moebassist]

Hi Everyone,

I'm attempting to get this library working on an S3 with ST7796 in Parallel mode.

Previously, I had great success with an S2 and IL9341 - the entire project (which includes RS485, rotary encoder, buttons, etc.) all work perfectly without any changes - I was hoping the S3 wasn't so different when it comes to getting the LCD operating.

I have proof that the S3/ST7796 Parallel 8080-8 combination operates because some low level driver code was written and tested using LVLG.

At present I get a blank white screen. I've verified the pin mapping (with the LVGL example). At present, the only obvious problem is that I have no TFT_RD pin and I'm unsure what to do regarding that.

#499 mentions 7796 and parallel but I'm not sure if anything came of it.

Any hints?

Thanks in advance for your time and effort.

[Bodmer]

I need more information to spot what you may have done wrong. I have it working with this setup:

#define USER_SETUP_ID 146

#define TFT_PARALLEL_8_BIT

//#define ILI9341_DRIVER
#define ST7796_DRIVER
//#define ILI9488_DRIVER

// ESP32 S3 pins used for the parallel interface TFT
#define TFT_CS    9
#define TFT_DC    8  // Data Command control pin - must use a GPIO in the range 0-31
#define TFT_RST  34

#define TFT_WR    7  // Write strobe control pin - must use a GPIO in the range 0-31
#define TFT_RD    6

#define TFT_D0   12  // Must use GPIO in the range 0-31 for the data bus
#define TFT_D1   13  // so a single register write sets/clears all bits
#define TFT_D2   14
#define TFT_D3   15
#define TFT_D4   16
#define TFT_D5   21
#define TFT_D6    5
#define TFT_D7    4


#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF

#define SMOOTH_FONT

This is the output of the Read_User_Setup example sketch@

TFT_eSPI ver = 2.4.61
Processor    = ESP32
Frequency    = 240MHz
Transactions = Yes
Interface    = Parallel
Display driver = 7796
Display width  = 320
Display height = 480

TFT_CS   = GPIO 9
TFT_DC   = GPIO 8
TFT_RST  = GPIO 34
TFT_WR   = GPIO 7
TFT_RD   = GPIO 6

TFT_D0   = GPIO 12
TFT_D1   = GPIO 13
TFT_D2   = GPIO 14
TFT_D3   = GPIO 15
TFT_D4   = GPIO 16
TFT_D5   = GPIO 21
TFT_D6   = GPIO 5
TFT_D7   = GPIO 4

Font GLCD   loaded
Font 2      loaded
Font 4      loaded
Font 6      loaded
Font 7      loaded
Font 8      loaded
Smooth font enabled

[moebassist]

Hi - many thanks for the input. A few problems that are beyond my control as this is a prototype board produced by others:

#define TFT_PARALLEL_8_BIT
#define ST7796_DRIVER

#define TFT_RD   -1   // Read pin
#define TFT_WR   36  // Write strobe control pin 
#define TFT_CS   34  // Chip select control pin
#define TFT_DC   14  // Data Command control pin 
#define TFT_RST  39  // Reset pin
#define TFT_D0   35  
#define TFT_D1   37
#define TFT_D2   38
#define TFT_D3   33
#define TFT_D4   10
#define TFT_D5   11
#define TFT_D6   12
#define TFT_D7   13


//#define TFT_BL   42
//#define TFT_BACKLIGHT_ON LOW

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts

I have no read pin, and you can see that pins >31 are used. Is it possible to get working on higher pin numbers? Are they used in masks that I can adjust?

Many, many thanks for all your time.

[Bodmer]

As you have concluded the library cannot be used with that pin configuration as the 8 bit data will require 2 register writes.

The code that needs to be changed is here.

[moebassist]

All I can say is wow.....After investigation, using pins>31 adds a high level of complexity. Regardless, I made some changes in case anyone else required the parallel bus to be on pins >31:

#define TFT_RD   -1     // Read pin
#define TFT_WR   36     // Write strobe control pin - must use a pin in the range 0-31 on ESP32
#define TFT_CS   34     // Chip select control pin
#define TFT_DC   14     // Data Command control pin - must use a pin in the range 0-31 on ESP32
#define TFT_RST  -1     //39  // Reset pin
#define TFT_D0   35  
#define TFT_D1   37
#define TFT_D2   38
#define TFT_D3   33
#define TFT_D4   10
#define TFT_D5   11
#define TFT_D6   12
#define TFT_D7   13


////////////////////////////////////////////////////////////////////////////////////////
// Define the parallel bus interface chip pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_PARALLEL_8_BIT)

  // Create a bit set lookup table for data bus - wastes 1kbyte of RAM but speeds things up dramatically
  // can then use e.g. GPIO.out_w1ts = set_mask(0xFF); to set data bus to 0xFF
  
  // Mask for the 8 data bits to set pin directions
  #define dir_mask (1 << TFT_D4) | (1 << TFT_D5) | (1 << TFT_D6) | (1 << TFT_D7)

  #define dir_mask1 (1 << (TFT_D0-32)) | (1 << (TFT_D1-32)) | (1 << (TFT_D2-32)) | (1 << (TFT_D3-32))
  
  
  #if (TFT_WR >= 32)
    // Data bits and the write line are cleared sequentially
    #define clr_mask1 (dir_mask1)
    #define clr_mask (dir_mask); WR_L  
  #elif (TFT_WR >= 0)
    // Data bits and the write line are cleared to 0 in one step (1.25x faster)
    #define clr_mask (dir_mask | (1 << TFT_WR))
  #else
    #define clr_mask
  #endif

  // A lookup table is used to set the different bit patterns, this uses 1kByte of RAM
//  #define set_mask(C) xset_mask[C] // 63fps Sprite rendering test 33% faster, graphicstest only 1.8% faster than shifting in real time

  // Real-time shifting alternative to above to save 1KByte RAM, 47 fps Sprite rendering test
  #define set_mask(C) (((C)&0x80)>>7)<<TFT_D7 | (((C)&0x40)>>6)<<TFT_D6 | (((C)&0x20)>>5)<<TFT_D5 | (((C)&0x10)>>4)<<TFT_D4

  #define set_mask1(C) (((C)&0x08)>>3)<<(TFT_D3-32) | (((C)&0x04)>>2)<<(TFT_D2-32) | (((C)&0x02)>>1)<<(TFT_D1-32) | ((((C)&0x01)>>0)<<(TFT_D0 - 32))
   

  // Write 8 bits to TFT
  #define tft_Write_8(C) GPIO.out1_w1tc.val = clr_mask1; \
                         GPIO.out_w1tc = clr_mask;\
                         GPIO.out1_w1ts.val = set_mask1((uint8_t)(C));\
                         GPIO.out_w1ts = set_mask((uint8_t)(C)); WR_H

  #if defined (SSD1963_DRIVER)

    // Write 18 bit color to TFT
    #define tft_Write_16(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0xF800)>> 8)); WR_H; \
                            GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x07E0)>> 3)); WR_H; \
                            GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x001F)<< 3)); WR_H

    // 18 bit color write with swapped bytes
    #define tft_Write_16S(C) Cswap = ((C) >>8 | (C) << 8); tft_Write_16(Cswap)

  #else

    #ifdef PSEUDO_16_BIT
      // One write strobe for both bytes
      #define tft_Write_16(C)  GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
      #define tft_Write_16S(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
    #else
      // Write 16 bits to TFT
      #define tft_Write_16(C) GPIO.out1_w1tc.val = clr_mask1;\
                              GPIO.out_w1tc = clr_mask; \
                              GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                              GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
                              GPIO.out1_w1tc.val = clr_mask;\
                              GPIO.out_w1tc = clr_mask; \
                              GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0)); \
                              GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H

      // 16 bit write with swapped bytes
      #define tft_Write_16S(C) GPIO.out1_w1tc.val = clr_mask; \
                               GPIO.out_w1tc = clr_mask;\
                               GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0)); \
                               GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
                               GPIO.out1_w1tc.val = clr_mask;\
                               GPIO.out_w1tc = clr_mask;\
                               GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                               GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
    #endif

  #endif

  // Write 32 bits to TFT
  #define tft_Write_32(C) GPIO.out1_w1tc.val = clr_mask;\
                          GPIO.out_w1tc.val = clr_mask;\
                          GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 24));\
                          GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 24)); WR_H; \
                          GPIO.out1_w1tc.val = clr_mask;\
                          GPIO.out_w1tc.val = clr_mask; \
                          GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 16)); \
                          GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 16)); WR_H; \
                          GPIO.out1_w1tc.val = clr_mask; \
                          GPIO.out_w1tc.val = clr_mask; \
                          GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >>  8));\
                          GPIO.out_w1ts = set_mask((uint8_t) ((C) >>  8)); WR_H; \
                          GPIO.out1_w1tc.val = clr_mask; \
                          GPIO.out_w1tc.val = clr_mask; \
                          GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >>  0)); \
                          GPIO.out_w1ts = set_mask((uint8_t) ((C) >>  0)); WR_H

  // Write two concatenated 16 bit values to TFT
  #define tft_Write_32C(C,D) GPIO.out1_w1tc.val = clr_mask; \
                             GPIO.out_w1tc = clr_mask; \
                             GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                             GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
                             GPIO.out1_w1tc.val = clr_mask; \
                             GPIO.out_w1tc = clr_mask; \
                             GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0));\
                             GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
                             GPIO.out1_w1tc.val = clr_mask; \
                             GPIO.out_w1tc = clr_mask; \
                             GPIO.out1_w1ts.val = set_mask1((uint8_t) ((D) >> 8)); \
                             GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 8)); WR_H; \
                             GPIO.out1_w1tc.val = clr_mask;\
                             GPIO.out_w1tc = clr_mask; \
                             GPIO.out1_w1ts.val = set_mask1((uint8_t) ((D) >> 0)); \
                             GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 0)); WR_H

  // Write 16 bit value twice to TFT - used by drawPixel()
  #define tft_Write_32D(C) GPIO.out1_w1tc.val = clr_mask;\
                           GPIO.out_w1tc = clr_mask; \
                           GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                           GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
                           GPIO.out1_w1tc.val = clr_mask;\
                           GPIO.out_w1tc = clr_mask; \
                           GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0));\
                           GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
                           GPIO.out1_w1tc.val = clr_mask; \
                           GPIO.out_w1tc = clr_mask;\
                           GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                           GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
                           GPIO.out1_w1tc.val = clr_mask;\
                           GPIO.out_w1tc = clr_mask;\
                           GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0)); \
                           GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H

You can see I removed the use of PARALLEL_INIT_TFT_DATA_BUS because this would use a 64bit mask / 2 x 32 bit masks (one for each GPIO.out_w1tc struct) and went with the slower 'define set_mask(C)' in order to save on memory.

In addition, I used two sets of masks for the pins (those in 0-31 and those in 32-53) and revised the tft_write functions accordingly. Of course, this will be literally twice as slow as I'm having to write the masks to IO twice - but it's working. Luckily, my pins are split D0-D3 > 31, D4 - D7 <32 so the code at least looks neat.

My only problem now is that no matter what I do, I can't get the screen to map correctly. I know the above is working because the screen initialises and commands work - including colors being displayed correctly (if the mask/remapping above was wrong, all the commands would be gibberish!):

The screen is supposed to be 480x320, and the red rectangle is drawn this size - you can see that it's offset and truncated. 0,0 should be the top left of the screen, but it's actually the top right of the red rectangle. Rotation aside, I've attempted to change the column/row mapping without any results.

Any pointers anyone?

Thanks in advance for all of your help, it's greatly appreciated.

[Bodmer]

You are using the wrong mask in a lot of places, one example line being:
#define tft_Write_32C(C,D) GPIO.out1_w1tc.val = clr_mask; \

Should be:
#define tft_Write_32C(C,D) GPIO.out1_w1tc.val = clr_mask1; \

These errors will make coordinate boxes appear in the wrong place. For GPIO.out1... use mask1

[iroger]

Any news on this? I have a similar question related to the WT32-SC01 plus display which also uses paralel 8 bit but also above 32 pin assigned to databus.

https://www.antratek.com/media/wysiwyg/pdf/WT32-SC01-Plus-V1.3-EN.pdf

Description | Module Pin | Remark
BL_PWM | GPIO 45 | Backlight control, active high
LCD_RESET | GPIO 4 | LCD reset, multiplexed with touch reset
LCD_RS | GPIO 0 | Command/Data selection
LCD_WR | GPIO 47 | Write clock
LCD_TE | GPIO 48 | Frame sync
LCD_DB0 | GPIO 9 | LCD data interface, 8bit MCU (8080)
LCD_DB1 | GPIO 46
LCD_DB2 | GPIO 3
LCD_DB3 | GPIO 8
LCD_DB4 | GPIO 18
LCD_DB5 | GPIO 17

[dkalliv]

Hi iroger, I have added support for the WT32-SC01 Plus module and created a pull request (3423). While it is being reviewed you can give it a spin using my fork.

[moebassist]

Hi,

Sorry for the late reply.

You need to edit the appropriate header file for your CPU. I've attached my adjusted ESP32 S3.

TFT_eSPI_ESP32_S3.zip

Most of the code already has support for pins > 31 - e.g.:

`    #if (TFT_DC >= 32)
      #ifdef RPI_DISPLAY_TYPE  // RPi displays need a slower DC change
        #define DC_C GPIO.out_w1ts.val = (1 << (TFT_DC - 32)); \
                     GPIO.out_w1tc.val = (1 << (TFT_DC - 32))
        #define DC_D GPIO.out_w1tc.val = (1 << (TFT_DC - 32)); \
                     GPIO.out_w1ts.val = (1 << (TFT_DC - 32))
      #else
        #define DC_C GPIO.out_w1tc.val = (1 << (TFT_DC - 32))//;GPIO.out_w1tc.val = (1 << (TFT_DC - 32))
        #define DC_D GPIO.out_w1ts.val = (1 << (TFT_DC - 32))//;GPIO.out_w1ts.val = (1 << (TFT_DC - 32))
      #endif

However, you'll need to make the most changes when pushing data to the 8 bit bus. A single byte is used to load the 8 bits - In the code below, you can see that I've added a second mask as my 8 bit bus uses 4 pins <32 and 4 pins > 31:

// Mask for the 8 data bits to set pin directions
 #define dir_mask (1 << TFT_D4) | (1 << TFT_D5) | (1 << TFT_D6) | (1 << TFT_D7)
 #define dir_mask1 (1 << (TFT_D0-32)) | (1 << (TFT_D1-32)) | (1 << (TFT_D2-32)) | (1 << (TFT_D3-32))

Likewise, when sending the data, the second mask requires adding.

     // Write 16 bits to TFT
      #define tft_Write_16(C) GPIO.out1_w1tc.val = clr_mask1;\
                              GPIO.out_w1tc = clr_mask; \
                              GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 8)); \
                              GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
                              GPIO.out1_w1tc.val = clr_mask1;\
                              GPIO.out_w1tc = clr_mask; \
                              GPIO.out1_w1ts.val = set_mask1((uint8_t) ((C) >> 0)); \
                              GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H

This works fine - but every data write is now has 2 operations instead of 1, so there's a performance impact. I wasn't needing anything crazy like 30fps (just updating real-time data every 500ms) so it didn't matter.

Hope this helps!

[pvetal]

Hi moebassist.
Tell me please, which a most easy way for beginner to "friendship" ESP32 S3 with 4" display ST7796?
Probably, exist simple instruction or User_Setups with minimum editions, which will be understand for beginner?
I had project on ESP32-D0WD-V3 with LVLG, but it needed more mamory and I cnanched to EPS32 S3.
I very need any solution.
Thanks.

[moebassist]

As long as your parallel bus connections are on pins < 32, it should just work.