新闻  |   论坛  |   博客  |   在线研讨会
TMS320C6748_IIC_EEPROM
tronlong | 2014-07-07 17:25:27    阅读:2208   发布文章

广州创龙电子基于TMS320C6748开发的IIC例程,此程序的作用是实现IIC EEPROM设备的数据读写功能,按照工程导入步骤加载IIC_EEPROM.out文件,将开发板的UART2和PC机连接,打开ZOC串口调试软件,设置好波特率为115200,数据位8位,停止位1位,检验位无,流控制无,然后点击程序运行按钮。

演示现象

(1)        ZOC串口调试终端会打印出信息: 

       此程序先写入并读出一个字节数据,然后写入并读出一页数据,接着对比写入和读出的数据,根据结果判断IIC EEPROM设备读写是否成功。


代码解析:


/*****************************************/
/*                                                                      */
/*              核心板及底板IIC EEPROM读写 测试      */
/*                                                                       */
/*              2014年5月19日                                   */
/*                                                                        */
/******************************************/
#include "main.h"
#include <string.h>
#include "soc_C6748.h"                 // DSP C6748 外设寄存器
#include "interrupt.h"                     // DSP C6748中断相关的函数和中断序号
#include "hw_syscfg0_C6748.h"      // SYSCF0模块中的寄存器和字段
#include "i2c.h"                              // I2C 设备抽象层函数
#include "evmC6748.h"                   // 与EVMC6748开发板相关的函数
#include "uart.h"

/***************************************
**                       宏定义
*****************************************/
/// I2C EEPROM Address
#define AT24C_ADDRESS   0x50

#define I2C0IsBusy()             I2CMasterBusBusy(SOC_I2C_0_REGS)

/*************************************
**                      函数原型声明
**************************************/
static void I2C0Isr(void);
static void I2C0IntRegister(unsigned int cpuINT);
static void I2C0IfConfig(unsigned int slaveAddr, unsigned int speed);


void EEPROM_ByteWrite(unsigned int Address, unsigned char Data);
void EEPROM_PageWrite(unsigned int StartAddress, unsigned char * Data, unsigned int Size);


unsigned char EEPROM_CurrentAddressRead(void);
unsigned char EEPROM_RandomRead(unsigned int Address);
void EEPROM_SequentialRead(unsigned int Address , unsigned char * Data , unsigned int Size);


void EEPROM_AckPolling(void);
void InterruptInit(void);
static void Delay(volatile unsigned int delay);


/********************************************
**                      变量定义
*********************************************/
static volatile unsigned char slaveData[9];

static volatile unsigned int dataIdx = 0;
static volatile unsigned int txCompFlag = 1;
static volatile unsigned int AckRolling = 0;

/*****************************************
**                      函数定义
******************************************/

/******************************************/
/*                                                                         */
/*              入口函数                                              */
/*                                                                         */
/******************************************/
int main(void)
{
int i,result;
unsigned char buf_send[8];
unsigned char buf_recv[8];

//I2C管脚配置
I2CPinMuxSetup(0);

UARTStdioInit();
/* Setting the UART Receiver Trigger Level*/
UARTFIFOLevelSet(SOC_UART_2_REGS, UART_RX_TRIG_LEVEL_1);
UARTPuts("\r\n ============Test Start===========.\r\n", -1);


UARTPuts("Welcome to StarterWare I2C FLASH application.\r\n\r\n", -1);
UARTPuts("Here the I2C controller on the SoC communicates with", -1);
UARTPuts(" the I2C EEPROM present on the SoM.\r\n\r\n", -1);;


    // 中断初始化
    InterruptInit();
    //I2C接口配置
    I2C0IfConfig((unsigned int)AT24C_ADDRESS, 100000);


    // 单字节写
    UARTPuts("Write single byte to address 0x0, value is 0x55.\r\n\r\n", -1);
    EEPROM_ByteWrite(0x0, 0x55);
    // 写动作完成轮询
    EEPROM_AckPolling();


    // 单字节读
    memset(buf_recv,0,8);
    buf_recv[0] = EEPROM_RandomRead(0);
    UARTPuts("Read one byte at a random address 0x0, the value is ", -1);
    UARTPutHexNum(buf_recv[0]);
    UARTPuts("\r\n\r\n", -1);


    // 当前地址读
    buf_recv[1] = EEPROM_CurrentAddressRead();
    UARTPuts("Read one byte at current address 0x0, the value is ", -1);
    UARTPutHexNum(buf_recv[1]);
    UARTPuts("\r\n\r\n", -1);

    for(i=0;i<8;i++)
    {
    if(i%2 ==0)
    buf_send[i]=0xaa;
    else
    buf_send[i]=0x55;
    }
    // 连续写指定长度 (一个页面)
    UARTPuts("Write one page (8 bytes) to address 0x0.\r\n\r\n", -1);
    EEPROM_PageWrite(0x00,buf_send,8);
    // 写动作完成轮询
    EEPROM_AckPolling();
    memset(buf_recv,0,8);


    // 连续读指定长度 (一个页面)
    UARTPuts("Read one page (8 bytes) at address 0x0.\r\n\r\n", -1);
    EEPROM_SequentialRead(0x00,buf_recv,8);


    result = 1;
    for (i=0;i<8;i++)
    {
    if (buf_send[i]!=buf_recv[i])
    {
    result = 0;
    break;
    }
    }
    // 如果result等于1,说明写入的字节值与读出的字节值全部相同;否则,写入与读取的不一致
if (result)
    UARTPuts("Verify successfully.\r\n", -1);
else
    UARTPuts("Verify failed.\r\n", -1);


    UARTPuts("\r\n ============Test End===========.\r\n", -1);


    while(1);
}


