Touch driver requerements, for example for CYD ESP32-2432S024C

[zoland]

Are there any basic requirements for the development of touch-drivers - functions and variables that are used by the kernel, polling methods, and where should binding to objects or widgets on the screen take place? For example, I have CYD ESP32-2432S024C c Touch on I2C. As a basis, I used https://github.com/jtobinart/Micropython_CYDc_ESP32-2432S024C ?tab=readme-ov-file with the ability to remove a touch at one or two points.

[peterhinch]

A quick web search suggests it uses an ILI9341 display controller and CST820 touch controller. The ILI9341 is supported as is the CST816s. I would think there is a good chance that the CST816s driver will work. Have you tried it?

[zoland]

Hi, Piter,
glad to see you soon. Last time we discuss some asyncio aspects. And now - your GUI.

I was surprised, because I copy all library source, running simple test and view nothing, also in the morning I really saw line and two boxes. I knew about CST 820 touch, but was not shure, that CST816S are the same for your GUI. But now I'm trying soon to see result from simple.py

As I sad early lib https://github.com/jtobinart/Micropython_CYDc_ESP32-2432S024C with the same Pins work correctly.

By the way, what about idea most Widget visualisation make as Icon Fonts? 

[zoland]

Problem with Display bben solved by adding Turn ON backlight

# Use hardSPI (bus 1)
spi = SPI(1, sck=Pin(14), mosi=Pin(13), baudrate=40000000)
# Precaution before instantiating framebuf
gc.collect()
ssd = SSD(spi, height=240, width=320, dc=pdc, cs=pcs, rst=prst, usd=True)  # 240x320 default

# Backlight
tft_bl = Pin(27, Pin.OUT) # !!!!!!!!!
tft_bl.value(1)                   # !!!!!!!!! Turn on backlight

[zoland]

Minimal Touch driver in Peter Hinch style for CYD ESP32-2432S024C
C means Capasity, another version R means Resistive.
This driver for C.
Full driver more complex

# cst820.py Capacitive touch driver, including for **CYD ESP32-2432S024C** 

# Released under the MIT License (MIT). See LICENSE.
# Copyright (c) 2024 Peter Hinch

# Created 21-dec-2024 @ZolAnd

# It is minimal, providing only the required functionality for the touh GUI.
# Sources: datasheet, Adafruit driver
# James Tobin : https://github.com/jtobinart/Micropython_CYDc_ESP32-2432S024C
# https://github.com/codekulturbonn/espocto/blob/main/src/CST820.cpp
# https://github.com/hi631/ESP32-2432S024C/tree/master

# I2C clock rate 10KHz - 400KHz

# 0 <= x < 240
# 0 <= y < 240

_verbose = True

from time import sleep_ms
from machine import Pin
import struct
from touch.touch import ABCTouch

_CST8xx_ADDR    = 0x15  # I2C адрес (проверьте по datasheet)
_CHIP_TYPE	      = const(0xA7)
# Untested Chip IDs which may use different registers
# If future chips do use different registers, it may be best to
# subclass each one and override the register constants
_CID_CST816S    = 0xB4
_CID_CST816T    = 0xB5
_CID_CST816D    = 0xB6
_CID_CST820 	    = 0xB7

_SINGLE_TAP	    = 0x05	 # Gesture single tap    


class CST820(ABCTouch):
    
    def __init__(self, i2c, ssd ):
        super().__init__(ssd, None)
        self.i2c	   = i2c
        self.addr	   = _CST8xx_ADDR
        self.version = bytearray(3)
        
        i2c.writeto_mem(_CST8xx_ADDR, 0xfe, b'\xff') # prohibit automatic switching to low-power mode
        _verbose and print("Chip_type: {:02X}".format(self.who_am_i()))

    
    def who_am_i(self):
        self.i2c.writeto(_CST8xx_ADDR, bytes([_CHIP_TYPE]))
        return self.i2c.readfrom(_CST8xx_ADDR, 1)[0]


    def acquire(self):
        sleep_ms(5)
        gest, fingers, self._x, self._y = struct.unpack('>BBHH', self.i2c.readfrom_mem(_CST8xx_ADDR, 0x01, 6))
        _verbose and print(f'Gest: {gest} Touches: {fingers} : {self._x} {self._y}')
        
        return False if gest == _SINGLE_TAP or fingers is 1 else True

[zoland]

# hardware_setup.py for CYDc_ESP32-2432S024C --- ili9341_CST820_ESP32

# Released under the MIT License (MIT). See LICENSE.
# Copyright (c) 2021-2024 Peter Hinch
# 17-dec-2024 ZolAnd

# ESP32 Display.   --- ili9341 240x320
# Touch controller --- CST820 

