CST816S input driver i2c failed to read

RE: CST816S input driver i2c failed to read

nanangcreacoll — Tue, 27 May 2025 03:53:34 GMT

That config is deprecated, set this in device tree:

&uicr {
	nfct-pins-as-gpios;
};

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Tue, 20 May 2025 12:52:35 GMT

Try to set CONFIG_NFCT_PINS_AS_GPIOS=y.

RE: CST816S input driver i2c failed to read

nanangcreacoll — Thu, 15 May 2025 02:19:40 GMT

Still nothing on the I2C output, just a low signal on reset in I2C.

There may be something with the PCF8574 firmware (with other platforms) that triggers I2C on the nRF, I don't know about that yet.

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Mon, 05 May 2025 07:17:14 GMT

Hm, if the pins works but I2C does not do anything, I am getting out of ideas here.

From your trace below, you get nothing on I2C. That is odd, as the nRF should send something.
Perhaps it is just going to fast, and the oscilloscope does not pick up the signal if it is not repeated?

Can you try to look at the I2C lines again, and then make them log for a longer time. Then reset the device multople times, and see if you can see some initial I2C communication. Do you still see nothing?

RE: CST816S input driver i2c failed to read

nanangcreacoll — Mon, 05 May 2025 07:09:14 GMT

I have tried the blinky sample for the SCL and SDA pins (GPIO 9 and 10) and it works. As for other pins for LCD display such as SPI, backlight, and Interrupt, all work fine. It can run the display and provide log message output for interrupts.

blinky sample code:

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <stdio.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>

/* 1000 msec = 1 sec */
#define SLEEP_TIME_MS   1000

/* The devicetree node identifier for the "led0" alias. */
#define LED0_NODE DT_ALIAS(led0)
#define LED1_NODE DT_ALIAS(led1)

/*
 * A build error on this line means your board is unsupported.
 * See the sample documentation for information on how to fix this.
 */
static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios);
static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios);

int main(void)
{
	int ret;
	bool led_state = true;

	if (!gpio_is_ready_dt(&led0)) {
		return 0;
	}
	if (!gpio_is_ready_dt(&led1)) {
		return 0;
	}

	ret = gpio_pin_configure_dt(&led0, GPIO_OUTPUT_ACTIVE);
	if (ret < 0) {
		return 0;
	}
	ret = gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE);
	if (ret < 0) {
		return 0;
	}

	while (1) {
		ret = gpio_pin_toggle_dt(&led0);
		if (ret < 0) {
			return 0;
		}
		ret = gpio_pin_toggle_dt(&led1);
		if (ret < 0) {
			return 0;
		}

		led_state = !led_state;
		printf("LED state: %s\n", led_state ? "ON" : "OFF");
		k_msleep(SLEEP_TIME_MS);
	}
	return 0;
}

overlay file:

/ {
    aliases {
        led0 = &led0;
        led1 = &led1;
    };

    leds {
        compatible = "gpio-leds";
        led0: led0 {
            label = "LED0";
            gpios = <&gpio0 9 GPIO_ACTIVE_LOW>;
        };
        led1: led1 {
            label = "LED1";
            gpios = <&gpio0 10 GPIO_ACTIVE_LOW>;
        };
    };
};

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Mon, 05 May 2025 06:05:32 GMT

Thanks for the clarifications, I edited them into the summary.

Let us focus on Test 1 for now. Can you try to use the blinky sample to "blink" on the pins that you use for the LCD display? This is a good way to see if you can control those pins at all from the MCU.

RE: CST816S input driver i2c failed to read

nanangcreacoll — Mon, 05 May 2025 02:50:58 GMT

In test 1 and test 2, the sensor location is on LCD display which is connected by wire via a socket to nRF custom board. In test 3, it uses the nRF custom board, but the software was in another framework. In test 4, yes, it will work if done right after test 3.

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Fri, 02 May 2025 10:29:35 GMT

Let me try to summarize this ticket, to get an overview. Could you go over and then correct me anywhere I am wrong? I put a question mark after the ones I am unsure of.
You have tested two different sensors over I2C, and here are the results:

EDITED: based on later answers.

CST816S

SDK version: v2.7.0

Test 1:
Board: nRF52 custom board
Sensor location: Wired LCD connected to nRF52 custom board
Software: Zephyr code
Result: Nothing on I2C lines

Test 2:
Board: nRF52 custom board?
Sensor location: Wired LCD connected to nRF52 custom board
Software: third party code
Result: I2C works

PCF8574

SDK version: v2.7.0

