用Energia写一个同样功能的USB<->I2C工具

karajanlee

用Energia写一个同样功能的USB<->I2C工具 [复制链接]

用CCS写的复杂版在这里https://bbs.eeworld.com.cn/thread-374278-1-6.html

最近有在玩Arduino，就觉得这样的编程思想很不错，完全无需知道底层代码和寄存器的实现方式，只要用封装好的函数就可以实现相应的功能，开发者只要专注在逻辑和应用上就可以了，方便许多。于是回过头来玩一下Launchpad，这次用Energia，做一个之前做过的USB-I2C工具，代码量小很多，调试错误量也小很多，方便不少，我就把代码贴在这里，大家玩玩。。呵呵

1. #include   // Need the Wire library for I2C communication
   
2. 
   
3. unsigned char dataBuff[130];          // The data buffer
   
4.                                       // The effective data area is 128 bytes.
   
5. unsigned char oneByte = 0;            // For holding the byte during each Wire.read() action
   
6. unsigned int  dataBuffIdx = 0;        // Data position during read and write
   
7. unsigned char inputDataComplete = 0;  // Indicate the input is finished
   
8.                                       // Whenever a CR or LF is received
   
9.                                       // or input data length excceed the effective data length
   
10. unsigned int  availableBytes = 0;     // Number of bytes in Serial RX buffer for read
    
11. unsigned char slaveAddr = 0;          // The 7-bit slave address
    
12. unsigned char i2cRW = 0;              // The I2C RW bit
    
13.                                       // 0x00 for master write
    
14.                                       // 0x01 for master read
    
15. unsigned char trDataLen = 0;          // The length of data to be transfered
    
16.                                       // either to I2C device or serial console
    
17. unsigned char CRLF[2] = {0x0D, 0x0A}; // The CRLF
    
18. 
    
19. void setup() {
    
20.   Serial.begin(9600);  // Start serial dialog @9600 BR
    
21.   Wire.begin();        // Prepare I2C peripherals
    
22. }
    
23. 
    
24. void loop() {
    
25.   if (inputDataComplete == 1) {                    // Data receive finished
    
26.                                                    // Go on processing data
    
27.     if (dataBuffIdx > 2) {                         // At lease 3 bytes in the data buffer
    
28.       i2cRW = dataBuff[dataBuffIdx - 1];           // The last byte received indicates I2C RW action
    
29.       slaveAddr = dataBuff[dataBuffIdx - 2];       // The I2C slave address is the byte before the RW byte
    
30.       if (i2cRW == 0x00) {                         // Master write
    
31.         trDataLen = dataBuffIdx - 2;               // The actual data length
    
32.                                                    // Excluding address byte and RW byte
    
33.         // The I2C master write action
    
34.         Wire.beginTransmission(slaveAddr);
    
35.         Wire.write(dataBuff, trDataLen);
    
36.         Wire.endTransmission();
    
37.         // --
    
38.       }
    
39.         if (i2cRW == 0x01) {                       // Master read
    
40.         trDataLen = dataBuff[0];                   // The 1st byte is the number of bytes to read
    
41.         dataBuffIdx = 0;                           // Clear the buffer index for read counting
    
42.         // The I2C master read action
    
43.         Wire.requestFrom(slaveAddr, trDataLen);
    
44.         while(Wire.available()) {
    
45.           dataBuff[dataBuffIdx] = Wire.read();
    
46.           dataBuffIdx++;
    
47.         }
    
48.         // --
    
49.         Serial.write(dataBuff, (unsigned char)dataBuffIdx);
    
50.                                                    // Write the data to serial console
    
51.                                                    // Enforce the data length to be 128 bytes at max
    
52.         Serial.write(CRLF, 2);                     // Print CRLF indicating data ending
    
53.       }
    
54.       
    
55.       // Reset data count and action status
    
56.       dataBuffIdx = 0;
    
57.       inputDataComplete = 0;
    
58.       // Clear the serial buffer
    
59.       Serial.flush();
    
60.     }
    
61.   } else {                                         // Read incoming data if available
    
62.     availableBytes = Serial.available();           // Get number of bytes available
    
63.                                                    // for reading in serial buffer
    
64.     while (availableBytes && !inputDataComplete) { // Read data when there are some bytes available
    
65.                                                    // And the input is not finished
    
66.       if (dataBuffIdx > 129) {                     // We will ignore the data
    
67.                                                    // when the buffer limit is reached
    
68.         inputDataComplete = 1;                     // And also make the input is finished
    
69.         continue;                                  // Skip all following codes
    
70.       }
    
71.       oneByte = Serial.read();                     // Read 1 byte from the serial buffer
    
72.       if (oneByte == 0x0D || oneByte == 0x0A) {    // Either CR(0x0D) or LF(0x0A) indicates the end of input
    
73.         inputDataComplete = 1;                     // Make the input is finished
    
74.       } else {
    
75.         dataBuff[dataBuffIdx] = oneByte;           // Copy the byte to the data buffer
    
76.         availableBytes--;
    
77.         dataBuffIdx++;
    
78.       }
    
79.     }
    
80.   }
    
81. }
    

复制代码

karajanlee

这次发送数据的格式改变了，如下：
I2C写入：[1~128 Bytes Data] [7-bit Slave Address] 0x00 0x0D 0x0A
I2C读取：[Number of Bytes to Read] [7-bit Slave Address] 0x01 0x0D 0x0A

[ 本帖最后由 karajanlee 于 2013-9-18 13:39 编辑 ]

wstt

赞一个，我们板块上也开始使用arduino的开发工具。期待lz更多的关于arduino的介绍。

在路上的旁观者

学习了