TFT Touch display on (XIAO) ESP32 (S3)

[MrTinkerman]

Hi,

I'm trying to use a TFT touch display on a XIAO ESP32-S3, this is the display:
https://www.openhasp.com/0.6.1/displays/ILI9341_IPS/

I have it hooked up and I can either show text/graphics or use the touch functionality.
But not both at this point.

I'm struggling with the SPI bus and hoping someone could let me know how to solve this.
My connections and code are below.

The library I'm working with is: https://github.com/rdagger/micropython-ili9341/tree/master
In the examples two SPI instances/buses(?) are used for the display and touchscreen.

Note: The display can handle a 40 MHz baudrate while the touch does not work above 1 MHz.

Should I use soft SPI to create a separate SPI for the touchscreen?
If so, how would I connect the MISO/MOSI/SCK from both the hardware and soft SPI to the display?
I've also been reading about daisy chaining, HSPI and VSPI but it's a bit beyond me what to do with that info.

So if someone has any suggestion, thanks in advance!

connections and code:

from machine import Pin, SPI
import time
from ili9341 import Display, color565
from xpt2046 import Touch
from xglcd_font import XglcdFont

show_text = 1							# Choose to display text on display,
use_touch = 0							# or test touch functionality,
test_both = 0							# or both

class GV():	pass						# Global Variables class
gv = GV()


def handle_touch(x,y):					# Display x and y of touch
    
    print(f'display touched {x} {y}')
    
    
def init():
    
    if show_text or test_both:													
        
        spi = SPI(1, baudrate=40000000, sck=Pin(7), mosi=Pin(9))				# Setting up SPI's to use at the same time: 
                                                                                # not working
        gv.display = Display(spi, dc=Pin(6), cs=Pin(5), rst=Pin(44),
                             width=240, height=320, rotation=180)
    
    if use_touch or test_both:
        
        spi = SPI(1, baudrate= 1000000, sck=Pin(7), mosi=Pin(9), miso=Pin(8))
    
        gv.touch = Touch(spi, cs=Pin(4), int_pin=Pin(43),
                         int_handler=handle_touch)

    main()


def main():
    
    if show_text or test_both:
        
        print('Loading font unispace')
        unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)

        lines = [f'This is line {n}' for n in range(11)]
        
        y = 0
        
        for l in range(len(lines)):
            
            gv.display.draw_text(0, y, lines[l], unispace,
                                 color565(255, 255, 0),
                                 background=color565(0,0,0))
            y += 28
    
    if use_touch or test_both:
        
        while True:
            
            print(f'Waiting for touch {time.ticks_ms()}')
            time.sleep_ms(1000)


init()

[robert-hh]

Since TFT and touch have different CS pins, you can use the same SPI object alternating for both. You should not create different SPI objects. Only you might have to switch the SCK frequency, since the touch only allows 1 MHz. You can do that with spi.init(freq=xyz).

[MrTinkerman]

Ok, so I tried creating both display and touch with the same spi instance (see below).
I wanted to make sure that worked before trying to change the baudrate (assuming you mean baudrate when you say frequency?)

But I still have the same problem. It's still either display or touch but not both.
Also, if i switch between display and text, I have to hard reset the board.

How could I troubleshoot this?

def init():
    
    gv.spi = SPI(1, baudrate=1_000_000, sck=Pin(7), mosi=Pin(9), miso=Pin(8))
    
    if show_text:													
        
        gv.display = Display(gv.spi, dc=Pin(6), cs=Pin(5), rst=Pin(44),
                             width=240, height=320, rotation=180)
    
    if use_touch:
        
        gv.touch = Touch(gv.spi, cs=Pin(4), int_pin=Pin(43),
                         int_handler=handle_touch)

    main()

[robert-hh]

You should ensure that after each call to a gv.display or touch function the respective CS pins is deasserted (= at high level).

[MrTinkerman]

Yes, one might assume that the library would take care of that, and indeed it does (see below).
The cs pins are set to low when writing data and set to high when finished.