/*******************************************/
/*                                                                          */
/*              DSP 中断初始化                                     */
/*                                                                          */
/*******************************************/
void InterruptInit(void)
{
// 初始化 DSP 中断控制器
IntDSPINTCInit();


// 登记中断向量
I2C0IntRegister(C674X_MASK_INT6);
IntEnable(C674X_MASK_INT6);


// 使能 DSP 全局中断
IntGlobalEnable();
}
/*******************************************/

/*                                                                          */
/*              设置I2C中断                                          */
/*                                                                          */
/*******************************************/
static void I2C0IntRegister(unsigned int cpuINT)
{
    /* Register the ISR in the Interrupt Vector Table.*/
    IntRegister(cpuINT, I2C0Isr);
    IntEventMap(cpuINT, SYS_INT_I2C0_INT);
}

/*******************************************/
/*                                                                          */
/*              设置I2C接口(从方式)                          */
/*                                                                          */
/*******************************************/
static void I2C0IfConfig(unsigned int slaveAddr, unsigned int speed)
{
    /* Put i2c in reset/disabled state */
    I2CMasterDisable(SOC_I2C_0_REGS);


    /* Configure i2c bus speed to 100khz */
    I2CMasterInitExpClk(SOC_I2C_0_REGS, 24000000, 8000000, speed);


    /* Set i2c slave address */
    I2CMasterSlaveAddrSet(SOC_I2C_0_REGS, slaveAddr);


    I2CMasterEnable(SOC_I2C_0_REGS);
}
/*******************************************/
/*                                                                          */
/*              通过I2C发送数据                                    */
/*                                                                          */
/*  dataCnt -- 数据长度                                            */
/*                                                                          */
/*******************************************/
static void I2C0SendBlocking(unsigned int dataCnt)
{
    txCompFlag = 1;
    dataIdx = 0;


    while(I2C0IsBusy());


    I2CSetDataCount(SOC_I2C_0_REGS, dataCnt);


    I2CMasterControl(SOC_I2C_0_REGS, I2C_CFG_MST_TX | I2C_CFG_STOP);


    I2CMasterIntEnableEx(SOC_I2C_0_REGS, I2C_INT_TRANSMIT_READY
                                         | I2C_INT_STOP_CONDITION
                                         | I2C_INT_NO_ACK);


    I2CMasterStart(SOC_I2C_0_REGS);


    /* Wait till the data is sent */
    while(txCompFlag);


    while(I2C0IsBusy());
}


/*******************************************/
/*                                                                          */
/*              通过I2C接收数据                                    */
/*                                                                          */
/*  dataCnt -- 数据长度                                            */
/*                                                                          */
/*******************************************/
static void I2C0RcvBlocking(unsigned int dataCnt)
{
    txCompFlag = 1;
    dataIdx = 0;


    while(I2C0IsBusy());


    I2CSetDataCount(SOC_I2C_0_REGS, dataCnt);


    I2CMasterControl(SOC_I2C_0_REGS, I2C_CFG_MST_RX | I2C_CFG_STOP);


    I2CMasterIntEnableEx(SOC_I2C_0_REGS, I2C_INT_DATA_READY
                                         | I2C_INT_STOP_CONDITION
                                         | I2C_INT_NO_ACK);


    I2CMasterStart(SOC_I2C_0_REGS);


    /* Wait till data is received fully */
    while(txCompFlag);


    while(I2C0IsBusy());
}


