Operational code for 16bit registers

Need to clean up a bit, but the code is now functional and able to read/write to the proper registers with the proper data.

Author: MadisonC-SparkFun

src/sfeTk/sfeTkIBus.h

@@ -150,7 +150,7 @@ class sfeTkIBus
         @retval int returns kSTkErrOk on success, or kSTkErrFail code
 
     */
-    virtual sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes, size_t *readBytes = nullptr) = 0;
+    virtual sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes) = 0;
 
 };
 

src/sfeTkArdI2C.cpp

@@ -136,108 +136,58 @@ sfeTkError_t sfeTkArdI2C::writeRegisterWord(uint8_t devReg, uint16_t dataToWrite
     return writeRegisterRegion(devReg, (uint8_t *)&dataToWrite, sizeof(uint16_t));
 }
 
-//---------------------------------------------------------------------------------
-// writeRegisterRegion()
-//
-// Writes an array of bytes to a given register on the target address
-//
-// Returns the number of bytes written, < 0 is an error
-//
-sfeTkError_t sfeTkArdI2C::writeRegisterRegion(uint8_t devReg, const uint8_t *data, size_t length)
+sfeTkError_t sfeTkArdI2C::writeRegisterRegionAddress(uint8_t *devReg, size_t regLength, const uint8_t *data, size_t length)
 {
     if (!_i2cPort)
         return kSTkErrBusNotInit;
 
     _i2cPort->beginTransmission(address());
-    _i2cPort->write(devReg);
+    _i2cPort->write(devReg, regLength);
     _i2cPort->write(data, (int)length);
 
     return _i2cPort->endTransmission() ? kSTkErrFail : kSTkErrOk;
 }
 
 //---------------------------------------------------------------------------------
-// write16BitRegisterRegion()
+// writeRegisterRegion()
 //
-// Writes an array of bytes to a given 16-bit register on the target address
+// Writes an array of bytes to a given register on the target address
 //
 // Returns the number of bytes written, < 0 is an error
 //
-//sfeTkError_t sfeTkArdI2C::write16BitRegisterRegion(uint16_t devReg, uint8_t *data, size_t length)
-sfeTkError_t sfeTkArdI2C::writeRegister16Region(uint16_t devReg, uint8_t *data, size_t length)
-
+sfeTkError_t sfeTkArdI2C::writeRegisterRegion(uint8_t devReg, const uint8_t *data, size_t length)
 {
-    if (!_i2cPort)
-        return kSTkErrBusNotInit;
-    _i2cPort->beginTransmission(address());
-    _i2cPort->write((devReg >> 8) & 0xff);
-    _i2cPort->write(devReg & 0xff);
-    for(int i = 0; i < length; i++)
-    {
-        _i2cPort->write(data[i]);
-    }
-
-    return _i2cPort->endTransmission() ? kSTkErrFail : kSTkErrOk;
+    return writeRegisterRegionAddress(&devReg, 1, data, length);
 }
 
 //---------------------------------------------------------------------------------
-// readRegisterByte()
+// write16BitRegisterRegion()
 //
-// Reads a byte to a given register.
+// Writes an array of bytes to a given 16-bit register on the target address
 //
-// Returns true on success, false on failure
+// Returns the number of bytes written, < 0 is an error
 //
-sfeTkError_t sfeTkArdI2C::readRegisterByte(uint8_t devReg, uint8_t &dataToRead)
-{
-    if (!_i2cPort)
-        return kSTkErrBusNotInit;
-
-    // Return value
-    uint8_t result = 0;
-
-    int nData = 0;
-
-    _i2cPort->beginTransmission(address());
-    _i2cPort->write(devReg);
-    _i2cPort->endTransmission(stop());
-    _i2cPort->requestFrom(address(), (uint8_t)1);
-
-    while (_i2cPort->available()) // slave may send less than requested
-    {
-        result = _i2cPort->read(); // receive a byte as a proper uint8_t
-        nData++;
-    }
-
-    if (nData == sizeof(uint8_t)) // Only update outputPointer if a single byte was returned
-        dataToRead = result;
+// sfeTkError_t sfeTkArdI2C::writeRegister16Region(uint16_t devReg, uint8_t *data, size_t length)
+// {
+//     if (!_i2cPort)
+//         return kSTkErrBusNotInit;
+//     _i2cPort->beginTransmission(address());
+//     _i2cPort->write((devReg >> 8) & 0xff);
+//     _i2cPort->write(devReg & 0xff);
+//     for(int i = 0; i < length; i++)
+//     {
+//         _i2cPort->write(data[i]);
+//     }
+//     return _i2cPort->endTransmission() ? kSTkErrFail : kSTkErrOk;
+// }
 
-    return (nData == sizeof(uint8_t) ? kSTkErrOk : kSTkErrFail);
-}
-//---------------------------------------------------------------------------------
-// readRegisterWord()
-//
-// Reads a world to a given register.
-//
-// Returns true on success, false on failure
-//
-sfeTkError_t sfeTkArdI2C::readRegisterWord(uint8_t devReg, uint16_t &dataToRead)
+sfeTkError_t sfeTkArdI2C::writeRegister16Region(uint16_t devReg, uint8_t *data, size_t length)
 {
-    if (!_i2cPort)
-        return kSTkErrBusNotInit;
-
-    size_t nRead;
-    sfeTkError_t retval = readRegisterRegion(devReg, (uint8_t *)&dataToRead, sizeof(uint16_t), nRead);
-
-    return (retval == kSTkErrOk && nRead == sizeof(uint16_t) ? kSTkErrOk : retval);
+    devReg = ((devReg << 8) & 0xff00) | ((devReg >> 8) & 0x00ff);
+    return writeRegisterRegionAddress((uint8_t*)&devReg, 2, data, length);
 }
 
