762 lines
28 KiB
C
762 lines
28 KiB
C
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#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;
|
|
} |