864 lines
30 KiB
C
864 lines
30 KiB
C
#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;
|
|
} |