#include <stdio.h>
#include <stdint.h>
#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;
}