added methods to send 16bit works on the bus - using BIG endian byte ordering

Author: gigapod

src/sfeTk/sfeTkIBus.h

@@ -96,7 +96,7 @@ class sfeTkIBus
     virtual sfeTkError_t writeByte(uint8_t data) = 0;
 
     /**--------------------------------------------------------------------------
-     *  @brief Send a word to the device. 
+     *  @brief Send a word to the device.
      *  @param data Data to write.
      *
      *  @retval sfeTkError_t -  kSTkErrOk on successful execution.
@@ -160,6 +160,17 @@ class sfeTkIBus
      */
     virtual sfeTkError_t writeRegister16Region(uint16_t devReg, const uint8_t *data, size_t length) = 0;
 
+    /**--------------------------------------------------------------------------
+     *  @brief Writes a number of uint16's starting at the given register's 16-bit address.
+     *
+     *  @param devReg The device's register's address.
+     *  @param data Data to write.
+     *  @param length - length of data
+     *
+     *   @retval sfeTkError_t kSTkErrOk on successful execution
+     *
+     */
+    virtual sfeTkError_t writeRegister16Region16(uint16_t devReg, const uint16_t *data, size_t length) = 0;
     /**--------------------------------------------------------------------------
      *  @brief Read a single byte from the given register
      *
@@ -206,6 +217,19 @@ class sfeTkIBus
      *
      */
     virtual sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes, size_t &readBytes) = 0;
+
+    /**--------------------------------------------------------------------------
+     *  @brief Reads a block of data from the given 16-bit register address.
+     *
+     *   @param reg The device's 16 bit register's address.
+     *   @param data Data to write.
+     *   @param numBytes - length of data
+     *   @param[out] readBytes - number of bytes read
+     *
+     *   @retval int returns kSTkErrOk on success, or kSTkErrFail code
+     *
+     */
+    virtual sfeTkError_t readRegister16Region16(uint16_t reg, uint16_t *data, size_t numBytes, size_t &readBytes) = 0;
 };
 
 //};

src/sfeTkArdI2C.cpp

@@ -180,7 +180,7 @@ sfeTkError_t sfeTkArdI2C::writeRegisterRegionAddress(uint8_t *devReg, size_t reg
 
     _i2cPort->beginTransmission(address());
 
-    if(devReg != nullptr && regLength > 0)
+    if (devReg != nullptr && regLength > 0)
         _i2cPort->write(devReg, regLength);
 
     _i2cPort->write(data, (int)length);
@@ -213,7 +213,23 @@ sfeTkError_t sfeTkArdI2C::writeRegister16Region(uint16_t devReg, const uint8_t *
     return writeRegisterRegionAddress((uint8_t *)&devReg, 2, data, length);
 }
 
+//---------------------------------------------------------------------------------
+// write16BitRegisterRegion16()
+//
+// Writes an array of bytes to a given 16-bit register on the target address
+//
+// Returns the number of bytes written, < 0 is an error
+//
+sfeTkError_t sfeTkArdI2C::writeRegister16Region16(uint16_t devReg, const uint16_t *data, size_t length)
+{
+    devReg = ((devReg << 8) & 0xff00) | ((devReg >> 8) & 0x00ff);
 
+    uint16_t data16[length];
+    // TODO determine local endianess and convert if needed
+    for (size_t i = 0; i < length; i++)
+        data16[i] = ((data[i] << 8) & 0xff00) | ((data[i] >> 8) & 0x00ff);
+    return writeRegisterRegionAddress((uint8_t *)&devReg, 2, (uint8_t *)data16, length * 2);
+}
 
 /**
  * @brief Reads an array of bytes to a register on the target address. Supports any address size
@@ -359,3 +375,23 @@ sfeTkError_t sfeTkArdI2C::readRegister16Region(uint16_t devReg, uint8_t *data, s
     devReg = ((devReg << 8) & 0xff00) | ((devReg >> 8) & 0x00ff);
     return readRegisterRegionAnyAddress((uint8_t *)&devReg, 2, data, numBytes, readBytes);
 }
+//---------------------------------------------------------------------------------
+// read16BitRegisterRegion16()
+//
+// 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::readRegister16Region16(uint16_t devReg, uint16_t *data, size_t numBytes, size_t &readBytes)
+{
+    devReg = ((devReg << 8) & 0xff00) | ((devReg >> 8) & 0x00ff);
+    sfeTkError_t status = readRegisterRegionAnyAddress((uint8_t *)&devReg, 2, (uint8_t *)data, numBytes * 2, readBytes);
+
+    // TODO determine local endianess and convert if needed
+    if (status == kSTkErrOk)
+    {
+        for (size_t i = 0; i < numBytes; i++)
+            data[i] = ((data[i] << 8) & 0xff00) | ((data[i] >> 8) & 0x00ff);
+    }
+    return status;
+}

src/sfeTkArdI2C.h

@@ -187,6 +187,18 @@ class sfeTkArdI2C : public sfeTkII2C
     */
     sfeTkError_t writeRegister16Region(uint16_t devReg, const uint8_t *data, size_t length);
 
+    /**
+        @brief Writes a number of bytes starting at the given register's 16-bit address.
+
+        @param devReg The device's register's address - 16 bit.
+        @param data Data to write.
+        @param length - length of data
+
+        @retval sfeTkError_t kSTkErrOk on successful execution
+
+    */
+    sfeTkError_t writeRegister16Region16(uint16_t devReg, const uint16_t *data, size_t length);
+
     /**
         @brief Reads a byte of data from the given register.
 
@@ -240,6 +252,19 @@ class sfeTkArdI2C : public sfeTkII2C
     */
     sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes, size_t &readBytes);
 
