From fd06d54fdcf4aaab067255c7c3e0596dcf45505f Mon Sep 17 00:00:00 2001 From: yelvlab Date: Thu, 19 Dec 2024 18:23:55 +0800 Subject: [PATCH] rewrite write/read function --- inc/LDC1612.h | 15 +- src/LDC1612.c | 394 +++++++++++++++++++++++++++++++++++++++++++++++++- src/main.c | 9 ++ 3 files changed, 411 insertions(+), 7 deletions(-) diff --git a/inc/LDC1612.h b/inc/LDC1612.h index 1fd3536..979f272 100644 --- a/inc/LDC1612.h +++ b/inc/LDC1612.h @@ -44,8 +44,13 @@ typedef enum { I2C_STOP } i2c_process_enum; +#define I2C_TIME_OUT (uint16_t)(10000) +#define I2C_OK 1 +#define I2C_FAIL 0 +#define I2C_END 1 + #define I2C_SPEED 100000 -#define RCU_IR_GPIO RCU_GPIOF +#define RCU_GPIO_I2C RCU_GPIOF #define RCU_I2C RCU_I2C0 #define I2C_SCL_PORT GPIOF #define I2C_SCL_PIN GPIO_PIN_1 @@ -53,13 +58,19 @@ typedef enum { #define I2C_SDA_PIN GPIO_PIN_0 #define I2C_GPIO_AF GPIO_AF_1 -#define I2C_TIME_OUT (uint16_t)(10000) + void I2C_config(void); +void gpio_config(void); +void i2c_config(void); +void i2c_bus_reset(void); void I2C_scan(void); int LDC1612_IIC_read_16bits(uint8_t reg, uint16_t *data); void ldc1612_iic_get_sensor_infomation(void); +uint16_t ldc1612_get_manufacturer_id(void); uint16_t ldc1612_get_deveice_id(void); +uint8_t ldc1612_iic_read_16bits(uint8_t reg_addr, uint8_t *data); +int ldc1612_iic_write_16bits(uint8_t reg_addr, uint8_t data[2]); #endif //LDC1612_H diff --git a/src/LDC1612.c b/src/LDC1612.c index 0c0918f..a41c217 100644 --- a/src/LDC1612.c +++ b/src/LDC1612.c @@ -5,7 +5,7 @@ #include "LDC1612.h" void I2C_config(void) { - rcu_periph_clock_enable(RCU_IR_GPIO); + rcu_periph_clock_enable(RCU_GPIO_I2C); rcu_periph_clock_enable(RCU_I2C); gpio_af_set(I2C_SCL_PORT, I2C_GPIO_AF, I2C_SCL_PIN); @@ -24,6 +24,79 @@ void I2C_config(void) { i2c_ack_config(I2C0, I2C_ACK_ENABLE); } +/*! + \brief configure the GPIO ports + \param[in] none + \param[out] none + \retval none +*/ +void gpio_config(void) { + /* enable IIC GPIO clock */ + rcu_periph_clock_enable(RCU_GPIO_I2C); + + /* connect I2C_SCL_PIN to I2C_SCL */ + gpio_af_set(I2C_SCL_PORT, I2C_GPIO_AF, I2C_SCL_PIN); + /* connect I2C_SDA_PIN to I2C_SDA */ + gpio_af_set(I2C_SDA_PORT, I2C_GPIO_AF, I2C_SDA_PIN); + /* configure GPIO pins of I2C */ + gpio_mode_set(I2C_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SCL_PIN); + gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN); + gpio_mode_set(I2C_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, I2C_SDA_PIN); + gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN); +} + +/*! + \brief configure the I2CX interface + \param[in] none + \param[out] none + \retval none +*/ +void i2c_config(void) { + /* enable I2C clock */ + rcu_periph_clock_enable(RCU_I2C); + /* configure I2C clock */ + i2c_clock_config(I2C0, I2C_SPEED, I2C_DTCY_2); + /* configure I2C address */ + i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, LDC1612_ADDR); + /* enable I2CX */ + i2c_enable(I2C0); + /* enable acknowledge */ + i2c_ack_config(I2C0, I2C_ACK_ENABLE); +} + +/*! + \brief reset I2C bus + \param[in] none + \param[out] none + \retval none +*/ +void i2c_bus_reset(void) { + i2c_deinit(I2C0); + /* configure SDA/SCL for GPIO */ + GPIO_BC(I2C_SCL_PORT) |= I2C_SCL_PIN; + GPIO_BC(I2C_SDA_PORT) |= I2C_SDA_PIN; + gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, I2C_SCL_PIN); + gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, I2C_SDA_PIN); + __NOP(); + __NOP(); + __NOP(); + __NOP(); + __NOP(); + GPIO_BOP(I2C_SCL_PORT) |= I2C_SCL_PIN; + __NOP(); + __NOP(); + __NOP(); + __NOP(); + __NOP(); + GPIO_BOP(I2C_SDA_PORT) |= I2C_SDA_PIN; + /* connect I2C_SCL_PIN to I2C_SCL */ + /* connect I2C_SDA_PIN to I2C_SDA */ + gpio_output_options_set(I2C_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SCL_PIN); + gpio_output_options_set(I2C_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C_SDA_PIN); + /* configure the I2CX interface */ + i2c_config(); +} + /** * @brief 扫描I2C总线，查找连接的设备 * @@ -196,9 +269,320 @@ void ldc1612_iic_get_sensor_infomation(void) { printf("\tDevice: 0x%x\r\n", data); } -uint16_t ldc1612_get_deveice_id(void) { - uint16_t data = 0; - LDC1612_IIC_read_16bits(READ_DEVICE_ID, &data); - return data; +uint16_t ldc1612_get_manufacturer_id(void) { + uint8_t data[2] = {0}; + ldc1612_iic_read_16bits(READ_MANUFACTURER_ID, data); + return (data[0] << 8) | data[1]; } +uint16_t ldc1612_get_deveice_id(void) { + // uint16_t data = 0; + // LDC1612_IIC_read_16bits(READ_DEVICE_ID, &data); + // return data; + uint8_t data[2] = {0}; + ldc1612_iic_read_16bits(READ_DEVICE_ID, data); + return (data[0] << 8) | data[1]; +} + +uint8_t ldc1612_iic_read_16bits(uint8_t reg_addr, uint8_t *data) { + uint8_t state = I2C_START; + uint8_t read_cycle = 0; + uint16_t timeout = 0; + uint8_t i2c_timeout_flag = 0; + uint8_t number_of_byte = 2; + + /* enable acknowledge */ + i2c_ack_config(I2C0, I2C_ACK_ENABLE); + + while (!(i2c_timeout_flag)) { + switch (state) { + case I2C_START: + if (RESET == read_cycle) { + /* i2c master sends start signal only when the bus is idle */ + while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + /* whether to send ACK or not for the next byte */ + i2c_ackpos_config(I2C0, I2C_ACKPOS_NEXT); + } else { + i2c_bus_reset(); + timeout = 0; + state = I2C_START; + printf("i2c bus is busy in READ!\n"); + } + } + /* send the start signal */ + delay_us(5); + i2c_start_on_bus(I2C0); + timeout = 0; + state = I2C_SEND_ADDRESS; + break; + case I2C_SEND_ADDRESS: + /* i2c master sends START signal successfully */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + if (RESET == read_cycle) { + i2c_master_addressing(I2C0, LDC1612_ADDR, I2C_TRANSMITTER); + state = I2C_CLEAR_ADDRESS_FLAG; + } else { + i2c_master_addressing(I2C0, LDC1612_ADDR, I2C_RECEIVER); + i2c_ack_config(I2C0, I2C_ACK_DISABLE); + state = I2C_CLEAR_ADDRESS_FLAG; + } + timeout = 0; + } else { + timeout = 0; + state = I2C_START; + read_cycle = RESET; + printf("i2c master sends start signal timeout in READ!\n"); + } + break; + case I2C_CLEAR_ADDRESS_FLAG: + /* address flag set means i2c slave sends ACK */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND); + if ((SET == read_cycle) && (1 == number_of_byte)) { + /* send a stop condition to I2C bus */ + i2c_stop_on_bus(I2C0); + } + timeout = 0; + state = I2C_TRANSMIT_DATA; + } else { + timeout = 0; + state = I2C_START; + read_cycle = RESET; + printf("i2c master clears address flag timeout in READ!\n"); + } + break; + case I2C_TRANSMIT_DATA: + if (RESET == read_cycle) { + /* wait until the transmit data buffer is empty */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + /* send the EEPROM's internal address to write to : only one byte address */ + i2c_data_transmit(I2C0, reg_addr); + timeout = 0; + } else { + timeout = 0; + state = I2C_START; + read_cycle = RESET; + printf("i2c master wait data buffer is empty timeout in READ!\n"); + } + /* wait until BTC bit is set */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + timeout = 0; + state = I2C_START; + read_cycle = SET; + } else { + timeout = 0; + state = I2C_START; + read_cycle = RESET; + printf("i2c master sends register address timeout in READ!\n"); + } + } else { + while (number_of_byte) { + timeout++; + if (2 == number_of_byte) { + /* wait until BTC bit is set */ + while (!i2c_flag_get(I2C0, I2C_FLAG_BTC)); + /* send a stop condition to I2C bus */ + i2c_stop_on_bus(I2C0); + } + /* wait until RBNE bit is set */ + if (i2c_flag_get(I2C0, I2C_FLAG_RBNE)) { + /* read a byte from the EEPROM */ + *data = i2c_data_receive(I2C0); + /* point to the next location where the byte read will be saved */ + data++; + /* decrement the read bytes counter */ + number_of_byte--; + timeout = 0; + } + if (timeout > I2C_TIME_OUT) { + timeout = 0; + state = I2C_START; + read_cycle = 0; + printf("i2c master sends data timeout in READ!\n"); + } + } + timeout = 0; + state = I2C_STOP; + } + break; + case I2C_STOP: + /* i2c master sends STOP signal successfully */ + while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + timeout = 0; + state = I2C_END; + i2c_timeout_flag = I2C_OK; + } else { + timeout = 0; + state = I2C_START; + read_cycle = 0; + printf("i2c master sends stop signal timeout in READ!\n"); + } + break; + default: + state = I2C_START; + read_cycle = 0; + i2c_timeout_flag = I2C_OK; + timeout = 0; + printf("i2c master sends start signal in READ.\n"); + break; + } + } + return I2C_END; +} + +int ldc1612_iic_write_16bits(uint8_t reg_addr, uint8_t data[2]) { + uint8_t state = I2C_START; + uint16_t timeout = 0; + uint8_t i2c_timeout_flag = 0; + + /* enable acknowledge */ + i2c_ack_config(I2C0, I2C_ACK_ENABLE); + while (!(i2c_timeout_flag)) { + switch (state) { + case I2C_START: + /* i2c master sends start signal only when the bus is idle */ + while (i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + i2c_start_on_bus(I2C0); + timeout = 0; + state = I2C_SEND_ADDRESS; + } else { + timeout = 0; + state = I2C_START; + printf("i2c bus is busy in WRITE BYTE!\n"); + } + break; + case I2C_SEND_ADDRESS: + /* i2c master sends START signal successfully */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + i2c_master_addressing(I2C0, LDC1612_ADDR, I2C_TRANSMITTER); + timeout = 0; + state = I2C_CLEAR_ADDRESS_FLAG; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends start signal timeout in WRITE BYTE!\n"); + } + break; + case I2C_CLEAR_ADDRESS_FLAG: + /* address flag set means i2c slave sends ACK */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND); + timeout = 0; + state = I2C_TRANSMIT_DATA; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master clears address flag timeout in WRITE BYTE!\n"); + } + break; + case I2C_TRANSMIT_DATA: + /* wait until the transmit data buffer is empty */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + /* send IIC register address */ + i2c_data_transmit(I2C0, reg_addr); + timeout = 0; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends data timeout in WRITE BYTE!\n"); + } + + /* wait until BTC bit is set */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + /* send register MSB value */ + i2c_data_transmit(I2C0, data[0]); + timeout = 0; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends MSB data timeout in WRITE BYTE!\n"); + } + + /* wait until BTC bit is set */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + /* send register LSB value */ + i2c_data_transmit(I2C0, data[1]); + timeout = 0; + state = I2C_STOP; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends LSB data timeout in WRITE BYTE!\n"); + } + + /* wait until BTC bit is set */ + while ((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + state = I2C_STOP; + timeout = 0; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends data timeout in WRITE BYTE!\n"); + } + break; + case I2C_STOP: + /* send a stop condition to I2C bus */ + i2c_stop_on_bus(I2C0); + /* i2c master sends STOP signal successfully */ + while ((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_TIME_OUT)) { + timeout++; + } + if (timeout < I2C_TIME_OUT) { + timeout = 0; + state = I2C_END; + i2c_timeout_flag = I2C_OK; + } else { + timeout = 0; + state = I2C_START; + printf("i2c master sends stop signal timeout in WRITE BYTE!\n"); + } + break; + default: + state = I2C_START; + i2c_timeout_flag = I2C_OK; + timeout = 0; + printf("i2c master sends start signal in WRITE BYTE.\n"); + break; + } + } + return I2C_END; +} diff --git a/src/main.c b/src/main.c index e819d1e..e19e083 100644 --- a/src/main.c +++ b/src/main.c @@ -65,6 +65,15 @@ int main(void) { device_id = ldc1612_get_deveice_id(); printf("device id = 0x%x\r\n", device_id); + delay_ms(100); + + device_id = 0; + device_id = ldc1612_get_manufacturer_id(); + printf("device id = 0x%x\r\n", device_id); + + uint8_t data[2] = {0x05, 0x36}; + ldc1612_iic_write_16bits(SET_CONVERSION_TIME_REG_START, data); + while (1) { // delay_ms(1000);