/*******************************************/
/*                                                                          */
/*              I2C中断处理函数                                    */
/*                                                                          */
/*******************************************/
static void I2C0Isr(void)
{
    volatile unsigned int intCode = 0;


    /* Get interrupt vector code */
    intCode = I2CInterruptVectorGet(SOC_I2C_0_REGS);


    while(intCode!=0)
    {
         /* Clear status of interrupt */


    IntEventClear(SYS_INT_I2C0_INT);

         if (intCode == I2C_INTCODE_TX_READY)
         {
              I2CMasterDataPut(SOC_I2C_0_REGS, slaveData[dataIdx]);
              dataIdx++;
         }


         if(intCode == I2C_INTCODE_RX_READY)
         {
              slaveData[dataIdx] = I2CMasterDataGet(SOC_I2C_0_REGS);
              dataIdx++;
         }


         if (intCode == I2C_INTCODE_STOP)
         {
             I2CMasterIntDisableEx(SOC_I2C_0_REGS, I2C_INT_TRANSMIT_READY |
                                                   I2C_INT_DATA_READY |
                                                   I2C_INT_NO_ACK |
                                                   I2C_INT_STOP_CONDITION);
              txCompFlag = 0;
         }


         if (intCode == I2C_INTCODE_NACK)
         {
             I2CMasterIntDisableEx(SOC_I2C_0_REGS, I2C_INT_TRANSMIT_READY |
                                                   I2C_INT_DATA_READY |
                                                   I2C_INT_NO_ACK |
                                                   I2C_INT_STOP_CONDITION);
             /* Generate a STOP */
             I2CMasterStop(SOC_I2C_0_REGS);


             I2CStatusClear(SOC_I2C_0_REGS, I2C_CLEAR_STOP_CONDITION);


             /* Clear interrupt, if we missed any, in case of error */
             IntEventClear(SYS_INT_I2C0_INT);
             txCompFlag = 0;
             AckRolling = 1;
         }


         if (I2CMasterIntStatus(SOC_I2C_0_REGS) & I2C_ICSTR_NACKSNT)
         {
             I2CMasterIntDisableEx(SOC_I2C_0_REGS, I2C_INT_TRANSMIT_READY |
                                                   I2C_INT_DATA_READY |
                                                   I2C_INT_NO_ACK |
                                                   I2C_INT_STOP_CONDITION);


             /* Generate a STOP */
             I2CMasterStop(SOC_I2C_0_REGS);


             I2CStatusClear(SOC_I2C_0_REGS, (I2C_CLEAR_NO_ACK_SENT |
                                             I2C_CLEAR_STOP_CONDITION));


             /* Clear interrupt, if we missed any, in case of error */
             IntEventClear(SYS_INT_I2C0_INT);
             txCompFlag = 0;
         }


         intCode = I2CInterruptVectorGet(SOC_I2C_0_REGS);
    }
}


/*******************************************/
/*                                                                          */
/*              写单个个字节到指定EEPROM地址中          */
/*                                                                          */
/*                                                                          */
/*   Address -- EEPROM字节地址                               */
/*   Data    -- 值                                                       */
/*******************************************/
void EEPROM_ByteWrite(unsigned int Address, unsigned char Data)
{
    slaveData[0] = Address;
    slaveData[1] = Data;


    I2C0SendBlocking(2);


}
/*******************************************/
/*                                                                          */
/*              写多个字节到指定EEPROM地址中             */
/*                                                                          */
/*   Address -- EEPROM字节地址                              */
/*   Data    -- 缓冲区                                                */
/*   Size    -- 缓冲区有效长度                                    */
/*******************************************/
void EEPROM_PageWrite(unsigned int Address, unsigned char * Data, unsigned int Size)
{
int i;
slaveData[0] = Address;
for (i=0;i<Size;i++)
slaveData[i+1] = Data[i];
I2C0SendBlocking(Size + 1);
}
/*******************************************/
/*                                                                          */
/*              在EEPROM当前地址读取                          */
/*                                                                          */
/*   返回值      -- 读取值                                          */
/*******************************************/
unsigned char EEPROM_CurrentAddressRead(void)
{
I2C0RcvBlocking(1);


return slaveData[0];
}


/*******************************************/
/*                                                                          */
/*             在EEPROM任意字节地址读取                    */
/*                                                                          */
/*   Address -- EEPROM字节地址                              */
/*   返回值      -- 读取值                                          */
/*******************************************/
unsigned char EEPROM_RandomRead(unsigned int Address)
{
slaveData[0] = Address;
    I2C0SendBlocking(1);
    I2C0RcvBlocking(1);
    return slaveData[0];
}


/*******************************************/
/*                                                                          */
/*              在EEPROM指定地址连续读                      */
/*                                                                          */
/*   Address -- EEPROM字节地址                              */
/*   Data    -- 接收缓冲区                                         */
/*   Size    -- 读取长度                                            */
/*******************************************/
void EEPROM_SequentialRead(unsigned int Address , unsigned char * Data , unsigned int Size)
{
int i;
slaveData[0] = Address;
    I2C0SendBlocking(1);
    I2C0RcvBlocking(Size);
for (i=0;i<Size;i++)
Data[i] = slaveData[i] ;
}


/*******************************************/
/*                                                                          */
/*              EEPROM进入写周期状态轮询                   */
/*                                                                          */
/*******************************************/
void EEPROM_AckPolling(void)
{
do
{
AckRolling = 0;
Delay(0xFFFFF);
slaveData[0] = AT24C_ADDRESS;
I2C0SendBlocking(1);
Delay(0xFFFFF);
}while(AckRolling==1);
}


/*****************************************/
/*                                                                       */
/*              指令时钟方法延时                                */
/*                                                                        */
/*   delay   -- 循环次数                                          */
/******************************************/
static void Delay(volatile unsigned int delay)
{
    while(delay--);
}
/************* End Of File *******************/


详细代码下载地址:http://download.csdn.net/detail/gzchuanglong/7581033

*博客内容为网友个人发布,仅代表博主个人观点,如有侵权请联系工作人员删除。

参与讨论
登录后参与讨论
推荐文章
最近访客