[参考译文] TMS320F28388D：F28388d / I2C 接口/从从器件读取多个字节的数据

e2e.ti.com/.../TEST_5F00_CODE_5F00_20211222.txt

Lee、

请考虑修改 最新 C2000Ware 中提供的 i2c_ex6_EEPROM_interrupt.c 示例代码。 此示例使用 I2C 通过中断方法读取/写入"N"个字节。

此致、

曼诺伊

您好、TI 技术团队！！

有一个与 I2C 读取相关的问题。

通过稍微修改 ex6 EEPROM 中断示例来执行调试。

仍然、一个字节的读取/写入操作正常。

但是、当读取读'N'字节时、会出现与之前代码相同的问题。

这次、第五个寄存器(或第一个寄存器)地址的数据被读取5次并存储在 Rx 缓冲器中。

请参阅修改后的示例代码。

请详细查看！

请注意

JM LEE

//
// Included Files
//
#include "driverlib.h"
#include "device.h"
#include "i2cLib_FIFO_master_interrupt.h"

#define BUFFER_SIZE 5
//
// Defines
//
#define EEPROM_SLAVE_ADDRESS        0x18

//
// Globals
//

struct I2CHandle EEPROM;
struct I2CHandle *currentResponderPtr;                   // Used in interrupt
uint16_t AvailableI2C_slaves[20];
uint16_t TX_MsgBuffer[BUFFER_SIZE];
uint16_t RX_MsgBuffer[BUFFER_SIZE];
uint32_t ControlAddr;
uint16_t status=0;

//
// Function Prototypes
//

interrupt void i2cFIFO_isr(void);
interrupt void i2c_isr(void);
void I2C_GPIO_init(void);
void I2Cinit(void);

//
// Main
//
void main(void)
{
    //
    // Initialize device clock and peripherals
    //
    Device_init();

    //
    // Disable pin locks and enable internal pullups.
    //
    Device_initGPIO();

    //
    // Initialize I2C pins
    //
    I2C_GPIO_init();

    //
    // Initialize PIE and clear PIE registers. Disable CPU interrupts.
    //
    Interrupt_initModule();

    //
    // Initialize the PIE vector table with pointers to the shell Interrupt
    // Service Routines (ISR).
    //
    Interrupt_initVectorTable();

    I2Cinit();
    //
    // Interrupts that are used in this example are re-mapped to ISR functions
    // found within this file.
    //
    Interrupt_register(INT_I2CB_FIFO, &i2cFIFO_isr);

    Interrupt_enable(INT_I2CB_FIFO);

    Interrupt_register(INT_I2CB, &i2c_isr);

    Interrupt_enable(INT_I2CB);


    //
    // Enable Global Interrupt (INTM) and realtime interrupt (DBGM)
    //
    EINT;
    ERTM;

    //I2Cs connected to I2CA will be found in AvailableI2C_slaves buffer
    //after you run I2CBusScan function.
    uint16_t *pAvailableI2C_slaves = AvailableI2C_slaves;
    status = I2CBusScan(I2CB_BASE, pAvailableI2C_slaves);

    //uint16_t i;

    currentResponderPtr = &EEPROM;

    EEPROM.currentHandlePtr     = &EEPROM;
    EEPROM.SlaveAddr            = EEPROM_SLAVE_ADDRESS;
    EEPROM.WriteCycleTime_in_us = 10000;    //6ms for EEPROM this code was tested
    EEPROM.base = I2CB_BASE;
    EEPROM.pControlAddr = &ControlAddr;
    EEPROM.NumOfAddrBytes = 1;


    TX_MsgBuffer[0] = 0x07;
    TX_MsgBuffer[1] = 0x23;
    TX_MsgBuffer[2] = 0;
    TX_MsgBuffer[3] = 0;
    TX_MsgBuffer[4] = 0x03;

    ControlAddr = 0x20;   
    EEPROM.NumOfDataBytes = BUFFER_SIZE;
    EEPROM.pTX_MsgBuffer = TX_MsgBuffer;
    status = I2C_MasterTransmitter(&EEPROM);
    DEVICE_DELAY_US(EEPROM.WriteCycleTime_in_us);


    while (1)
    {        
        ControlAddr = 0x20;
        EEPROM.pControlAddr = &ControlAddr;
        EEPROM.pRX_MsgBuffer = RX_MsgBuffer;
        EEPROM.NumOfDataBytes = BUFFER_SIZE;

        status = I2C_MasterReceiver(&EEPROM);
        DEVICE_DELAY_US(EEPROM.WriteCycleTime_in_us);

    }


}

interrupt void i2c_isr(void)
{
    uint16_t MasterSlave = HWREGH(currentResponderPtr->base + I2C_O_MDR);

    handleI2C_ErrorCondition(currentResponderPtr);

    if(MasterSlave & I2C_MDR_MST)
    {
        I2C_enableInterrupt(currentResponderPtr->base, I2C_INT_RXFF);
        I2C_clearInterruptStatus(currentResponderPtr->base,(I2C_INT_RXFF));
    }
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP8);
}

interrupt void i2cFIFO_isr(void)
{
    Write_Read_TX_RX_FIFO(currentResponderPtr);

    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP8);
}


void I2C_GPIO_init(void)
{
    // I2CB pins (SDAA / SCLA)
    GPIO_setDirectionMode(35, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(35, GPIO_PIN_TYPE_PULLUP);    
    GPIO_setMasterCore(35, GPIO_CORE_CPU1);
    GPIO_setQualificationMode(35, GPIO_QUAL_ASYNC);

    GPIO_setDirectionMode(40, GPIO_DIR_MODE_IN);
    GPIO_setPadConfig(40, GPIO_PIN_TYPE_PULLUP);    
    GPIO_setMasterCore(40, GPIO_CORE_CPU1);
    GPIO_setQualificationMode(40, GPIO_QUAL_ASYNC);

    GPIO_setPinConfig(GPIO_35_I2CB_SCL);
    GPIO_setPinConfig(GPIO_40_I2CB_SDA);

}

void I2Cinit(void)
{
    I2C_disableModule(I2CB_BASE);

    I2C_initMaster(I2CB_BASE, DEVICE_SYSCLK_FREQ, 100000, I2C_DUTYCYCLE_50); // I2C configuration. Use a 100kHz I2CCLK with a 50% duty cycle.
    I2C_setConfig(I2CB_BASE, I2C_MASTER_SEND_MODE);
    I2C_setSlaveAddress(I2CB_BASE, 80);
    //I2C_setOwnSlaveAddress(I2CB_BASE, 96);
    I2C_disableLoopback(I2CB_BASE);
    I2C_setBitCount(I2CB_BASE, I2C_BITCOUNT_8);
    I2C_setDataCount(I2CB_BASE, 2);
    I2C_setAddressMode(I2CB_BASE, I2C_ADDR_MODE_7BITS);
    I2C_enableFIFO(I2CB_BASE);
    I2C_clearInterruptStatus(I2CB_BASE, I2C_INT_ARB_LOST | I2C_INT_NO_ACK);
    I2C_setFIFOInterruptLevel(I2CB_BASE, I2C_FIFO_TXEMPTY, I2C_FIFO_RX2);
    I2C_enableInterrupt(I2CB_BASE, I2C_INT_ADDR_SLAVE | I2C_INT_ARB_LOST | I2C_INT_NO_ACK | I2C_INT_STOP_CONDITION);
    I2C_setEmulationMode(I2CB_BASE, I2C_EMULATION_FREE_RUN);

    I2C_enableModule(I2CB_BASE);
}
//
// End of File
//