Linux i2c rework for better compatibility

Author: jp-bennett

cores/portduino/linux/LinuxHardwareI2C.cpp

@@ -12,13 +12,16 @@
 
 extern "C"
 {
-    #include<linux/i2c-dev.h>
+    #include <linux/i2c-dev.h>
     #include <i2c/smbus.h>
 }
 
 
 namespace arduino {
-    char buf[100] = {0};
+    char TXbuf[1000] = {0};
+    char RXbuf[1000] = {0};
+    int RXlen = 0;
+    size_t RXindex = 0;
     int requestedBytes = 0;
     int sessionstatus;
     LinuxHardwareI2C Wire;
@@ -43,12 +46,17 @@ namespace arduino {
 
     void LinuxHardwareI2C::beginTransmission(uint8_t address) {
         sessionstatus = ioctl(i2c_file, I2C_SLAVE, address);
+        requestedBytes = 0;
     }
     uint8_t LinuxHardwareI2C::endTransmission(bool stopBit) {
         if (requestedBytes) {
-            int resp = ::write(i2c_file, buf, requestedBytes);
+            int resp = ::write(i2c_file, TXbuf, requestedBytes);
+            bool success = resp == requestedBytes;
             requestedBytes = 0;
-            return resp;
+            if (success)
+                return 0;
+            else
+                return 4;
         }
         return 0;
 
@@ -60,15 +68,28 @@ namespace arduino {
     }
 
     size_t LinuxHardwareI2C::write(uint8_t toWrite) {
-        buf[requestedBytes] = toWrite; // todo: alloc and copy
+        TXbuf[requestedBytes] = toWrite;
         requestedBytes++;
         return 0;
     }
     size_t LinuxHardwareI2C::write(const uint8_t *buffer, size_t size) {
-        return ::write(i2c_file, buffer, size); // Should this defer actual writing til transaction close?
+        for (int i = 0; i < size; i++) {
+            TXbuf[requestedBytes] = buffer[i];
+            requestedBytes++;
+        }
+        return size;
     }
 
     int LinuxHardwareI2C::read() {
+        if (RXlen - RXindex != 0) {
+            int tmpVal = RXbuf[RXindex];
+            RXindex++;
+            if (RXindex == RXlen || RXindex > 999) {
+                RXindex = 0;
+                RXlen = 0;
+            }
+            return tmpVal;
+        }
         int tmpBuf = 0;
         if (::read(i2c_file, &tmpBuf, 1) == -1)
             return -1;
@@ -82,18 +103,27 @@ namespace arduino {
             return length;
         } else {
             bytes_read = ::read(i2c_file, buffer, length);
-            if ( bytes_read < 0) bytes_read = 0;
+            if ( bytes_read < 0)
+                bytes_read = 0;
         }
         return bytes_read;
     }
 
     int LinuxHardwareI2C::available() {
-        int numBytes;
+        if (RXlen - RXindex != 0)
+            return RXlen - RXindex;
+        int numBytes = 0;
         ioctl(i2c_file, FIONREAD, &numBytes);
         return numBytes;
     }
 
-    uint8_t LinuxHardwareI2C::requestFrom(uint8_t address, size_t) {
-        return ioctl(i2c_file, I2C_SLAVE, address);
+    uint8_t LinuxHardwareI2C::requestFrom(uint8_t address, size_t count, bool stop) {
+        ioctl(i2c_file, I2C_SLAVE, address);
+        RXlen  = ::read(i2c_file, RXbuf, count);
+        if (RXlen < 1) {
+            RXlen = 0;
+        }
+        RXindex = 0;
+        return RXlen;
     }
 }

cores/portduino/linux/LinuxHardwareI2C.h

@@ -20,7 +20,7 @@ enum ResultI2c {
 };
 
 class LinuxHardwareI2C : public HardwareI2C {
-  int i2c_file;
+  int i2c_file = 0;
 
 public:
   void begin(const char* device);
@@ -39,12 +39,11 @@ class LinuxHardwareI2C : public HardwareI2C {
 
   virtual uint8_t endTransmission(void) { return endTransmission(true); }
 
-  virtual uint8_t requestFrom(uint8_t address, size_t len, bool stopBit) {
-    notImplemented("requestFrom");
-    return 0;
-  }
+  virtual uint8_t requestFrom(uint8_t address, size_t len, bool stopBit);
 
-  virtual uint8_t requestFrom(uint8_t address, size_t len);
+  virtual uint8_t requestFrom(uint8_t address, size_t len)  {
+    return requestFrom(address, len, true);
+  }
 
   virtual void onReceive(void (*)(int)) NOT_IMPLEMENTED("onReceive");
 
@@ -65,7 +64,7 @@ class LinuxHardwareI2C : public HardwareI2C {
   virtual int read();
 
   virtual uint8_t readBytes(uint8_t address, size_t len, bool stopBit) {
-    notImplemented("requestFrom");
+    notImplemented("readBytes");
     return 0;
   }