Is it the library, is it my setup, what's the problem here?
/me bangs head on desk :)

the function in library that handles touch:

    def send_command(self, command):
               
        print(f'TOUCH - writing command t1, cs pin: {self.cs.value()}')
        
        self.tx_buf[0] = command
        self.cs(0)
        print(f'TOUCH - writing command t2, cs pin: {self.cs.value()}')
        self.spi.write_readinto(self.tx_buf, self.rx_buf)
        self.cs(1)
        
        print(f'TOUCH - written command t3, cs pin: {self.cs.value()}')

        return (self.rx_buf[1] << 4) | (self.rx_buf[2] >> 4)

The output:

Waiting for touch input
TOUCH - writing command t1, cs pin: 1
TOUCH - writing command t2, cs pin: 0
TOUCH - written command t3, cs pin: 1
TOUCH - writing command t1, cs pin: 1
TOUCH - writing command t2, cs pin: 0
TOUCH - written command t3, cs pin: 1
touch x,y: 102 171

That would be two interrupts because the interrupt is triggered on rising and falling

The functions in the display library that output over spi:

    def write_cmd_mpy(self, command, *args):
        """Write command to OLED (MicroPython).

        Args:
            command (byte): ILI9341 command code.
            *args (optional bytes): Data to transmit.
        """
        print(f'DISPLAY - def write_cmd_mpy - writing command t1, cs pin: {self.cs.value()}')
        self.dc(0)
        self.cs(0)
        print(f'DISPLAY - def write_cmd_mpy - writing command t2, cs pin: {self.cs.value()}')
        self.spi.write(bytearray([command]))
        self.cs(1)
        print(f'DISPLAY - def write_cmd_mpy - written command t3, cs pin: {self.cs.value()}')
        # Handle any passed data
        if len(args) > 0:
            self.write_data(bytearray(args))

    def write_data_mpy(self, data):
        """Write data to OLED (MicroPython).

        Args:
            data (bytes): Data to transmit.
        """
        print(f'DISPLAY - def write_data_mpy - writing command t1, cs pin: {self.cs.value()}')
        self.dc(1)
        self.cs(0)
        print(f'DISPLAY - def write_data_mpy - writing command t2, cs pin: {self.cs.value()}')
        self.spi.write(data)
        self.cs(1)
        print(f'DISPLAY - def write_data_mpy - written command t3, cs pin: {self.cs.value()}')

The output:

DISPLAY - def write_cmd_mpy - writing command t1, cs pin: 1
DISPLAY - def write_cmd_mpy - writing command t2, cs pin: 0
DISPLAY - def write_cmd_mpy - written command t3, cs pin: 1
DISPLAY - def write_data_mpy - writing command t1, cs pin: 1
DISPLAY - def write_data_mpy - writing command t2, cs pin: 0
DISPLAY - def write_data_mpy - written command t3, cs pin: 1

[robert-hh]

I do not know the internal wiring of the display you use. Could it be that the interrupt handler is only called when CS of the touch is low? Do you get touch events when you poll the touch sensor in main()?

[robert-hh]

I looked into the behavior of the IRQ pin. It works, even if CS is not active, is digital and is sufficiently fast. But it can produce quiet a burst of events. See the picture below of a touch release. The rise and fall times are 7.8 and 2.8 ns, but there is a ~20ns burst and also slower toggling with ~35µs width. That may confuse an IRQ handler. But that is handled well in the XPT2046 code, and using touch interrupt works well.

[shariltumin]

Hi Robert, I was just wondering at what baudrate you did your test. Did you set the rate to 10Mhz for touch and 40Mhz for display, or both at a fixed rate?

[robert-hh]

I tested both at 1Mhz, no freq change (yet). The XPT2046 only supports 1 MHz.
Edit: Reading the data sheet I see that the XPT2046 works up to 2.5 MHz (200ns high/low time of the clock).
Edit 2: Switching baud rate could get difficult when using the touch interrupt

[robert-hh]