-//---------------------------------------------------------------------------------
-// readRegisterRegion()
-//
-// Reads an array of bytes to a given register on the target address
-//
-// Returns the number of bytes read, < 0 is an error
-//
-sfeTkError_t sfeTkArdI2C::readRegisterRegion(uint8_t devReg, uint8_t *data, size_t numBytes, size_t &readBytes)
+sfeTkError_t sfeTkArdI2C::readRegisterRegionAnyAddress(uint8_t *devReg, size_t regLength, uint8_t *data, size_t numBytes, size_t &readBytes)
 {
 
     // got port
@@ -262,7 +212,10 @@ sfeTkError_t sfeTkArdI2C::readRegisterRegion(uint8_t devReg, uint8_t *data, size
         {
             _i2cPort->beginTransmission(address());
 
-            _i2cPort->write(devReg);
+            // uint16_t *foo = (uint16_t*)devReg;
+            // _i2cPort->write((*foo >> 8) & 0xff);
+            // _i2cPort->write(*foo & 0xff);
+            _i2cPort->write(devReg, regLength);
 
             if (_i2cPort->endTransmission(stop()) != 0)
                 return kSTkErrFail; // error with the end transmission
@@ -295,80 +248,81 @@ sfeTkError_t sfeTkArdI2C::readRegisterRegion(uint8_t devReg, uint8_t *data, size
 }
 
 
-
-
 //---------------------------------------------------------------------------------
-// read16BitRegisterRegion()
+// readRegisterByte()
 //
-// Reads an array of bytes to a given 16-bit register on the target address
+// Reads a byte to a given register.
 //
-// Returns the number of bytes read, < 0 is an error
+// Returns true on success, false on failure
 //
-//sfeTkError_t sfeTkArdI2C::read16BitRegisterRegion(uint16_t devReg, uint8_t *data, size_t numBytes, size_t *readBytes)
-sfeTkError_t sfeTkArdI2C::readRegister16Region(uint16_t devReg, uint8_t *data, size_t numBytes, size_t *readBytes)
+sfeTkError_t sfeTkArdI2C::readRegisterByte(uint8_t devReg, uint8_t &dataToRead)
 {
-
-    // got port
     if (!_i2cPort)
         return kSTkErrBusNotInit;
 
-    // Buffer valid?
-    if (!data)
-        return kSTkErrBusNullBuffer;
-  
-    if(readBytes != nullptr)
-    {
-        readBytes = 0;
-    }
-
-    uint16_t nOrig = numBytes; // original number of bytes.
-    uint8_t nChunk;
-    uint16_t nReturned;
-    uint16_t i;              // counter in loop
-    bool bFirstInter = true; // Flag for first iteration - used to send devRegister
-
-    while (numBytes > 0)
-    {
-        if (bFirstInter)
-        {
-            _i2cPort->beginTransmission(address());
-
-            _i2cPort->write((devReg >> 8) & 0xff);
-            _i2cPort->write(devReg & 0xff);
-
-            if (_i2cPort->endTransmission(stop()) != 0)
-                return kSTkErrFail; // error with the end transmission
+    // Return value
+    uint8_t result = 0;
 
-            bFirstInter = false;
-        }
+    int nData = 0;
 
-        // We're chunking in data - keeping the max chunk to kMaxI2CBufferLength
-        nChunk = numBytes > _bufferChunkSize ? _bufferChunkSize : numBytes;
+    _i2cPort->beginTransmission(address());
+    _i2cPort->write(devReg);
+    _i2cPort->endTransmission(stop());
+    _i2cPort->requestFrom(address(), (uint8_t)1);
 
-        // Request the bytes. If this is the last chunk, always send a stop
-        nReturned = _i2cPort->requestFrom((int)address(), (int)nChunk, (int)(nChunk == numBytes ? true : stop()));
+    while (_i2cPort->available()) // slave may send less than requested
+    {
+        result = _i2cPort->read(); // receive a byte as a proper uint8_t
+        nData++;
+    }
 
-        // No data returned, no dice
-        if (nReturned == 0)
-            return kSTkErrBusUnderRead; // error
+    if (nData == sizeof(uint8_t)) // Only update outputPointer if a single byte was returned
+        dataToRead = result;
 
-        // Copy the retrieved data chunk to the current index in the data segment
-        for (i = 0; i < nReturned; i++)
-            *data++ = _i2cPort->read();
+    return (nData == sizeof(uint8_t) ? kSTkErrOk : kSTkErrFail);
+}
+//---------------------------------------------------------------------------------
+// readRegisterWord()
+//
+// Reads a world to a given register.
+//
+// Returns true on success, false on failure
+//
+sfeTkError_t sfeTkArdI2C::readRegisterWord(uint8_t devReg, uint16_t &dataToRead)
+{
+    if (!_i2cPort)
+        return kSTkErrBusNotInit;
 
-        // Decrement the amount of data received from the overall data request amount
-        numBytes = numBytes - nReturned;
+    size_t nRead;
+    sfeTkError_t retval = readRegisterRegion(devReg, (uint8_t *)&dataToRead, sizeof(uint16_t), nRead);
 
-    } // end while
+    return (retval == kSTkErrOk && nRead == sizeof(uint16_t) ? kSTkErrOk : retval);
+}
 
-    if(readBytes != nullptr)
-    {
-        *readBytes = nOrig - numBytes; // Bytes read.
+//---------------------------------------------------------------------------------
+// readRegisterRegion()
+//
+// Reads an array of bytes to a given register on the target address
+//
+// Returns the number of bytes read, < 0 is an error
+//
+sfeTkError_t sfeTkArdI2C::readRegisterRegion(uint8_t devReg, uint8_t *data, size_t numBytes, size_t &readBytes)
+{
+    return readRegisterRegionAnyAddress(&devReg, 1, data, numBytes, readBytes);
+}
 
-        return (*readBytes == nOrig) ? kSTkErrOk : kSTkErrBusUnderRead; // Success
-    }
-    else
-    {
-        return (numBytes == 0) ? kSTkErrOk : kSTkErrBusUnderRead; // Success
-    }
-}
+//---------------------------------------------------------------------------------
+// read16BitRegisterRegion()
+//
+// Reads an array of bytes to a given 16-bit register on the target address
+//
+// Returns the number of bytes read, < 0 is an error
+//
+sfeTkError_t sfeTkArdI2C::readRegister16Region(uint16_t devReg, uint8_t *data, size_t numBytes)
+{
+    size_t readBytes = 0;
+    devReg = ((devReg << 8) & 0xff00) | ((devReg >> 8) & 0x00ff);
+//     _i2cPort->write((devReg >> 8) & 0xff);
+//     _i2cPort->write(devReg & 0xff);
+    return readRegisterRegionAnyAddress((uint8_t*)&devReg, 2, data, numBytes, readBytes);
+}

src/sfeTkArdI2C.h

@@ -200,8 +200,8 @@ class sfeTkArdI2C : public sfeTkII2C
 
         @retval int returns kSTkErrOk on success, or kSTkErrFail code
 
-    */
-    sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes, size_t *readBytes = nullptr);
+    */ 
+    sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes);
 
     // Buffer size chunk getter/setter
     /*--------------------------------------------------------------------------
@@ -237,6 +237,10 @@ class sfeTkArdI2C : public sfeTkII2C
     TwoWire *_i2cPort;
 
   private:
+sfeTkError_t writeRegisterRegionAddress(uint8_t *devReg, size_t regLength, const uint8_t *data, size_t length);
+
+sfeTkError_t readRegisterRegionAnyAddress(uint8_t *devReg, size_t regLength, uint8_t *data, size_t numBytes, size_t &readBytes);
+
     static constexpr size_t kDefaultBufferChunk = 32;
 
     // the I2C buffer chunker size