【NXP Rapid IoT评测】I2C程序小bug

dvd1478

【NXP Rapid IoT评测】I2C程序小bug [复制链接]

上一篇 解决了I2C死锁解除的方法，
【NXP Rapid IoT评测】触摸按键没有反应——I2C死锁解除方法
https://bbs.eeworld.com.cn/forum ... 1480&fromuid=194541。

但是总线上挂载的外设多时，有时会遇到外设失灵的情况，后来深入分析代码，出现问题在于
ATMO_Platform_I2C_Master_Transfer 这个函数上

1. static ATMO_I2C_Status_t ATMO_Platform_I2C_Master_Transfer(
   
2.                 i2c_direction_t direction, kI2C_Blocking_t blocking, uint32_t instance,
   
3.                 uint16_t slaveAddress, const uint8_t* cmdBytes, uint16_t numCmdBytes,
   
4.                 uint8_t* dataBytes, uint16_t numDataBytes) {
   
5.         status_t platformStatus = kStatus_Fail;
   
6.         i2c_master_transfer_t masterStructure;
   
7.         uint32_t cmd;
   
8. 
   
9.         if (instance > MK64F_NUM_I2C_INSTANCES) {
   
10.                 return ATMO_I2C_Status_NotSupported;
    
11.         }
    
12. 
    
13.         if (ATMO_Platform_I2C_Peripheral[instance].operatingMode
    
14.                         == ATMO_I2C_OperatingMode_Slave) {
    
15.                 return ATMO_I2C_Status_Invalid;
    
16.         }
    
17. 
    
18.         if (numCmdBytes > 4) {
    
19.                 return ATMO_I2C_Status_NotSupported;
    
20.         }
    
21. 
    
22.         if ((dataBytes == NULL) || (numDataBytes == 0)) {
    
23.                 return ATMO_I2C_Status_Invalid;
    
24.         }
    
25. 
    
26.         // if either cmdBytes or numCmdBytes is null/zero then set both to null/zero
    
27.         if (cmdBytes == NULL) {
    
28.                 numCmdBytes = 0;
    
29.         } else if (numCmdBytes == 0) {
    
30.                 cmdBytes = NULL;
    
31.         }
    
32. 
    
33.         if (numCmdBytes == 1) {
    
34.                 cmd = cmdBytes[0];
    
35.         } else if (numCmdBytes == 2) {
    
36.                 cmd = (cmdBytes[0] << 8) | cmdBytes[1];
    
37.         } else if (numCmdBytes == 3) {
    
38.                 cmd = (cmdBytes[0] << 16) | (cmdBytes[1] << 8) | cmdBytes[2];
    
39.         } else if (numCmdBytes == 4) {
    
40.                 cmd = (cmdBytes[0] << 24) | (cmdBytes[1] << 16) | (cmdBytes[2] << 8)
    
41.                                 | cmdBytes[3];
    
42.         }
    
43. 
    
44.         masterStructure.flags = kI2C_TransferDefaultFlag;
    
45.         masterStructure.slaveAddress = slaveAddress;
    
46.         masterStructure.direction = direction;
    
47.         masterStructure.subaddress = cmd;
    
48.         masterStructure.subaddressSize = numCmdBytes;
    
49.         masterStructure.data = dataBytes;
    
50.         masterStructure.dataSize = numDataBytes;
    
51. 
    
52.         if (blocking == kI2C_Blocking) {
    
53.                 //ATMO_PLATFORM_DebugUsbPrint("ATMO_Platform_I2C_Master_Transfer kI2C_Blocking\r\n");
    
54. [color=#ff0000]                platformStatus = I2C_MasterTransferNonBlocking(peripheralBase[instance],
    
55.                                 &masterHandle[instance], &masterStructure);
    
56. 
    
57.                 uint32_t timeoutCounter = ATMO_I2C_TIMEOUT;
    
58.                 for (int i = 0; i < 1000; i++) {
    
59.                 }
    
60. 
    
61.                 while ((peripheralBase[instance]->S) & I2C_S_BUSY_MASK
    
62.                                 && (timeoutCounter > 0)) {
    
63.                         timeoutCounter--;[/color]
    
64.                 }
    
65. 
    
66.                 if (timeoutCounter == 0) {
    
67.                         //ATMO_PLATFORM_DebugUsbPrint("ATMO_Platform_I2C_Master_Transfer ATMO_I2C_Status_Timeout\r\n");
    
68.                         return ATMO_I2C_Status_Timeout;
    
69.                 }
    
70. 
    
71.         } else {
    
72.                 platformStatus = I2C_MasterTransferNonBlocking(peripheralBase[instance],
    
73.                                 &masterHandle[instance], &masterStructure);
    
74. 
    
75.         }
    
76.         //ATMO_PLATFORM_DebugUsbPrint("I2C_Master_Transfer Address:%d Status:%d \r\n",slaveAddress,platformStatus);
    
77.         return ATMO_Platform_I2C_Convert_Status_PlatformToAtmo(platformStatus);
    
78. }