So I tested now setting the SPI baudrate to 40MHz before talking to the display and setting it to 2.5 Mhz back after the call using spi.init(baudrate=xxxx). It works. A touch interrupt may be missed is the touch happens during a call to the display.

[shariltumin]

Nice!, thanks. I will also do some tests.

[shariltumin]

I can confirm that the setup works with a single SPI object. My solution is to make a small change to "xpt2046.py".

...
    def raw_touch(self):
        """Read raw X,Y touch values.

        Returns:
            tuple(int, int): X, Y
        """
        self.spi.init(baudrate=2000000) # set rate to 2Mhz
        x = self.send_command(self.GET_X)
        y = self.send_command(self.GET_Y)
        self.spi.init(baudrate=5000000) # set rate to 5Mhz
        if self.x_min <= x <= self.x_max and self.y_min <= y <= self.y_max:
            return (x, y)
        else:
            return None
...

And this is my "test.py"

from machine import Pin, SPI
import esp
from ili9341 import Display, color565
from xpt2046 import Touch
from xglcd_font import XglcdFont

esp.osdebug(None)

spi = SPI(1, baudrate=50000000, sck=Pin(14), mosi=Pin(13), miso=Pin(12))

# display
display = Display(spi, dc=Pin(4), cs=Pin(16), rst=Pin(17), width=240, height=320, rotation=180)
print('Loading font unispace')
unispace = XglcdFont('Unispace12x24.c', 12, 24)

# touch 
def handle_touch(x,y):	# Display x and y of touch
    print(f'touched at x:{x} y:{y}')
touch = Touch(spi, cs=Pin(33), int_pin=Pin(32), int_handler=handle_touch)
    
def main():
    lines = [f'This is line {n+1}' for n in range(11)]
    y = 0
    for l in range(len(lines)):
        display.draw_text(0, y, lines[l], unispace, color565(255, 255-y, y), background=color565(0,0,0))
        y += 28

main()

Works on esp32 board:

>>> import test
Loading font unispace
>>> touched at x:90 y:181
touched at x:84 y:190
touched at x:94 y:194
touched at x:104 y:174
touched at x:113 y:181
touched at x:121 y:177
touched at x:89 y:177
touched at x:104 y:178
touched at x:97 y:175
touched at x:27 y:303
touched at x:17 y:41
touched at x:178 y:51
touched at x:193 y:305

[robert-hh]

It is a good suggestion that the respective driver sets the SPI clock top a feasible rate. But I would not reset it in the driver to a different rate. So the touch driver would set it to 2MHz, and leave it to the other parties to set SPI baud rate to an appropriate value for them.

P.S.: In the test script your initial SPI baud rate is 50MHz, if I count the zeroes right. And just for interest, which type of display/touch did you use. One with combined SPI port like @MrTinkerman or one with separate SPI ports, wired to the same bus?

[shariltumin]

The display I tested is like the one you have, SKU: MSP3218. Connect the display
and touch on the same bus.

[MrTinkerman]

Thanks for looking into this guys.