from machine import Pin, SPI, SoftI2C
import gc
from drivers.ili93xx.ili9341 import ILI9341 as SSD


'''  Pin Reference
######################################################'''
'''
IO Pins
D    0   Digital   Boot Button
D    2   Digital   Display                          - Display:		TFT_RS / TFT_DC
    12   Digital   Display                          - Display:		TFT_SDO / TFT_MISO [HSPI]
D   13   Digital   Display                          - Display:		TFT_SDI / TFT_MOSI [HSPI]
D   14   Digital   Display                          - Display:		TFT_SCK [HSPI]
D   15   Digital   Display                          - Display:		TFT_CS [HSPI]
T   21   Digital   Touch, Connector P3 & CN1        - Touch CST820:	CTP_INT / I2C SDA
T   25   Digital   Touch CST920                     - Touch CST820:	CTP_RST
D   27   Digital   Display                          - Display:		TFT_BL (BackLight)
T   32   Digital   Touch CST820                     - Touch CST820:	CTP_SCL
T   33   Digital   Touch CST820                     - Touch CST820:	CTP_SDA
'''


''' OUTPUT: DISPLAY setup
##########################################'''
prst = Pin( 0, Pin.OUT, value=1)
pdc  = Pin( 2, Pin.OUT, value=0)  # Arbitrary pins
pcs  = Pin(15, Pin.OUT, value=1)

# Use hardSPI (bus 1)
spi = SPI(1, sck=Pin(14), mosi=Pin(13), baudrate=40000000)
# Precaution before instantiating framebuf
gc.collect()
ssd = SSD(spi, height=240, width=320, dc=pdc, cs=pcs, rst=prst, usd=True)  # 240x320 default

# Backlight
tft_bl = Pin(27, Pin.OUT)
tft_bl.value(1) #Turn on backlight


''' IMPORTANT! Not to use interrupt '''
from touch.cst820 import CST820
i2c = SoftI2C(scl=Pin(32), sda=Pin(33), freq=400000)
tpad = CST820(i2c, ssd)
# Assign orientation and calibration values.
#          xpix, ypix, xmin, ymin, xmax, ymax, trans,   rr,    rc):
tpad.init(  240,  320,  120,  314, 3923, 3878,  True, True, False)


''' GUI configuration
##########################################'''
from gui.core.tgui import Display
display = Display(ssd, tpad)

[zoland]

This works, but not with all the examples, even after launching setup.py and tpad corrections.init(...)

[peterhinch]

I've now had a chance to look into this. A datasheet seems unobtainable - if you know a source, please point me at it. I have found this LilyGo driver which supports various CST816 variants and the CST820: evidently they are very similar.

I had difficulty with the CST816s. It wouldn't respond to I2C.scan() and it became evident that it only responded to I2C transactions for a period after it generated an IRQ. This is bizarre behaviour and is the reason for the rather odd design of my driver. The fact that your version almost works indicates that the CST820 does not suffer from this problem.

I have therefore attempted to write a minimal CST820 driver based on my CST816s version, your above code, and the LilyGo driver. As I don't have any hardware you might like to test this.

from time import sleep_ms
from .touch import ABCTouch

class CST820(ABCTouch):
    def __init__(self, i2c, rst, ssd, addr=0x15):
        super().__init__(ssd, None)
        self.i2c = i2c
        self.addr = addr
        rst(0)
        sleep_ms(5)
        rst(1)
        sleep_ms(50)
        i2c.writeto_mem(addr, 0xfe, b'\xff') # prohibit automatic switching to low-power mode
        # i2c.writeto_mem(addr, 0xfe, b'\x01') # Or should it be this???

    def acquire(self, buf=bytearray(6)):
        self.i2c.readfrom_mem_into(self.addr, 0x01, buf)
        self._x = ((buf[2] & 0xF) << 8) + buf[3]
        self._y = ((buf[4] & 0xF) << 8) + buf[5]
        # Gesture == 5 or event == 1: touch released
        return buf[0] == 5 or (buf[2] & 0x40)

    def version(self, buf=bytearray(3)):  # Are there 3 bytes or 1???
        self.i2c.readfrom_mem_into(self.addr, 0xA7, buf)

Detection of touch release differs from your version.

Re initialisation.

I have included your line that prevents low power mode: note that the LilyGo code writes 1 to register 0xFE. I have not seen any ill effects from not doing this on CST816s: this is probably because the touch GUI polls the device continuously.

I think a hardware reset should be applied.

Requests

If this driver works, please could you report what is returned by .version(). Also please could you try removing the line that disables auto-sleep.

[zoland]