+    /**
+        @brief Reads a block of data from the given 16-bit register address.
+
+        @param reg The device's 16 bit register's address.
+        @param 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 int returns kSTkErrOk on success, or kSTkErrFail code
+
+    */
+    sfeTkError_t readRegister16Region16(uint16_t reg, uint16_t *data, size_t numBytes, size_t &readBytes);
+
     // Buffer size chunk getter/setter
     /**
         @brief set the buffer chunk size

src/sfeTkArdSPI.cpp

@@ -120,7 +120,6 @@ sfeTkError_t sfeTkArdSPI::writeWord(uint16_t dataToWrite)
     return writeRegion((uint8_t *)&dataToWrite, sizeof(uint8_t)) > 0;
 }
 
-
 //---------------------------------------------------------------------------------
 // writeRegion()
 //
@@ -240,6 +239,30 @@ sfeTkError_t sfeTkArdSPI::writeRegister16Region(uint16_t devReg, const uint8_t *
     return kSTkErrOk;
 }
 
+//---------------------------------------------------------------------------------
+// 16 bit address and data version ...
+sfeTkError_t sfeTkArdSPI::writeRegister16Region16(uint16_t devReg, const uint16_t *data, size_t length)
+{
+    if (!_spiPort)
+        return kSTkErrBusNotInit;
+
+    // Apply settings before work
+    _spiPort->beginTransaction(_sfeSPISettings);
+
+    // Signal communication start
+    digitalWrite(cs(), LOW);
+    _spiPort->transfer16(devReg);
+
+    for (size_t i = 0; i < length; i++)
+        _spiPort->transfer16(*data++);
+
+    // End communication
+    digitalWrite(cs(), HIGH);
+    _spiPort->endTransaction();
+
+    return kSTkErrOk;
+}
+//---------------------------------------------------------------------------------
 sfeTkError_t sfeTkArdSPI::readRegisterByte(uint8_t devReg, uint8_t &data)
 {
     size_t nRead;
@@ -320,3 +343,36 @@ sfeTkError_t sfeTkArdSPI::readRegister16Region(uint16_t devReg, uint8_t *data, s
 
     return kSTkErrOk;
 }
+
+//---------------------------------------------------------------------------------
+// readRegister16Region16()
+//
+// Reads an array of uint16 to a given a 16 bit register on the target address
+//
+// Returns kSTkErrOk on success
+//
+sfeTkError_t sfeTkArdSPI::readRegister16Region16(uint16_t devReg, uint16_t *data, size_t numBytes, size_t &readBytes)
+{
+    if (!_spiPort)
+        return kSTkErrBusNotInit;
+
+    // Apply settings
+    _spiPort->beginTransaction(_sfeSPISettings);
+
+    // Signal communication start
+    digitalWrite(cs(), LOW);
+
+    // A leading "1" must be added to transfer with devRegister to indicate a "read"
+    _spiPort->transfer16(devReg | kSPIReadBit);
+
+    for (size_t i = 0; i < numBytes; i++)
+        *data++ = _spiPort->transfer16(0x00);
+
+    // End transaction
+    digitalWrite(cs(), HIGH);
+    _spiPort->endTransaction();
+
+    readBytes = numBytes;
+
+    return kSTkErrOk;
+}

src/sfeTkArdSPI.h

@@ -178,6 +178,18 @@ class sfeTkArdSPI : public sfeTkISPI
     */
     sfeTkError_t writeRegister16Region(uint16_t devReg, const uint8_t *data, size_t length);
 
+    /**
+        @brief Writes a number of uint16s starting at the given register's address.
+        @note This method is virtual to allow it to be overridden to support a device that requires a unique impl
+
+        @param devReg The device's register's address.
+        @param data Data to write.
+        @param length - length of data
+
+        @retval sfeTkError_t - kSTkErrOk on success
+        */
+    sfeTkError_t writeRegister16Region16(uint16_t devReg, const uint16_t *data, size_t length);
+
     /**
         @brief Read a single byte from the given register
 
@@ -224,6 +236,19 @@ class sfeTkArdSPI : public sfeTkISPI
     */
     virtual sfeTkError_t readRegister16Region(uint16_t reg, uint8_t *data, size_t numBytes, size_t &readBytes);
 
+    /**
+            @brief Reads a block of data from the given register.
+            @note This method is virtual to allow it to be overridden to support a device that requires a unique impl
+
+            @param reg The device's register's 16 bit address.
+            @param[out] data Data buffer to read into
+            @param numBytes - Length of data to read/size of data buffer
+            @param[out] readBytes - Number of bytes read
+
+            @retval sfeTkError_t - true on success
+        */
+    virtual sfeTkError_t readRegister16Region16(uint16_t reg, uint16_t *data, size_t numBytes, size_t &readBytes);
+
   protected:
     // note: The instance data is protected, allowing access if a sub-class is
     //      created to implement a special read/write routine