Test 3:
Board: nRF52 custom board
Sensor location: External board
Software: third party code
Result: I2C works

Test 4:
Board: nRF52 custom board
Sensor location: External board
Software: Zephyr code
Result: Nothing on I2C lines
Comment: Will work if done right after Test 3

RE: CST816S input driver i2c failed to read

nanangcreacoll — Fri, 25 Apr 2025 08:30:54 GMT

When I tried with PCF8574, I actually tried it first with another platform to read and write to PCF8574 (it can read and write), then back to zephyr and it works. If I try directly with zephyr, it can't read and write to PCF8574.

RE: CST816S input driver i2c failed to read

nanangcreacoll — Fri, 25 Apr 2025 07:07:45 GMT

I use this board, connect the touch screen with the socket on the board.

I have a PCF8574 GPIO Expander that I am using to try out I2C, it can read and write to the PCF8574.

Main code with PCF8574:

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/i2c.h>

#define LOG_LEVEL LOG_LEVEL_DBG
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app, LOG_LEVEL);

#define PCF8574_NODE DT_NODELABEL(pcf8574)

int main(void)
{
        const struct i2c_dt_spec pcf8574 = I2C_DT_SPEC_GET(PCF8574_NODE);
        if (!i2c_is_ready_dt(&pcf8574))
        {
                LOG_ERR("I2C device not ready");
                return -ENODEV;
        }

        int ret;
        uint8_t data = 0;
        
        ret = i2c_read_dt(&pcf8574, &data, sizeof(data));
        if (ret < 0)
        {
                LOG_ERR("Failed to read data: %d", ret);
                return ret;
        }
        LOG_DBG("Initial data read: 0x%02X", data);

        while(1)
        {
                uint8_t read_data;
                
                ret = i2c_write_read_dt(&pcf8574, &data, sizeof(data), &read_data, sizeof(read_data));
                if (ret < 0)
                {
                        LOG_ERR("Failed to write/read data: %d", ret);
                }
                LOG_DBG("Wrote data: 0x%02X, Read data: 0x%02X", data, read_data);

                if (data == 0)
                {
                        data = 1;
                }
                else if (data & 0x80)
                {
                        data = 0;
                }
                else
                {
                        data <<= 1;
                }
                
                k_msleep(1000);
        }
        return 0;
}

Output log:

** Booting nRF Connect SDK v2.7.0-5cb85570ca43 ***
*** Using Zephyr OS v3.6.99-100befc70c74 ***
[00:00:00.391,174] <dbg> app: main: Initial data read: 0xFF
[00:00:00.391,387] <dbg> app: main: Wrote data: 0xFF, Read data: 0xFF
[00:00:01.391,632] <dbg> app: main: Wrote data: 0x00, Read data: 0x00
[00:00:02.391,967] <dbg> app: main: Wrote data: 0x01, Read data: 0x01
[00:00:03.392,303] <dbg> app: main: Wrote data: 0x02, Read data: 0x02
[00:00:04.392,639] <dbg> app: main: Wrote data: 0x04, Read data: 0x04
[00:00:05.392,974] <dbg> app: main: Wrote data: 0x08, Read data: 0x08
[00:00:06.393,310] <dbg> app: main: Wrote data: 0x10, Read data: 0x10
[00:00:07.393,646] <dbg> app: main: Wrote data: 0x20, Read data: 0x20
[00:00:08.393,981] <dbg> app: main: Wrote data: 0x40, Read data: 0x40
[00:00:09.394,317] <dbg> app: main: Wrote data: 0x80, Read data: 0x80

Is there a possible problem with the board? I've used it with other platforms and it works fine.

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Thu, 24 Apr 2025 16:44:37 GMT

[quote user="nanangcreacoll"] I try directly using I2C to initialize CST816S. I try to make my own device tree binding for CST816S. I still don't know which part I should fix, I2C still can't read the chip. RST and IRQ gpio work fine.[/quote]

Alright, then we have tried two different ways to read the CST816S over I2C.

At this point, I think it would be a good idea to look at the hardware.

How do you connect the CST to the nRF?
Do you have another I2C device that you can try to read with the nRF, to verify that the I2C code work?

RE: CST816S input driver i2c failed to read

nanangcreacoll — Wed, 23 Apr 2025 07:49:31 GMT

Here I try directly using I2C to initialize CST816S. I try to make my own device tree binding for CST816S. I still don't know which part I should fix, I2C still can't read the chip. RST and IRQ gpio work fine.

overlay file:

&i2c1 {
	cst816s: cst816s@15 {
		compatible = "cst816s";
		status = "okay";
		reg = <0x15>;
		irq-gpios = <&gpio0 26 GPIO_ACTIVE_LOW>;
		rst-gpios = <&gpio0 21 GPIO_ACTIVE_LOW>;
	};
};

main code:

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>

#define LOG_LEVEL LOG_LEVEL_DBG
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(app, LOG_LEVEL);

#define CST816S_NODE DT_NODELABEL(cst816s)

#define CST816S_I2C_ADDR 0x15
#define CST816S_I2C_CHIP_ID_REG 0xA7

struct cst816s_data
{
        const struct i2c_dt_spec *i2c;
        struct k_work work;
        struct gpio_callback irq_gpio_cb;
};

static int cst816s_reset(const struct gpio_dt_spec *rst_gpio)
{
        LOG_DBG("CST816S Reset");

        int ret;

        if (!gpio_is_ready_dt(rst_gpio))
        {
                LOG_ERR("RST GPIO not ready");
                return -ENODEV;
        }

        ret = gpio_pin_configure_dt(rst_gpio, GPIO_OUTPUT);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure RST GPIO: %d", ret);
                return ret;
        }
        
        ret = gpio_pin_set_dt(rst_gpio, 1);
        if (ret < 0)
        {
                LOG_ERR("Failed to set RST GPIO: %d", ret);
                return ret;
        }
        k_msleep(5);
        ret = gpio_pin_set_dt(rst_gpio, 0);
        if (ret < 0)
        {
                LOG_ERR("Failed to set RST GPIO: %d", ret);
                return ret;
        }
        k_msleep(50);

        return 0;
}

static void cst816s_irq_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
{
        struct cst816s_data *data = CONTAINER_OF(cb, struct cst816s_data, irq_gpio_cb);

        k_work_submit(&data->work);
}

static int cst816s_irq_init(const struct gpio_dt_spec *irq_gpio, struct gpio_callback *irq_gpio_cb)
{
        LOG_DBG("CST816S IRQ Initialization");

        int ret;

        if (!gpio_is_ready_dt(irq_gpio))
        {
                LOG_ERR("IRQ GPIO not ready");
                return -ENODEV;
        }

        ret = gpio_pin_configure_dt(irq_gpio, GPIO_INPUT);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure IRQ GPIO: %d", ret);
                return ret;
        }

        ret = gpio_pin_interrupt_configure_dt(irq_gpio, GPIO_INT_EDGE_TO_ACTIVE);
        if (ret < 0)
        {
                LOG_ERR("Failed to configure IRQ GPIO interrupt: %d", ret);
                return ret;
        }

        gpio_init_callback(irq_gpio_cb, cst816s_irq_handler, BIT(irq_gpio->pin));
        ret = gpio_add_callback(irq_gpio->port, irq_gpio_cb);
        if (ret < 0)
        {
                LOG_ERR("Failed to add IRQ GPIO callback: %d", ret);
                return ret;
        }

        return 0;
}

static int cst816s_process(const struct i2c_dt_spec *cst816s)
{
        LOG_DBG("CST816S Process");

        if (!i2c_is_ready_dt(cst816s))
        {
                LOG_ERR("CST816S I2C device not ready");
                return -ENODEV;
        }

        return 0;
}

static void cst816s_work_handler(struct k_work *work)
{
        struct cst816s_data *data = CONTAINER_OF(work, struct cst816s_data, work);
        
        cst816s_process(data->i2c);
}