Version returned 0xB7 value, and chip photo show CST820 too on CYD ESP32-2432S024C board.

You right - documentation is very poor.

My best source - https://github.com/jtobinart/Micropython_CYDc_ESP32-2432S024C, that work fine, other sources researched by me was not so interesting.

LiluGo code constants look the same, but IRQ in one of source strictly been not recommended. Reset Pin not used too.

[zoland]

In version() - 1 byte is enough

'''# i2c.writeto_mem(addr, 0xfe, b'\x01') # Or should it be this???''' - I not found this action in sources, so I not use it

In my tests, the Gesture value always remained zero no matter what efforts

[zoland]

By the way - "event" means number of fingers? Or it is another event?

"""gest, fingers, self._x, self._y = struct.unpack('>BBHH', self.i2c.readfrom_mem(_CST8xx_ADDR, 0x01, 6))"""

0x01 addr - Gesture
0x02 addr- Fingers (multitouch)
0x03-0x04 - raw X
0x05-0x06 - raw Y

but you test high bit located on addr(0x03) & 0x04. I not found any info about it

I find only Data Shits for ESP32-2432S028.Specifications-EN and Data Sheets for CST816S and CST826, I can send it to email

[peterhinch]

The link you posted led to this schatic which shows touch chip reset on GPIO25. At last, a legible schematic!

Version returned 0xB7 value

That conforms with the LilyGo code.

The sources for my CST816s driver are listed in the code comments, in particular this driver. Its code comments give the meanings of the first four bytes of the data from the chip.

I've just spotted a mistake in my code: the sense of acquire is wrong. It should read

    def acquire(self, buf=bytearray(6)):
        self.i2c.readfrom_mem_into(self.addr, 0x01, buf)
        self._x = ((buf[2] & 0xF) << 8) + buf[3]
        self._y = ((buf[4] & 0xF) << 8) + buf[5]
        # Gesture == 5 or event == 1: touch released
        return not (buf[0] == 5 or (buf[2] & 0x40))

Please give that a try.

Failing this I guess I'll have to buy one of these things :)

[zoland]

Hmmm, what means Event 1 -UP and 2 - Contact? Do you have any ideas?

struct data_struct {
  byte gestureID; // Gesture ID
  byte points;  // Number of touch points
  byte event; // Event (0 = Down, 1 = Up, 2 = Contact)
  int x;
  int y;
  uint8_t version;
  uint8_t versionInfo[3];
};

CST 820 support multitouch, so addr(0x02) may have value up to five, that's why I prefered to test understandable "fingers" than unrnown "event". I don't know which way be better.
I tested with my driver 1 or 2 fingers - addr(0x01) gesture (always 0) addr(0x02) - num.fingers or 0, addr(0x03-0x04) X1, addr(0x05-0x06) Y1, , addr(0x07-0x08) X2, addr(0x09-0x0A) Y2

As I understand CST816 supported only touched one finger

Your driver I plain to test tommorow

[zoland]

вс, 22 дек. 2024 г. в 22:07, Peter Hinch ***@***.***>:

…

The link you posted led to this schatic <https://github.com/jtobinart/Micropython_CYDc_ESP32-2432S024C/blob/main/resources/5-Schematic/2432S024-2-V1.0.png> which shows touch chip reset on GPIO25. At last, a legible schematic! Version returned 0xB7 value That conforms with the LilyGo code. The sources for my CST816s driver are listed in the code comments, in particular this driver <https://github.com/fbiego/CST816S/blob/main/CST816S.cpp>. Its code comments give the meanings of the first four bytes of the data from the chip. I've just spotted a mistake in my code: the sense of acquire is wrong. It should read def acquire(self, buf=bytearray(6)): self.i2c.readfrom_mem_into(self.addr, 0x01, buf) self._x = ((buf[2] & 0xF) << 8) + buf[3] self._y = ((buf[4] & 0xF) << 8) + buf[5] # Gesture == 5 or event == 1: touch released return not (buf[0] == 5 or (buf[2] & 0x40)) Please give that a try. Failing this I guess I'll have to buy one of these things :) — Reply to this email directly, view it on GitHub <#19 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AIMPJDFIZIR6YDCBAB5K7WD2G3ITVAVCNFSM6AAAAABT2K7HWKVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDKNJYGQ4DMNBRGY> . You are receiving this because you were mentioned.Message ID: ***@***.***>

-- С уважением, Золотарёв А.В.

[zoland]

I think

    def version(self): 
        return self.i2c.readfrom_mem(self.addr, 0xA7, 1)[0]

equal

    def version(self): 
        self.i2c.writeto(self.addr, bytes([0xA7]))
        return self.i2c.readfrom(self.addr, 1)[0]

but lighter