#include #include #include "gd32e23x.h" #include "i2c.h" #include "gd32e23x.h" #include "chirp_board_config.h" #include "board_init.h" /*! \brief Enable IIC0 & NVIC \param[in] none \param[out] none \retval none */ void i2c_master_initialize1(void) { /* IIC config */ rcu_periph_clock_enable(CHIRP_PIN_IIC_CLK); i2c_clock_config(CHIRP_PIN_IIC_BUS, I2C0_SPEED, I2C_DTCY_2); i2c_mode_addr_config(CHIRP_PIN_IIC_BUS, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_MASTER_ADDRESS7); i2c_enable(CHIRP_PIN_IIC_BUS); i2c_ack_config(CHIRP_PIN_IIC_BUS, I2C_ACK_ENABLE); /* enable I2C0 NVIC */ nvic_irq_enable(I2C0_ER_IRQn, 1); nvic_irq_enable(I2C0_EV_IRQn, 3); } /*! \brief No TWI3(IIC3),no operation err log. \param[in] none \param[out] none \retval none */ void i2c_master_initialize3(void) { __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_initialize3 @ i2c.c, no TWI3 \n"); #endif } /*! \brief Only Init TWI1(IIC1),No TWI3(IIC3),no operation err log. \param[in] none \param[out] none \retval none */ void i2c_master_init(void) { i2c_master_initialize1(); i2c_master_initialize3(); gpio_mode_set(CHIRP_PIN_LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, CHIRP_PIN_LED_PIN); } /*! \brief Deinit TWI1(IIC1). \param[in] none \param[out] none \retval none */ void i2c_master_deinit1(void) { rcu_periph_clock_disable(CHIRP_PIN_IIC_CLK); i2c_disable(CHIRP_PIN_IIC_BUS); } /*! \brief No TWI3(IIC3),no operation err log. \param[in] none \param[out] none \retval none */ void i2c_master_deinit3(void) { __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_deinit3 @ i2c.c, no TWI3 Pin \n"); #endif } /*! \brief TWI1(IIC0) read data from the IIC Slave Device \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] RegisterAddr: the IIC Slave Device's internal address to start reading from \param[in] RegisterLen: number of bytes to reads from the IIC Slave Device \param[in] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device \param[out] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device \retval IIC_SUCCESS */ uint8_t i2c_master_read_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){ uint8_t state = I2C_START; uint8_t read_cycle = 0; uint16_t timeout = 0; uint8_t i2c_timeout_flag = 0; unsigned char IIC_SLAVE_ADDR = (Address << 1); 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_timeout_flag)) { timeout ++; } if(timeout < I2C_TIME_OUT) { /* whether to send ACK or not for the next byte */ if(2 == RegisterLen) { 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 */ i2c_start_on_bus(I2C0); timeout = 0; state = I2C_SEND_ADDR; break; case I2C_SEND_ADDR: /* 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, IIC_SLAVE_ADDR, I2C_TRANSMITTER); state = I2C_CLEAR_ADDRESS_FLAG; } else { i2c_master_addressing(I2C0, IIC_SLAVE_ADDR, I2C_RECEIVER); if(RegisterLen < 3) { /* disable acknowledge */ i2c_ack_config(I2C0, I2C_ACK_DISABLE); } state = I2C_CLEAR_ADDRESS_FLAG; } timeout = 0; } else { timeout = 0; state = I2C_START; read_cycle = 0; 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 == RegisterLen)) { /* 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 = 0; 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, RegisterAddr); timeout = 0; } else { timeout = 0; state = I2C_START; read_cycle = 0; 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++; } else { timeout = 0; state = I2C_START; read_cycle = 0; printf("i2c master sends i2c_master_read_register1 internal address timeout in READ!\n"); } } else { while(RegisterLen) { timeout++; if(3 == RegisterLen) { /* wait until BTC bit is set */ while(!i2c_flag_get(I2C0, I2C_FLAG_BTC)); /* disable acknowledge */ i2c_ack_config(I2C0, I2C_ACK_DISABLE); } if(2 == RegisterLen) { /* 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 */ *RegisterValue = i2c_data_receive(I2C0); /* point to the next location where the byte read will be saved */ RegisterValue++; /* decrement the read bytes counter */ RegisterLen--; 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 IIC_SUCCESS; } /*! \brief TWI3(none) read data from the IIC Slave Device \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] RegisterAddr: the IIC Slave Device's internal address to start reading from \param[in] RegisterLen: number of bytes to reads from the IIC Slave Device \param[in] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device \param[out] RegisterValue: pointer to the buffer that receives the data read from the IIC Slave Device \retval IIC_SUCCESS \note No TWI3(IIC3) - No operation - Error log. */ uint8_t i2c_master_read_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){ __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_read_register3 @ i2c.c, no TWI3 \n"); #endif return IIC_SUCCESS; } /*! \brief TWI1(IIC0) read data from the IIC Slave Device \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] len: number of bytes to reads from the IIC Slave Device \param[in] data: pointer to the buffer that receives the data read from the IIC Slave Device \param[out] data: pointer to the buffer that receives the data read from the IIC Slave Device \retval IIC_SUCCESS */ uint8_t i2c_master_read_register1_raw(unsigned char Address, unsigned short len, unsigned char *data){ uint8_t state = I2C_START; // uint8_t read_cycle = 0; uint16_t timeout = 0; uint8_t i2c_timeout_flag = 0; unsigned char IIC_SLAVE_ADDR = (Address << 1); 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_timeout_flag)) { timeout ++; } if(timeout < I2C_TIME_OUT) { /* whether to send ACK or not for the next byte */ if(2 == len) { 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 */ i2c_start_on_bus(I2C0); timeout = 0; state = I2C_SEND_ADDR; break; case I2C_SEND_ADDR: /* 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, IIC_SLAVE_ADDR, I2C_RECEIVER); if(len < 3) { /* disable acknowledge */ i2c_ack_config(I2C0, I2C_ACK_DISABLE); } state = I2C_CLEAR_ADDRESS_FLAG; timeout = 0; } else { timeout = 0; state = I2C_START; // read_cycle = 0; 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); timeout = 0; state = I2C_TRANSMIT_DATA; } else { timeout = 0; state = I2C_START; // read_cycle = 0; printf("i2c master clears address flag timeout in READ!\n"); } break; case I2C_TRANSMIT_DATA: while(len) { timeout++; if(3 == len) { /* wait until BTC bit is set */ while(!i2c_flag_get(I2C0, I2C_FLAG_BTC)); /* disable acknowledge */ i2c_ack_config(I2C0, I2C_ACK_DISABLE); } if(2 == len) { /* 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 */ len--; 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 IIC_SUCCESS; } /*! \brief TWI3(none) read data from the IIC Slave Device with no regisiter address \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] len: number of bytes to reads from the IIC Slave Device \param[in] data: pointer to the buffer that receives the data read from the IIC Slave Device \param[out] data: pointer to the buffer that receives the data read from the IIC Slave Device \retval IIC_SUCCESS \note No TWI3(IIC3) - No operation - Error log. */ uint8_t i2c_master_read_register3_raw(unsigned char Address, unsigned short len, unsigned char *data){ __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_read_register3_raw @ i2c.c, no TWI3 \n"); #endif return IIC_SUCCESS; } /*! \brief TWI1(IIC0) write data to the IIC Slave Device \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] RegisterAddr: the IIC Slave Device's internal address to start writing to \param[in] RegisterLen: number of bytes to write to the IIC Slave Device \param[in] RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device \param[out] RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device \retval IIC_SUCCESS */ uint8_t i2c_master_write_register1(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue) { uint8_t state = I2C_START; uint16_t timeout = 0; uint8_t i2c_timeout_flag = 0; unsigned char IIC_SLAVE_ADDR = (Address << 1); /* 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_ADDR; } else { i2c_bus_reset(); timeout = 0; state = I2C_START; printf("i2c bus is busy in WRITE!\n"); } break; case I2C_SEND_ADDR: /* 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, IIC_SLAVE_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!\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!\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 the EEPROM's internal address to write to : only one byte address */ i2c_data_transmit(I2C0, RegisterAddr); timeout = 0; } else { timeout = 0; state = I2C_START; printf("i2c master sends i2c_master_write_register1 internal address timeout in WRITE!\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; } else { timeout = 0; state = I2C_START; printf("i2c master sends data timeout in WRITE!\n"); } while(RegisterLen--) { i2c_data_transmit(I2C0, *RegisterValue); /* point to the next byte to be written */ RegisterValue++; /* 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; } else { timeout = 0; state = I2C_START; printf("i2c master sends data timeout in WRITE!\n"); } } timeout = 0; state = I2C_STOP; 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!\n"); } break; default: state = I2C_START; i2c_timeout_flag = I2C_OK; timeout = 0; printf("i2c master sends start signal in WRITE.\n"); break; } } return IIC_SUCCESS; } /*! \brief TWI3(none) write data to the IIC Slave Device \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] RegisterAddr: the IIC Slave Device's internal address to start writing to \param[in] RegisterLen: number of bytes to write to the IIC Slave Device \param[in] RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device \param[out] RegisterValue: pointer to the buffer that transfer the data write to the IIC Slave Device \retval IIC_SUCCESS \note No TWI3(IIC3) - No operation - Error log. */ uint8_t i2c_master_write_register3(unsigned char Address, unsigned char RegisterAddr, unsigned short RegisterLen, unsigned char *RegisterValue){ __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_write_register3 @ i2c.c, no TWI3 \n"); #endif return IIC_SUCCESS; } /*! \brief TWI1(IIC0) write data to the IIC Slave Device with no regisiter address \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] len: number of bytes to write to the IIC Slave Device \param[in] data: pointer to the buffer that transfer the data write to the IIC Slave Device \param[out] data: pointer to the buffer that transfer the data write to the IIC Slave Device \retval IIC_SUCCESS */ uint8_t i2c_master_write_register1_raw(unsigned char Address, unsigned short len, unsigned char *data){ uint8_t state = I2C_START; uint16_t timeout = 0; uint8_t i2c_timeout_flag = 0; unsigned char IIC_SLAVE_ADDR = (Address << 1); /* 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_ADDR; } else { i2c_bus_reset(); timeout = 0; state = I2C_START; printf("i2c bus is busy in WRITE!\n"); } break; case I2C_SEND_ADDR: /* 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, IIC_SLAVE_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!\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!\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++; } while(len--) { i2c_data_transmit(I2C0, *data); /* point to the next byte to be written */ data++; /* 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; } else { timeout = 0; state = I2C_START; printf("i2c master sends data timeout in WRITE!\n"); } } timeout = 0; state = I2C_STOP; 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!\n"); } break; default: state = I2C_START; i2c_timeout_flag = I2C_OK; timeout = 0; printf("i2c master sends start signal in WRITE.\n"); break; } } return IIC_SUCCESS; } /*! \brief TWI3(none) write data to the IIC Slave Device with no regisiter address \param[in] Address: the IIC Slave Device's IIC Device Address \param[in] len: number of bytes to write to the IIC Slave Device \param[in] data: pointer to the buffer that transfer the data write to the IIC Slave Device \param[out] data: pointer to the buffer that transfer the data write to the IIC Slave Device \retval IIC_SUCCESS \note No TWI3(IIC3) - No operation - Error log. */ uint8_t i2c_master_write_register3_raw(unsigned char Address, unsigned short len, unsigned char *data){ __NOP(); #ifdef DEBUG_VERBOES printf("\n[DebugVerboes]i2c_master_write_register3_raw @ i2c.c, no TWI3 \n"); #endif return IIC_SUCCESS; }