static int cst816s_init (const struct i2c_dt_spec *cst816s, const struct gpio_dt_spec *rst_gpio, const struct gpio_dt_spec *irq_gpio, struct cst816s_data *data)
{
        LOG_DBG("CST816S Initialization");

        int ret;
        uint8_t chip_id = 0;

        ret = cst816s_reset(rst_gpio);
        if (ret < 0)
        {
                LOG_ERR("Failed to reset CST816S chip: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S Chip Reset complete");

        ret = cst816s_irq_init(irq_gpio, &data->irq_gpio_cb);
        if (ret < 0)
        {
                LOG_ERR("Failed to initialize CST816S IRQ: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S IRQ initialized successfully");

        ret = i2c_reg_read_byte_dt(cst816s, CST816S_I2C_CHIP_ID_REG, &chip_id);
        if (ret < 0)
        {
                LOG_ERR("Failed to read chip ID: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S Chip ID: 0x%02X", chip_id);

        return 0;
}

int main()
{
        LOG_DBG("CST816S Touchscreen I2C Test");

        const struct i2c_dt_spec cst816s_i2c = I2C_DT_SPEC_GET(CST816S_NODE);
        if (!i2c_is_ready_dt(&cst816s_i2c))
        {
                LOG_ERR("CST816S I2C device not ready");
                return -ENODEV;
        }
        LOG_DBG("CST816S I2C device (bus %d, addr 0x%02X)", cst816s_i2c.bus->name, cst816s_i2c.addr);

        const struct gpio_dt_spec cst816s_rst_gpio = GPIO_DT_SPEC_GET(CST816S_NODE, rst_gpios);
        if (!gpio_is_ready_dt(&cst816s_rst_gpio))
        {
                LOG_ERR("RST GPIO not ready");
                return -ENODEV;
        }
        LOG_DBG("RST GPIO (port %d, pin %d)", cst816s_rst_gpio.port->name, cst816s_rst_gpio.pin);
        const struct gpio_dt_spec cst816s_irq_gpio = GPIO_DT_SPEC_GET(CST816S_NODE, irq_gpios);
        if (!gpio_is_ready_dt(&cst816s_irq_gpio))
        {
                LOG_ERR("IRQ GPIO not ready");
                return -ENODEV;
        }
        LOG_DBG("IRQ GPIO (port %d, pin %d)", cst816s_irq_gpio.port->name, cst816s_irq_gpio.pin);

        struct cst816s_data data;
        data.i2c = &cst816s_i2c;

        k_work_init(&data.work, cst816s_work_handler);

        int ret;

        ret = cst816s_init(&cst816s_i2c, &cst816s_rst_gpio, &cst816s_irq_gpio, &data);
        if (ret < 0)
        {
                LOG_ERR("Failed to initialize CST816S: %d", ret);
                return ret;
        }
        LOG_DBG("CST816S initialized successfully");

        while(1)
        {
                k_msleep(1);
        }

        return 0;
}

log output:

*** Booting nRF Connect SDK v2.7.0-5cb85570ca43 ***
*** Using Zephyr OS v3.6.99-100befc70c74 ***
[00:00:00.431,335] <dbg> app: main: CST816S Touchscreen I2C Test
[00:00:00.431,365] <dbg> app: main: CST816S I2C device (bus i2c@40004000, addr 0x15)
[00:00:00.431,396] <dbg> app: main: RST GPIO (port gpio@50000000, pin 21)
[00:00:00.431,427] <dbg> app: main: IRQ GPIO (port gpio@50000000, pin 26)
[00:00:00.431,457] <dbg> app: cst816s_init: CST816S Initialization
[00:00:00.431,457] <dbg> app: cst816s_reset: CST816S Reset
[00:00:00.486,633] <dbg> app: cst816s_init: CST816S Chip Reset complete
[00:00:00.486,663] <dbg> app: cst816s_irq_init: CST816S IRQ Initialization
[00:00:00.486,694] <dbg> app: cst816s_init: CST816S IRQ initialized successfully
[00:00:00.486,785] <err> app: Failed to read chip ID: -5
[00:00:00.486,816] <err> app: Failed to initialize CST816S: -5
[00:16:50.213,226] <dbg> app: cst816s_process: CST816S Process

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Tue, 22 Apr 2025 10:17:50 GMT

Looks like you are using the cst816s drivers directly.
I found a Zephyr issue where another user has exactly the same issue:
https://github.com/zephyrproject-rtos/zephyr/discussions/74678. Im not sure if it is related or not, but worth knowing about.

[quote user="nanangcreacoll"]I2c readings with other framework:[/quote]

This is good to know. It shows that the hardware works correctly, and that this is a software issue.

I suggest that you start by trying to use I2C directly to read the device ID.
You can do this by following the DevAcademy Fundamentals: I2C lesson.

This way, you get some firmware to compare with. Then we can compare the working I2C with the cst816s driver.

RE: CST816S input driver i2c failed to read

nanangcreacoll — Thu, 17 Apr 2025 08:21:29 GMT

Hi, thanks for your response. As you can see, there is nothing on the i2c reading with zephyr. I have tried it with other frameworks and it still works fine. I'm still curious what makes i2c (with gpio sda 9 and gpio scl 10) not output any data, maybe I missed something when setting up the board devicetree or overlay.

I2c readings with other framework:

I2c readings with zephyr:

RE: CST816S input driver i2c failed to read

Sigurd Hellesvik — Wed, 16 Apr 2025 10:39:07 GMT

Hi,

Are you able to get logic analyzer or oscilloscope readings from the I2C?

Regards,
Sigurd Hellesvik