@robert-hh: Thanks for mentioning that the 'rdagger-display' (with separate SPI's) works on a P Pico W.
I actually ordered 2 displays and Pico W's before I read your post, nice to know it should work.

@shariltumin: I just tried your suggestion to make that change to the baudrate in xpt2046.py and also tried your test code.
Sorry to say but it doesn't work over here. I went on to test with my code below. I have made a truth table with results.
I do have to mention that in between changing option I had to hard reset my board.

At this point I will no longer be testing with the XIAO ESP32-S3.
I will wait for my new displays and Pico W's and go from there.

Truth table mentioned above:

show_text	use_touch	shari_edit	works
1		0		1		1
0		1		1		0
1		1		1		0

1		0		0		1
0		1		0		1
1		1		0		0

Board: XIAO ESP32-S3
Libaries:
https://github.com/rdagger/micropython-ili9341/blob/master/ili9341.py
https://github.com/rdagger/micropython-ili9341/blob/master/xpt2046.py

Code shows initial baudrate of 20_000_000 but an initial baudrate of 1_000_000
yields the same results.

Test code:

from machine import Pin, SPI
import time, esp
from ili9341 import Display, color565
from xpt2046 import Touch
from xglcd_font import XglcdFont

esp.osdebug(None)

show_text = 1						# Choose to display text on display,
use_touch = 1						# and/or test touch functionality

class GV():	pass					# Global Variables class
gv = GV()


def handle_touch(x,y):			        # Display x and y of touch
    
    print(f'touch x,y: {x} {y}')
    
    
def init():
    
    gv.spi = SPI(1, baudrate=20_000_000, sck=Pin(7), mosi=Pin(9), miso=Pin(8))
    
    if use_touch:
        
        gv.touch = Touch(gv.spi, cs=Pin(4), int_pin=Pin(43),
                         int_handler=handle_touch)
        
    if show_text:													
        
        gv.display = Display(gv.spi, dc=Pin(6), cs=Pin(5), rst=Pin(44),
                             width=240, height=320, rotation=180)
    
    main()


def main():
    
    if show_text:
        
        print('Loading font unispace')
        unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)

        lines = [f'This is line {n}' for n in range(11)]
        
        y = 0
        
        for l in range(len(lines)):
            
            gv.display.draw_text(0, y, lines[l], unispace,
                                 color565(0, 150, 0),
                                 background=color565(0,0,0))
            y += 28
    
    if use_touch:
        
        print(f'Waiting for touch input')
            
        while True:
            
            print(gv.touch.get_touch())
            time.sleep_ms(1000)


init()

[shariltumin]

Sorry to hear it did not work for you. I have a couple of esp32s3 and esp32s3, I will try running test on them.

[MrTinkerman]

Thanks, I appreciate your involvement. But as I said, I will wait for my new displays and Pico W's.
If you want to delve into this further, do it only for your own curiosity.

[MrTinkerman]

I got my Pico's and displays today and I can confirm that my test code as posted before works.
As robert-hh mentioned both the display and touch can be on the same SPI @ max baudrate of 15_000_000 MHz.

I think the conclusion is that the board I started out with just doesn't play nice with Micropython.

Thanks guys!

[robert-hh]

The touch should not work at 15 MHz. In the previous set-up the ESP32 should be fine, only the display/touch combo is questionable.

[MrTinkerman]

Yeah, but I have the code below running on a Pi Pico and the 'rdagger-display' (search for: '2.8 tft spi 240x320 v1.2')

Touch works up until and including 15_624_999 but fails @ 15_625_000

from machine import Pin, SPI
import time
from ili9341 import Display, color565
from xpt2046 import Touch
from xglcd_font import XglcdFont


def handle_touch(x,y): print(f'touch x,y: {x} {y}')

fnt = XglcdFont('fonts/Unispace12x24.c', 12, 24)

clr = color565(0, 150, 0)

spi = SPI(1, baudrate=15_000_000,
          sck=Pin(10), mosi=Pin(11), miso=Pin(12))

dsp = Display(spi, dc=Pin(8), cs=Pin(13), rst=Pin(9),
              width=240, height=320, rotation=0)
                     
tch = Touch(spi, cs=Pin(7), int_pin=Pin(6),
            int_handler=handle_touch)

y,n = 0,0

while True:
    
    dsp.draw_text(0, y, str(time.ticks_us()**2), fnt, clr)
    
    y += 28
    n += 1
    
    if y >320-24: y=0

[robert-hh]

Touch works up until and including 15_624_999 but fails @ 15_625_000

The data sheet of the XPT2046 sets a limit at 2.5MHz. For the ILI9341 it's 8 Mhz for write and 6 MHz for read. It's not advisable to go beyond these limits. It may work now, but fail later under different environmental conditions. @shariltumin and me tested switching the baud rate when needed.
Note: when setting the baud rate to 15Mhz or 15_624_999, the actual baud rate is 12.5Mhz, when setting it to 15_625_000, it is a mix of 12.5MHz and 16.666MHz cycles.

[MrTinkerman]

Thanks for mentioning, I'll take into consideration.
And thanks for doing all this detailed analyses.