#include #include #include "gd32e23x.h" #include "systick.h" #include "gd32e23x_hw_i2c.h" #include "gd32e23x.h" void i2c_struct_para_init(i2c_parameter_struct* initpara) { initpara->i2c_gpio_rcu = RCU_GPIOF; initpara->i2c_gpio_port = GPIOF; initpara->i2c_gpio_scl_pin = GPIO_PIN_1; initpara->i2c_gpio_sda_pin = GPIO_PIN_0; initpara->i2c_speed = 400000U; initpara->i2c_dcty = I2C_DTCY_2; initpara->i2c_addr7 = 0xA0; } void i2c_init(uint32_t i2c_periph, i2c_parameter_struct* initpara) { switch (i2c_periph){ case I2C0: rcu_periph_clock_enable(RCU_I2C0); rcu_periph_clock_enable(initpara->i2c_gpio_rcu); gpio_af_set(I2C0_GPIO_PORT, I2C0_GPIO_AF, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); i2c_clock_config(I2C0, I2C0_SPEED, I2C0_DCTY); i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_ADDR7); i2c_enable(I2C0); i2c_ack_config(I2C0, I2C_ACK_ENABLE); break; case I2C1: break; default: break; } } /*! \brief Enable IIC0 & NVIC \param[in] none \param[out] none \retval none */ void i2c_init(uint32_t i2c_periph) { switch (i2c_periph) { case I2C0: rcu_periph_clock_enable(RCU_I2C0); rcu_periph_clock_enable(I2C0_GPIO_RCU); gpio_af_set(I2C0_GPIO_PORT, I2C0_GPIO_AF, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); i2c_clock_config(I2C0, I2C0_SPEED, I2C0_DCTY); i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_ADDR7); i2c_enable(I2C0); i2c_ack_config(I2C0, I2C_ACK_ENABLE); break; #ifdef I2C1_ENABLE case I2C1: rcu_periph_clock_enable(RCU_I2C1); rcu_periph_clock_enable(I2C1_GPIO_RCU); gpio_af_set(I2C1_GPIO_PORT, I2C1_GPIO_AF, I2C1_GPIO_SDA_PIN | I2C1_GPIO_SCL_PIN); gpio_output_options_set(I2C1_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C1_GPIO_SDA_PIN | I2C1_GPIO_SCL_PIN); i2c_clock_config(I2C1, I2C1_SPEED, I2C1_DCTY); i2c_mode_addr_config(I2C1, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C1_ADDR7); i2c_enable(I2C1); i2c_ack_config(I2C1, I2C_ACK_ENABLE); break; #endif default: break; } } void i2c_bus_reset(void) { i2c_deinit(I2C0); /* configure SDA/SCL for GPIO */ GPIO_BC(I2C0_GPIO_PORT) |= I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN; gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); delay_5_nop(); /* stop signal */ GPIO_BOP(I2C0_GPIO_PORT) |= I2C0_GPIO_SCL_PIN; delay_5_nop(); GPIO_BOP(I2C0_GPIO_PORT) |= I2C0_GPIO_SDA_PIN; /* connect I2C_SCL_PIN to I2C_SCL */ /* connect I2C_SDA_PIN to I2C_SDA */ gpio_output_options_set(I2C0_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, I2C0_GPIO_SDA_PIN | I2C0_GPIO_SCL_PIN); /* configure the I2CX interface */ i2c_init(I2C0); } /*! \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_receive(uint32_t i2c_periph, uint8_t Dev_Address, uint8_t) 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; uint8_t 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 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; } int read_ir_mlx90614(void) { uint8_t Data[5]; int inttemp_ir=0; uint32_t TIMEOUT=0; while(TIMEOUT<10000&&i2c_flag_get(I2C0,I2C_FLAG_I2CBSY)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR0\r\n"); return -410; } TIMEOUT=0; I2C_GenerateSTART(I2C0,ENABLE); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_MODE_SELECT)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR1\r\n"); return -410; } // I2C_AcknowledgeConfig(I2C0,DISABLE); TIMEOUT=0; I2C_Send7bitAddress(I2C0,0XB4,I2C_Direction_Transmitter); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) TIMEOUT++; if(TIMEOUT>=10000) { printf("ERROR2\r\n"); return -410; } I2C_SendData(I2C0,0x07); TIMEOUT=0; I2C_GenerateSTART(I2C0,ENABLE); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_MODE_SELECT)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR3\r\n"); return -410; } TIMEOUT=0; I2C_Send7bitAddress(I2C0,0XB4,I2C_Direction_Receiver); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED )) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR4\r\n"); return -410; } //I2C_AcknowledgeConfig(I2C0,DISABLE); TIMEOUT=0; Data[0]=I2C_ReceiveData(I2C0); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR5\r\n"); return -410; } TIMEOUT=0; Data[1]=I2C_ReceiveData(I2C0); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR6\r\n"); return -410; } TIMEOUT=0; Data[2]=I2C_ReceiveData(I2C0); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR7\r\n"); return -410; } I2C_AcknowledgeConfig(I2C0,DISABLE); Data[3]=I2C_ReceiveData(I2C0); while(TIMEOUT<10000&&!I2C_CheckEvent(I2C0,I2C_EVENT_MASTER_BYTE_RECEIVED)) TIMEOUT++; if(TIMEOUT>=10000) { //printf("ERROR11\r\n"); return -410; } I2C_GenerateSTOP(I2C0,ENABLE); I2C_AcknowledgeConfig(I2C0,ENABLE); //printf("data:%x,%x,%x\r\n",Data[0],Data[1],Data[2]); inttemp_ir=(int)((Data[0]+Data[1]*255)*0.2-2731.5); // printf("temp:%d\r\n",inttemp_ir); if(inttemp_ir<-400) inttemp_ir=-400; if(inttemp_ir>850) inttemp_ir=850; // return inttemp_ir; }