Adds read methods to compliment the previously committed write methods

Author: edspark

src/sfeTk/sfeTkIBus.h

@@ -124,6 +124,45 @@ class sfeTkIBus
      */
     virtual sfeTkError_t writeRegisterByte(uint8_t devReg, uint8_t data) = 0;
 
+    /**
+        @brief Reads a byte of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device. 
+        @param[out] data Data to read.
+
+        @retval  kStkErrOk on success
+    */
+    virtual sfeTkError_t readByte(uint8_t dataToWrite, uint8_t &data) = 0; 
+
+    /**
+        @brief Reads a word of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device.
+        @param[out] data Data to read.
+
+        @retval kSTkErrOk on success
+    */
+    virtual sfeTkError_t readWord(uint8_t dataToWrite, uint16_t &data) = 0;
+
+    /**
+        @brief Reads a block of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device.
+        @param[out] data Data buffer to read into
+        @param numBytes Number of bytes to read/length of data buffer
+        @param[out] readBytes - Number of bytes read
+
+
+        @retval kSTkErrOk on success
+    */
+    virtual sfeTkError_t readBlock(uint8_t dataToWrite, uint8_t *data, size_t numBytes, size_t &readBytes) = 0; 
+
     /**--------------------------------------------------------------------------
      * @brief Write a single word (16 bit) to the given register
      *

src/sfeTkArdI2C.cpp

@@ -22,6 +22,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "sfeTkArdI2C.h"
+#include <cstddef>
+#include <cstdint>
 
 //---------------------------------------------------------------------------------
 // init()
@@ -87,7 +89,7 @@ sfeTkError_t sfeTkArdI2C::ping()
 //---------------------------------------------------------------------------------
 // writeByte()
 //
-// Sends a single byte to the device.
+// Writes a single byte to the device, without indexing to a register.
 //
 // Returns true on success, false on failure
 //
@@ -105,7 +107,7 @@ sfeTkError_t sfeTkArdI2C::writeByte(uint8_t dataToWrite)
 //---------------------------------------------------------------------------------
 // writeWord()
 //
-// Sends a word to the device.
+// Writes a word to the device, without indexing to a register.
 //
 // Returns true on success, false on failure
 //
@@ -120,13 +122,12 @@ sfeTkError_t sfeTkArdI2C::writeWord(uint16_t dataToWrite)
 //---------------------------------------------------------------------------------
 // writeBlock()
 //
-// Sends an array of data to the device.
+// Writes a word to the device, without indexing to a register.
 //
 // Returns true on success, false on failure
 //
 sfeTkError_t sfeTkArdI2C::writeBlock(const uint8_t *data, size_t length)
 {
-    int nData = 0; 
     if (!_i2cPort)
         return kSTkErrBusNotInit;
 
@@ -218,6 +219,121 @@ sfeTkError_t sfeTkArdI2C::writeRegister16Region(uint16_t devReg, const uint8_t *
     return writeRegisterRegionAddress((uint8_t *)&devReg, 2, data, length);
 }
 
+//---------------------------------------------------------------------------------
+// readByte()
+//
+// Reads a byte from the device, without indexing to a register.
+//
+// Returns true on success, false on failure
+//
+sfeTkError_t sfeTkArdI2C::readByte(uint8_t dataToWrite, uint8_t &dataToRead)
+{
+    if (!_i2cPort)
+        return kSTkErrBusNotInit;
+
+    // Return value
+    uint8_t result = 0;
+
+    int nData = 0;
+
+    _i2cPort->beginTransmission(address());
+    _i2cPort->write(dataToWrite);
+    _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;
+
+    return (nData == sizeof(uint8_t) ? kSTkErrOk : kSTkErrFail);
+}
+
+
+//---------------------------------------------------------------------------------
+// readWord()
+//
+// Reads a word from the device, without indexing to a register.
+//
+// Returns true on success, false on failure
+//
+sfeTkError_t sfeTkArdI2C::readWord(uint8_t dataToWrite, uint16_t &dataToRead)
+{
+    if (!_i2cPort)
+        return kSTkErrBusNotInit;
+
+    size_t nRead;
+    sfeTkError_t retval = readBlock(dataToWrite, (uint8_t *)&dataToRead, sizeof(uint16_t), nRead);
+
+    return (retval == kSTkErrOk && nRead == sizeof(uint16_t) ? kSTkErrOk : retval);
+}
+
+//---------------------------------------------------------------------------------
+// readBlock()
+//
+// Reads a block of data from the device, without indexing to a register.
+//
+// Returns the number of bytes written, < 0 is an error
+//
+sfeTkError_t sfeTkArdI2C::readBlock(uint8_t dataToWrite, uint8_t *data, size_t numBytes, size_t &readBytes)
+{
+
+    // got port
+    if (!_i2cPort)
+        return kSTkErrBusNotInit;
+
+    // Buffer valid?
+    if (!data)
+        return kSTkErrBusNullBuffer;
+
+    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(dataToWrite);
+            if (_i2cPort->endTransmission(stop()) != 0)
+                return kSTkErrFail; // error with the end transmission
+
+            bFirstInter = false;
+        }
+
+        // We're chunking in data - keeping the max chunk to kMaxI2CBufferLength
+        nChunk = numBytes > _bufferChunkSize ? _bufferChunkSize : numBytes;
+
+        // 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()));
+
+        // No data returned, no dice
+        if (nReturned == 0)
+            return kSTkErrBusUnderRead; // error
+
+        // Copy the retrieved data chunk to the current index in the data segment
+        for (i = 0; i < nReturned; i++)
+            *data++ = _i2cPort->read();
+
+        // Decrement the amount of data received from the overall data request amount
+        numBytes = numBytes - nReturned;
+
+    } // end while
+
+    readBytes = nOrig - numBytes; // Bytes read.
+
+    return (readBytes == nOrig) ? kSTkErrOk : kSTkErrBusUnderRead; // Success
+}
+
 //---------------------------------------------------------------------------------
 
 /**

src/sfeTkArdI2C.h

@@ -186,6 +186,45 @@ class sfeTkArdI2C : public sfeTkII2C
     */
     sfeTkError_t writeRegister16Region(uint16_t devReg, const uint8_t *data, size_t length);
 
+    /**
+        @brief Reads a byte of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device.
+        @param[out] data Data to read.
+
+        @retval  kStkErrOk on success
+    */
+    sfeTkError_t readByte(uint8_t dataToWrite, uint8_t &data);
+
+    /**
+        @brief Reads a word of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device.
+        @param[out] data Data to read.
+
+        @retval kSTkErrOk on success
+    */
+    sfeTkError_t readWord(uint8_t dataToWrite, uint16_t &data);
+
+    /**
+        @brief Reads a block of data from the device.
+
+        @note sfeTkIBus interface method
+
+        @param dataToWrite The data to write to the device.
+        @param[out] data Data buffer to read into
+        @param numBytes Number of bytes to read/length of data buffer
+        @param[out] readBytes - Number of bytes read
+
+
+        @retval kSTkErrOk on success
+    */
+    sfeTkError_t readBlock(uint8_t dataToWrite, uint8_t *data, size_t numBytes, size_t &readBytes);
+
     /**
         @brief Reads a byte of data from the given register.