复制代码

在kI2C_Blocking 读写模时 并非是阻塞式等待I2C结果的，仅仅是延时等等吧了for (int i = 0; i < 1000; i++) {
}对于120Mhz 的系统时钟，对于100Kpb的I2C实在时太少了。
同时(peripheralBase[instance]->S) & I2C_S_BUSY_MASK语句仅用共同启动I2C时才会出现。
所以代码，应该修改成如下

1. if (blocking == kI2C_Blocking) {
   
2.                 //ATMO_PLATFORM_DebugUsbPrint("ATMO_Platform_I2C_Master_Transfer kI2C_Blocking\r\n");
   
3.                 nakFlag[instance] = false;
   
4.                 completionFlag[instance] = false;
   
5.                 platformStatus = I2C_MasterTransferNonBlocking(peripheralBase[instance],
   
6.                                 &masterHandle[instance], &masterStructure);
   
7. #if 0
   
8.                 uint32_t timeoutCounter = ATMO_I2C_TIMEOUT;
   
9.                 for (int i = 0; i < 1000; i++) {
   
10.                 }
    
11. 
    
12.                 while ((peripheralBase[instance]->S) & I2C_S_BUSY_MASK
    
13.                                 && (timeoutCounter > 0)) {
    
14.                         timeoutCounter--;
    
15.                 }
    
16. 
    
17.                 if (timeoutCounter == 0) {
    
18.                         //ATMO_PLATFORM_DebugUsbPrint("ATMO_Platform_I2C_Master_Transfer ATMO_I2C_Status_Timeout\r\n");
    
19.                         return ATMO_I2C_Status_Timeout;
    
20.                 }
    
21. #else
    
22.                 /*  wait for transfer completed. */
    
23.                 while ((!nakFlag[instance]) && (!completionFlag[instance])) {
    
24.                 }
    
25.                 nakFlag[instance] = false;
    
26.                 if (completionFlag[instance] == true) {
    
27.                         completionFlag[instance] = false;
    
28.                         //ATMO_PLATFORM_DebugUsbPrint(" 0x%x", masterXfer.slaveAddress);
    
29.                 } else {
    
30.                         return ATMO_I2C_Status_Timeout;
    
31.                 }
    
32. #endif
    
33.         }

复制代码

同时在中断回调函数上添加以下代码

