From: houchenyao Date: Sun, 17 Dec 2017 02:21:14 +0000 (+0800) Subject: test: components/driver: i2c case X-Git-Tag: v3.3-beta1~48^2 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=147447b13e54d072c379cde6082d1024762b1e08;p=esp-idf test: components/driver: i2c case --- diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index a206b9f6ec..d6d66fd50d 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1608,6 +1608,31 @@ UT_012_05: - UT_T1_1 - 8Mpsram +UT_014_01: + <<: *unit_test_template + tags: + - ESP32_IDF + - UT_T2_I2C + +UT_014_02: + <<: *unit_test_template + tags: + - ESP32_IDF + - UT_T2_I2C + +UT_014_03: + <<: *unit_test_template + tags: + - ESP32_IDF + - UT_T2_I2C + +UT_014_04: + <<: *unit_test_template + tags: + - ESP32_IDF + - UT_T2_I2C + - psram + UT_015_01: <<: *unit_test_template tags: diff --git a/components/driver/test/test_i2c.c b/components/driver/test/test_i2c.c new file mode 100644 index 0000000000..07432b002b --- /dev/null +++ b/components/driver/test/test_i2c.c @@ -0,0 +1,526 @@ +/** + * test environment UT_T2_I2C: + * please prepare two ESP32-WROVER-KIT board. + * Then connect GPIO18 and GPIO18, GPIO19 and GPIO19 between these two boards. + */ +#include +#include +#include "unity.h" +#include "test_utils.h" +#include "unity_config.h" +#include "driver/i2c.h" +#include "esp_attr.h" +#include "esp_log.h" +#include "soc/gpio_sig_map.h" +#include "soc/i2c_struct.h" +#include "soc/i2c_reg.h" +#include "esp_system.h" +#include "driver/pcnt.h" + + +#define DATA_LENGTH 512 /*! 1) { + i2c_master_read(cmd, data_rd, size - 1, ACK_VAL); + } + i2c_master_read_byte(cmd, data_rd + size - 1, NACK_VAL); + i2c_master_stop(cmd); + esp_err_t ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_RATE_MS); + i2c_cmd_link_delete(cmd); + return ret; +} + +static esp_err_t i2c_master_write_slave(i2c_port_t i2c_num, uint8_t *data_wr, size_t size) +{ + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + TEST_ESP_OK(i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | WRITE_BIT, ACK_CHECK_EN)); + TEST_ESP_OK(i2c_master_write(cmd, data_wr, size, ACK_CHECK_EN)); + TEST_ESP_OK(i2c_master_stop(cmd)); + esp_err_t ret = i2c_master_cmd_begin(i2c_num, cmd, 5000 / portTICK_RATE_MS); + i2c_cmd_link_delete(cmd); + return ret; +} + +// print the reading buffer +static void disp_buf(uint8_t *buf, int len) +{ + int i; + for (i = 0; i < len; i++) { + printf("%02x ", buf[i]); + if (( i + 1 ) % 16 == 0) { + printf("\n"); + } + } + printf("\n"); +} + +static i2c_config_t i2c_master_init() +{ + i2c_config_t conf_master = { + .mode = I2C_MODE_MASTER, + .sda_pullup_en = GPIO_PULLUP_ENABLE, + .scl_pullup_en = GPIO_PULLUP_ENABLE, + .master.clk_speed = I2C_MASTER_FREQ_HZ, + .sda_io_num = I2C_MASTER_SDA_IO, + .scl_io_num = I2C_MASTER_SCL_IO, + }; + return conf_master; +} + +static i2c_config_t i2c_slave_init() +{ + i2c_config_t conf_slave = { + .mode = I2C_MODE_SLAVE, + .sda_io_num = I2C_SLAVE_SDA_IO, + .scl_io_num = I2C_SLAVE_SCL_IO, + .sda_pullup_en = GPIO_PULLUP_ENABLE, + .scl_pullup_en = GPIO_PULLUP_ENABLE, + .slave.addr_10bit_en = 0, + .slave.slave_addr = ESP_SLAVE_ADDR, + }; + return conf_slave; +} + +TEST_CASE("I2C config test", "[i2c]") +{ + // master test + i2c_config_t conf_master = i2c_master_init(); + gpio_pullup_t sda_pull_up_en[2] = {GPIO_PULLUP_DISABLE, GPIO_PULLUP_ENABLE}; + gpio_pullup_t scl_pull_up_en[2] = {GPIO_PULLUP_DISABLE, GPIO_PULLUP_ENABLE}; + + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + conf_master.sda_pullup_en = sda_pull_up_en[i]; + conf_master.scl_pullup_en = scl_pull_up_en[j]; + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ASSERT_EQUAL_INT32(I2C[I2C_MASTER_NUM]->ctr.ms_mode, 1); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + TEST_ESP_OK(i2c_driver_delete(I2C_MASTER_NUM)); + } + } + + // slave test + i2c_config_t conf_slave = i2c_slave_init(); + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + conf_master.sda_pullup_en = sda_pull_up_en[i]; + conf_master.scl_pullup_en = scl_pull_up_en[j]; + conf_slave.sda_pullup_en = sda_pull_up_en[i]; + conf_slave.scl_pullup_en = scl_pull_up_en[j]; + TEST_ESP_OK(i2c_param_config( I2C_SLAVE_NUM, &conf_slave)); + TEST_ASSERT_EQUAL_INT32(I2C[I2C_SLAVE_NUM] -> ctr.ms_mode, 0); + TEST_ESP_OK(i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0)); + TEST_ESP_OK(i2c_driver_delete(I2C_SLAVE_NUM)); + } + } + + +} + +TEST_CASE("I2C set and get period test", "[i2c]") +{ + int high_period, low_period; + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + + TEST_ESP_OK(i2c_set_period(I2C_MASTER_NUM, I2C_SCL_HIGH_PERIOD_V, I2C_SCL_HIGH_PERIOD_V)); + TEST_ESP_OK(i2c_get_period(I2C_MASTER_NUM, &high_period, &low_period)); + TEST_ASSERT_EQUAL_INT(I2C_SCL_HIGH_PERIOD_V, high_period); + TEST_ASSERT_EQUAL_INT(I2C_SCL_HIGH_PERIOD_V, low_period); + + TEST_ASSERT_NOT_NULL((void *)i2c_set_period(I2C_MASTER_NUM, I2C_SCL_HIGH_PERIOD_V + 1, I2C_SCL_HIGH_PERIOD_V + 1)); + + TEST_ESP_OK(i2c_set_period(I2C_MASTER_NUM, 300, 400)); + TEST_ESP_OK(i2c_get_period(I2C_MASTER_NUM, &high_period, &low_period)); + TEST_ASSERT_EQUAL_INT(300, high_period); + TEST_ASSERT_EQUAL_INT(400, low_period); + TEST_ESP_OK(i2c_driver_delete(I2C_MASTER_NUM)); +} + +TEST_CASE("I2C config FIFO test", "[i2c]") +{ + TEST_ASSERT_BIT_LOW(1, I2C[I2C_SLAVE_NUM]->fifo_conf.tx_fifo_rst); + TEST_ESP_OK(i2c_reset_tx_fifo(I2C_SLAVE_NUM)); + TEST_ASSERT_BIT_LOW(0, I2C[I2C_SLAVE_NUM]->fifo_conf.tx_fifo_rst); + + TEST_ESP_OK(i2c_reset_rx_fifo(I2C_SLAVE_NUM)); + TEST_ASSERT_BIT_LOW(0, I2C[I2C_SLAVE_NUM]->fifo_conf.rx_fifo_rst); +} + +TEST_CASE("I2C timing test", "[i2c]") +{ + int test_setup_time, test_data_time, test_stop_time, test_hold_time; + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + + TEST_ESP_OK(i2c_set_start_timing(I2C_MASTER_NUM, 50, 60)); + TEST_ESP_OK(i2c_set_data_timing(I2C_MASTER_NUM, 80, 60)); + TEST_ESP_OK(i2c_set_stop_timing(I2C_MASTER_NUM, 100, 60)); + + for (int i = 0; i < DATA_LENGTH; i++) { + data_wr[i] = i; + } + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, RW_TEST_LENGTH); + TEST_ESP_OK(i2c_get_start_timing(I2C_MASTER_NUM, &test_setup_time, &test_hold_time)); + TEST_ESP_OK(i2c_get_data_timing(I2C_MASTER_NUM, &test_data_time, &test_hold_time)); + TEST_ESP_OK(i2c_get_stop_timing(I2C_MASTER_NUM, &test_stop_time, &test_hold_time)); + TEST_ASSERT_EQUAL_INT32(50, test_setup_time); + TEST_ASSERT_EQUAL_INT32(80, test_data_time); + TEST_ASSERT_EQUAL_INT32(100, test_stop_time); + TEST_ASSERT_EQUAL_INT32(60, test_hold_time); + free(data_wr); + i2c_driver_delete(I2C_MASTER_NUM); +} + + +TEST_CASE("I2C data mode test", "[i2c]") +{ + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + i2c_trans_mode_t test_tx_trans_mode, test_rx_trans_mode; + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + for (int i = 0; i < DATA_LENGTH; i++) { + data_wr[i] = i; + } + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, RW_TEST_LENGTH); + TEST_ESP_OK(i2c_set_data_mode(I2C_MASTER_NUM, I2C_DATA_MODE_LSB_FIRST, I2C_DATA_MODE_LSB_FIRST)); + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, RW_TEST_LENGTH); + TEST_ASSERT_EQUAL_INT(1, I2C[I2C_MASTER_NUM]->ctr.rx_lsb_first); + TEST_ASSERT_EQUAL_INT(1, I2C[I2C_MASTER_NUM]->ctr.tx_lsb_first); + + TEST_ESP_OK(i2c_get_data_mode(I2C_MASTER_NUM, &test_tx_trans_mode, &test_rx_trans_mode)); + TEST_ASSERT_EQUAL_INT(1, test_tx_trans_mode); + TEST_ASSERT_EQUAL_INT(1, test_rx_trans_mode); + free(data_wr); + i2c_driver_delete(I2C_MASTER_NUM); +} + + +TEST_CASE("I2C driver memory leaking check", "[i2c]") +{ + esp_err_t ret; + i2c_config_t conf_slave = i2c_slave_init(); + ret = i2c_param_config(I2C_SLAVE_NUM, &conf_slave); + TEST_ASSERT(ret == ESP_OK); + + int size = esp_get_free_heap_size(); + for (uint32_t i = 0; i <= 1000; i++) { + ret = i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0); + TEST_ASSERT(ret == ESP_OK); + vTaskDelay(10 / portTICK_RATE_MS); + i2c_driver_delete(I2C_SLAVE_NUM); + TEST_ASSERT(ret == ESP_OK); + } + + TEST_ASSERT_INT_WITHIN(100, size, esp_get_free_heap_size()); +} + +static void i2c_master_write_test() +{ + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + int i; + + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + unity_wait_for_signal("i2c slave init finish"); + + unity_send_signal("master write"); + for (i = 0; i < DATA_LENGTH / 2; i++) { + data_wr[i] = i; + } + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, DATA_LENGTH / 2); + disp_buf(data_wr, i + 1); + free(data_wr); + unity_wait_for_signal("ready to delete"); + TEST_ESP_OK(i2c_driver_delete(I2C_MASTER_NUM)); +} + +static void i2c_slave_read_test() +{ + uint8_t *data_rd = (uint8_t *) malloc(DATA_LENGTH); + int size_rd = 0; + int len = 0; + + i2c_config_t conf_slave = i2c_slave_init(); + TEST_ESP_OK(i2c_param_config( I2C_SLAVE_NUM, &conf_slave)); + TEST_ESP_OK(i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0)); + unity_send_signal("i2c slave init finish"); + + unity_wait_for_signal("master write"); + while (1) { + len = i2c_slave_read_buffer( I2C_SLAVE_NUM, data_rd + size_rd, DATA_LENGTH, 10000 / portTICK_RATE_MS); + if (len == 0) { + break; + } + size_rd += len; + } + disp_buf(data_rd, size_rd); + for (int i = 0; i < size_rd; i++) { + TEST_ASSERT(data_rd[i] == i); + } + free(data_rd); + unity_send_signal("ready to delete"); + TEST_ESP_OK(i2c_driver_delete(I2C_SLAVE_NUM)); +} + +TEST_CASE_MULTIPLE_DEVICES("I2C master write slave test", "[i2c][test_env=UT_T2_I2C][timeout=150]", i2c_master_write_test, i2c_slave_read_test); + +static void master_read_slave_test() +{ + uint8_t *data_rd = (uint8_t *) malloc(DATA_LENGTH); + memset(data_rd, 0, DATA_LENGTH); + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + unity_wait_for_signal("i2c slave init finish"); + + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | READ_BIT, ACK_CHECK_EN); + + unity_send_signal("slave write"); + unity_wait_for_signal("master read"); + i2c_master_read(cmd, data_rd, RW_TEST_LENGTH-1, ACK_VAL); + i2c_master_read_byte(cmd, data_rd + RW_TEST_LENGTH-1, NACK_VAL); + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 5000 / portTICK_RATE_MS); + i2c_cmd_link_delete(cmd); + vTaskDelay(100 / portTICK_RATE_MS); + for (int i = 0; i < RW_TEST_LENGTH; i++) { + printf("%d\n", data_rd[i]); + TEST_ASSERT(data_rd[i]==i); + } + free(data_rd); + unity_send_signal("ready to delete"); + i2c_driver_delete(I2C_MASTER_NUM); +} + +static void slave_write_buffer_test() +{ + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + int size_rd; + + i2c_config_t conf_slave = i2c_slave_init(); + TEST_ESP_OK(i2c_param_config( I2C_SLAVE_NUM, &conf_slave)); + TEST_ESP_OK(i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0)); + unity_send_signal("i2c slave init finish"); + + unity_wait_for_signal("slave write"); + for (int i = 0; i < DATA_LENGTH / 2; i++) { + data_wr[i] = i; + } + size_rd = i2c_slave_write_buffer(I2C_SLAVE_NUM, data_wr, RW_TEST_LENGTH, 2000 / portTICK_RATE_MS); + disp_buf(data_wr, size_rd); + unity_send_signal("master read"); + unity_wait_for_signal("ready to delete"); + free(data_wr); + i2c_driver_delete(I2C_SLAVE_NUM); +} + + +TEST_CASE_MULTIPLE_DEVICES("I2C master read slave test", "[i2c][test_env=UT_T2_I2C][timeout=150]", master_read_slave_test, slave_write_buffer_test); + +static void i2c_master_write_read_test() +{ + uint8_t *data_rd = (uint8_t *) malloc(DATA_LENGTH); + memset(data_rd, 0, DATA_LENGTH); + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + unity_wait_for_signal("i2c slave init finish"); + i2c_cmd_handle_t cmd = i2c_cmd_link_create(); + i2c_master_start(cmd); + i2c_master_write_byte(cmd, ( ESP_SLAVE_ADDR << 1 ) | READ_BIT, ACK_CHECK_EN); + + unity_send_signal("slave write"); + unity_wait_for_signal("master read and write"); + i2c_master_read(cmd, data_rd, RW_TEST_LENGTH, ACK_VAL); + i2c_master_read_byte(cmd, data_rd + RW_TEST_LENGTH, NACK_VAL); + i2c_master_stop(cmd); + i2c_master_cmd_begin(I2C_MASTER_NUM, cmd, 5000 / portTICK_RATE_MS); + i2c_cmd_link_delete(cmd); + vTaskDelay(100 / portTICK_RATE_MS); + disp_buf(data_rd, RW_TEST_LENGTH); + for (int i = 0; i < RW_TEST_LENGTH; i++) { + TEST_ASSERT(data_rd[i] == i/2); + } + + for (int i = 0; i < DATA_LENGTH; i++) { + data_wr[i] = i % 3; + } + + vTaskDelay(100 / portTICK_RATE_MS); + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, RW_TEST_LENGTH); + free(data_wr); + free(data_rd); + unity_send_signal("slave read"); + unity_wait_for_signal("ready to delete"); + i2c_driver_delete(I2C_MASTER_NUM); +} + +static void i2c_slave_read_write_test() +{ + uint8_t *data_rd = (uint8_t *) malloc(DATA_LENGTH); + memset(data_rd, 0, DATA_LENGTH); + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + int size_rd; + + i2c_config_t conf_slave = i2c_slave_init(); + TEST_ESP_OK(i2c_param_config( I2C_SLAVE_NUM, &conf_slave)); + TEST_ESP_OK(i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0)); + unity_send_signal("i2c slave init finish"); + unity_wait_for_signal("slave write"); + + for (int i = 0; i < DATA_LENGTH / 2; i++) { + data_wr[i] = i/2; + } + size_rd = i2c_slave_write_buffer(I2C_SLAVE_NUM, data_wr, RW_TEST_LENGTH, 2000 / portTICK_RATE_MS); + disp_buf(data_wr, size_rd); + unity_send_signal("master read and write"); + unity_wait_for_signal("slave read"); + size_rd = i2c_slave_read_buffer( I2C_SLAVE_NUM, data_rd, RW_TEST_LENGTH, 1000 / portTICK_RATE_MS); + printf("slave read data is:\n"); + disp_buf(data_rd, size_rd); + for (int i = 0; i < RW_TEST_LENGTH; i++) { + TEST_ASSERT(data_rd[i] == i % 3); + } + free(data_wr); + free(data_rd); + unity_send_signal("ready to delete"); + i2c_driver_delete(I2C_SLAVE_NUM); +} + +TEST_CASE_MULTIPLE_DEVICES("I2C read and write test", "[i2c][test_env=UT_T2_I2C][timeout=150]", i2c_master_write_read_test, i2c_slave_read_write_test); + +static void i2c_master_repeat_write() +{ + uint8_t *data_wr = (uint8_t *) malloc(DATA_LENGTH); + int times = 3; + + i2c_config_t conf_master = i2c_master_init(); + TEST_ESP_OK(i2c_param_config(I2C_MASTER_NUM, &conf_master)); + + TEST_ESP_OK(i2c_driver_install(I2C_MASTER_NUM, I2C_MODE_MASTER, + I2C_MASTER_RX_BUF_DISABLE, + I2C_MASTER_TX_BUF_DISABLE, 0)); + unity_wait_for_signal("i2c slave init finish"); + + for (int j = 0; j < times; j++) { + for (int i = 0; i < DATA_LENGTH; i++) { + data_wr[i] = j + i; + } + i2c_master_write_slave(I2C_MASTER_NUM, data_wr, RW_TEST_LENGTH); + disp_buf(data_wr, RW_TEST_LENGTH); + } + free(data_wr); + unity_send_signal("master write"); + unity_wait_for_signal("ready to delete"); + i2c_driver_delete(I2C_MASTER_NUM); +} + +static void i2c_slave_repeat_read() +{ + int size_rd = 0; + int times = 3; + uint8_t *data_rd = (uint8_t *) malloc(DATA_LENGTH * 3); + + i2c_config_t conf_slave = i2c_slave_init(); + TEST_ESP_OK(i2c_param_config( I2C_SLAVE_NUM, &conf_slave)); + TEST_ESP_OK(i2c_driver_install(I2C_SLAVE_NUM, I2C_MODE_SLAVE, + I2C_SLAVE_RX_BUF_LEN, + I2C_SLAVE_TX_BUF_LEN, 0)); + unity_send_signal("i2c slave init finish"); + unity_wait_for_signal("master write"); + + while (1) { + int len = i2c_slave_read_buffer( I2C_SLAVE_NUM, data_rd + size_rd, RW_TEST_LENGTH * 3, 10000 / portTICK_RATE_MS); + if (len == 0) { + break; + } + size_rd += len; + } + disp_buf(data_rd, size_rd); + for (int j = 0; j < times; j++) { + for (int i = 0; i < RW_TEST_LENGTH; i++) { + printf("data: %d, %d\n", data_rd[j * RW_TEST_LENGTH + i], (i % 129 + j)); + TEST_ASSERT(data_rd[j * RW_TEST_LENGTH + i] == (i % 129 + j)); + } + } + free(data_rd); + unity_send_signal("ready to delete"); + i2c_driver_delete(I2C_SLAVE_NUM); +} + +TEST_CASE_MULTIPLE_DEVICES("I2C repeat write test", "[i2c][test_env=UT_T2_I2C][timeout=150]", i2c_master_repeat_write, i2c_slave_repeat_read);