I2C communication between Renesas MCU(master) - nRF5340(slave).

Question

Hello Nordic Team, 
 I am using nRF5340 DK as a debugger/programmer to develop firmware for the Fanstel EV-WT02C40C module. My goal is to do i2c communication between Renesas MCU and EV-WT02C40C board with nRF Connect SDK . 
 I have a few i2c communication related questions and would appreciate clarification. 
 SDK: nRF Connect SDK v3.2.1 Toolchain: nRF Connect SDK Toolchain v3.2.1 
 here i'm considering renesas MCU as master and nrf5340 MCU as slave. renesas mcu send data to nrf5340 mcu which i will publish on server with the help of wifi and MQTT 
 which sample code should i refer for my i2c communication query?

Simon D-M · Answer

Hi, I've used the " custom_target " sample as a base for my small sample. I first encountered the same issue you had with the hard fault. However, this is because the sample used is not configured to use the config " CONFIG_I2C_TARGET_BUFFER_MODE " which is enabled by default. The result is that when the i2c receive a request, it tries to call a callback which is not implemented. Thus provoke a hard fault in the MCU. To fix that, we either need to deactivate that configuration or to implement these callbacks. I choose to implement the callbacks as it is preferable to use the "buffer mode". Here is the resulting code ( I tried on a nrf54l15 so the nrf5340 overlay hasn't been tested ): main.c /* * Copyright (c) 2024 Open Pixel Systems * * SPDX-License-Identifier: Apache-2.0 */ #include #include #include static const struct device *bus = DEVICE_DT_GET(DT_ALIAS(i2c_target)); static char last_byte; /* * @brief Callback which is called when a write request is received from the master. * @param config Pointer to the target configuration. */ int sample_target_write_requested_cb(struct i2c_target_config *config) { printk("sample target write requested "); return 0; } /* * @brief Callback which is called when a write is received from the master. * @param config Pointer to the target configuration. * @param val The byte received from the master. */ int sample_target_write_received_cb(struct i2c_target_config *config, uint8_t val) { printk("sample target write received: 0x%02x ", val); last_byte = val; return 0; } /* * @brief Callback which is called when a read request is received from the master. * @param config Pointer to the target configuration. * @param val Pointer to the byte to be sent to the master. */ int sample_target_read_requested_cb(struct i2c_target_config *config, uint8_t *val) { printk("sample target read request: 0x%02x ", *val); *val = 0x42; return 0; } /* * @brief Callback which is called when a read is processed from the master. * @param config Pointer to the target configuration. * @param val Pointer to the next byte to be sent to the master. */ int sample_target_read_processed_cb(struct i2c_target_config *config, uint8_t *val) { printk("sample target read processed: 0x%02x ", *val); *val = 0x43; return 0; } /* * @brief Callback which is called when the master sends a stop condition. * @param config Pointer to the target configuration. */ int sample_target_stop_cb(struct i2c_target_config *config) { printk("sample target stop callback "); return 0; } #ifdef CONFIG_I2C_TARGET_BUFFER_MODE /* * @brief Callback which is called when a write buffer is received from the master. * @param config Pointer to the target configuration. * @param data Pointer to the buffer received from the master. * @param size Size of the buffer received from the master. */ static void sample_target_buf_write_received_cb(struct i2c_target_config *config, uint8_t *data, uint32_t size) { printk("sample target buffer write received, size: %d ", size); for (uint32_t i = 0; i < size; i++) { printk("byte %d: 0x%02x ", i, data[i]); } } /* * @brief Callback which is called when a read buffer is requested from the master. * @param config Pointer to the target configuration. * @param data Pointer to the buffer to be sent to the master. * @param size Size of the buffer to be sent to the master. */ static int sample_target_buf_read_requested_cb(struct i2c_target_config *config, uint8_t **data, uint32_t *size) { printk("sample target buffer read requested "); static uint8_t buffer[5] = {0x44, 0x45, 0x46, 0x47, 0x48}; *data = buffer; *size = sizeof(buffer); return 0; } #endif /* CONFIG_I2C_TARGET_BUFFER_MODE */ static struct i2c_target_callbacks sample_target_callbacks = { .write_requested = sample_target_write_requested_cb, .write_received = sample_target_write_received_cb, .read_requested = sample_target_read_requested_cb, .read_processed = sample_target_read_processed_cb, .stop = sample_target_stop_cb, #ifdef CONFIG_I2C_TARGET_BUFFER_MODE .buf_write_received = sample_target_buf_write_received_cb, .buf_read_requested = sample_target_buf_read_requested_cb, #endif }; int main(void) { struct i2c_target_config target_cfg = { .address = 0x60, .callbacks = &sample_target_callbacks, }; printk("i2c custom target sample "); if (i2c_target_register(bus, &target_cfg) < 0) { printk("Failed to register target "); return -1; } while(1) { k_sleep(K_SECONDS(10)); } // never reached, but unregister the target before exiting if (i2c_target_unregister(bus, &target_cfg) < 0) { printk("Failed to unregister target "); return -1; } return 0; } nrf5340dk_nrf5340_cpuapp.overlay / { aliases { i2c-target = &i2c1; }; }; &i2c1 { compatible = "nordic,nrf-twis"; pinctrl-0 = <&i2c1_default>; pinctrl-1 = <&i2c1_sleep>; pinctrl-names = "default", "sleep"; status = "okay"; }; &pinctrl { i2c1_default: i2c1_default { group1 { psels = , ; bias-pull-up; }; }; i2c1_sleep: i2c1_sleep { group1 { psels = , ; low-power-enable; }; }; }; prj.conf CONFIG_I2C=y CONFIG_I2C_NRFX=y CONFIG_I2C_TARGET=y CONFIG_I2C_TARGET_BUFFER_MODE=y If you have any more questions / issue with the i2c target driver, feel free to ask ! Best regards, Simon D-M

Embedded developer0 · Answer

Hey Simon D-M , 
 Thank you very much for your help. 
 I managed to fix the I2C master transmit and receive issue. The problem was actually coming from the code snippet below: 
 static int sample_target_buf_read_requested_cb(struct i2c_target_config *config,
 uint8_t **data, uint32_t *size)
{
 // printk("sample target buffer read requested
");
 // static uint8_t buffer [1] = {0x44};
 *data = rx_buf;
 *size = sizeof(rx_buf);
 return 0;
} 
 When these two lines were enabled: 
 printk("sample target buffer read requested
");
static uint8_t buffer [1] = {0x44}; 
 they introduced a small delay. Since this function is executed inside a callback context, the delay was not acceptable and the I2C read operation was failing. 
 After commenting out these lines, the code works perfectly and the I2C master can now transmit and receive data correctly. 
 Thanks again for your support!

I2C communication between Renesas MCU(master) -> nRF5340(slave).