1. static void ATMO_Platform_I2C_Master_Callback(I2C_Type* base,
   
2.                 i2c_master_handle_t* handle, status_t status, void* userData) {
   
3.         ATMO_I2C_MasterTransfer_t masterXfer;
   
4.         uint32_t instance = I2C_GetInstance(base);
   
5.         ATMO_I2C_Master_Callback_t callback =
   
6.                         ATMO_Platform_I2C_Peripheral[instance].cbFunc;
   
7.         size_t xferCount;
   
8. 
   
9.         /* Signal transfer success when received success status. */
   
10.         if (status == kStatus_Success) {
    
11.                 completionFlag[instance] = true;
    
12. 
    
13.                 if ((handle->transfer.direction == kI2C_Read)
    
14.                                 && (status == kStatus_Success)) {
    
15.                         I2C_MasterTransferGetCount(base, handle, &xferCount);
    
16. 
    
17.                         masterXfer.event = ATMO_I2C_MasterEvent_Complete;
    
18.                         masterXfer.data = handle->transfer.data - xferCount;
    
19.                         masterXfer.dataSize = xferCount;
    
20. 
    
21.                         if (callback != NULL) {
    
22.                                 callback(&masterXfer, userData);
    
23.                         }
    
24.                 } else {
    
25.                         if (callback != NULL) {
    
26.                                 callback(&masterXfer, userData);
    
27.                         }
    
28.                 }
    
29.         }
    
30.         /* Signal transfer failure when received any other status. */
    
31.         if ((status == kStatus_I2C_Nak) || (status == kStatus_I2C_Addr_Nak)
    
32.                         || (status == kStatus_I2C_ArbitrationLost)
    
33.                         || (status == kStatus_I2C_Timeout)) {
    
34.                 nakFlag[instance] = true;
    
35.         }
    
36. 
    
37. }

复制代码

实现阻塞为读写。


同时提供一个扫描I2C总线上设备的代码

1. 
   
2. ATMO_I2C_Status_t ATMO_I2C_Scan(ATMO_DriverInstanceHandle_t instance)
   
3. {
   
4.         uint8_t cmdBuf[2]={0};
   
5.         uint8_t readBuf[1]={0};
   
6.         uint8_t slaveAddress=0;
   
7.         ATMO_I2C_Status_t status=ATMO_I2C_Status_Unknown;
   
8.         ATMO_PLATFORM_DebugUsbPrint("Driver On I2C%d Line:\r\n    ",instance);
   
9.         for(slaveAddress= 0x00;slaveAddress<=0x0f;slaveAddress++){
   
10.                 ATMO_PLATFORM_DebugUsbPrint(" %02x",slaveAddress);
    
11.         }
    
12.         //ATMO_PLATFORM_DebugUsbPrint("\r\n __",0);//slaveAddress == 0; 不存在
    
13.         for(slaveAddress= 0x00;slaveAddress<=0x7f;slaveAddress++){
    
14.                 status = ATMO_I2C_MasterRead(instance,slaveAddress,cmdBuf,0,readBuf,1,1000);
    
15.                 //status = ATMO_I2C_MasterWrite(instance,slaveAddress,cmdBuf,0,readBuf,1,1000);
    
16.                 if(slaveAddress%16==0){
    
17.                         ATMO_PLATFORM_DebugUsbPrint("\r\n0x%02X",(slaveAddress/16)*16);
    
18.                 }
    
19.                 if(status != ATMO_I2C_Status_Success){
    
20.                         ATMO_PLATFORM_DebugUsbPrint(" __");
    
21.                 }else{
    
22.                         ATMO_PLATFORM_DebugUsbPrint(" %02x",slaveAddress);
    
23.                 }
    
24. 
    
25.         }
    
26.         ATMO_PLATFORM_DebugUsbPrint("\r\n");
    
27.         return ATMO_I2C_Status_Success;
    
28. }
    

复制代码

挂在总线上的外设都能正常读取地址

MPL3115Pressure                                    0x60
TSL2572AmbientLight                              0x39
CCS811AirQuality                                    0x5A
SX9500Touch                                         0x28
FXAS21002Gyroscope                             0x20
ENS210TemperatureHumidity                  0x43
FXOS8700AccelerometerMagnetometer     0x1E




此内容由EEWORLD论坛网友dvd1478原创，如需转载或用于商业用途需征得作者同意并注明出处

hujj

资料不错哟，做标记备用。