Diff: Devices/DS28E17.cpp

Revision:

6:a8c83a2e6fa4

Parent:

0:f77ad7f72d04

--- a/Devices/DS28E17.cpp	Fri Jan 19 10:25:02 2018 -0600
+++ b/Devices/DS28E17.cpp	Wed Jan 23 13:11:04 2019 -0600
@@ -39,46 +39,43 @@
 namespace MaximInterface {
 
 error_code DS28E17::writeDataWithStop(uint_least8_t I2C_addr,
-                                      const uint_least8_t * data,
-                                      size_t data_len,
+                                      span<const uint_least8_t> data,
                                       uint_least8_t * wr_status) {
-  return sendPacket(WriteDataWithStopCmd, &I2C_addr, data, data_len, NULL, 0,
-                    wr_status);
+  return sendPacket(WriteDataWithStopCmd, &I2C_addr, data,
+                    span<uint_least8_t>(), wr_status);
 }
 
 error_code DS28E17::writeDataNoStop(uint_least8_t I2C_addr,
-                                    const uint_least8_t * data, size_t data_len,
+                                    span<const uint_least8_t> data,
                                     uint_least8_t * wr_status) {
-  return sendPacket(WriteDataNoStopCmd, &I2C_addr, data, data_len, NULL, 0,
+  return sendPacket(WriteDataNoStopCmd, &I2C_addr, data, span<uint_least8_t>(),
                     wr_status);
 }
 
-error_code DS28E17::writeDataOnly(const uint_least8_t * data, size_t data_len,
+error_code DS28E17::writeDataOnly(span<const uint_least8_t> data,
                                   uint_least8_t * wr_status) {
-  return sendPacket(WriteDataOnlyCmd, NULL, data, data_len, NULL, 0, wr_status);
+  return sendPacket(WriteDataOnlyCmd, NULL, data, span<uint_least8_t>(),
+                    wr_status);
 }
 
-error_code DS28E17::writeDataOnlyWithStop(const uint_least8_t * data,
-                                          size_t data_len,
+error_code DS28E17::writeDataOnlyWithStop(span<const uint_least8_t> data,
                                           uint_least8_t * wr_status) {
-  return sendPacket(WriteDataOnlyWithStopCmd, NULL, data, data_len, NULL, 0,
+  return sendPacket(WriteDataOnlyWithStopCmd, NULL, data, span<uint_least8_t>(),
                     wr_status);
 }
 
 error_code DS28E17::writeReadDataWithStop(uint_least8_t I2C_addr,
-                                          const uint_least8_t * write_data,
-                                          size_t write_data_len,
-                                          uint_least8_t * read_data,
-                                          size_t read_data_len,
+                                          span<const uint_least8_t> write_data,
+                                          span<uint_least8_t> read_data,
                                           uint_least8_t * wr_status) {
-  return sendPacket(WriteReadDataWithStopCmd, &I2C_addr, write_data,
-                    write_data_len, read_data, read_data_len, wr_status);
+  return sendPacket(WriteReadDataWithStopCmd, &I2C_addr, write_data, read_data,
+                    wr_status);
 }
 
 error_code DS28E17::readDataWithStop(uint_least8_t I2C_addr,
-                                     uint_least8_t * data, size_t data_len) {
-  return sendPacket(ReadDataWithStopCmd, &I2C_addr, NULL, 0, data, data_len,
-                    NULL);
+                                     span<uint_least8_t> data) {
+  return sendPacket(ReadDataWithStopCmd, &I2C_addr, span<const uint_least8_t>(),
+                    data, NULL);
 }
 
 error_code DS28E17::writeConfigReg(I2CSpeed speed) {
@@ -87,8 +84,7 @@
     // Send CMD and Data
     const uint_least8_t send_block[] = {WriteConfigurationCmd,
                                         static_cast<uint_least8_t>(speed)};
-    result = master->writeBlock(send_block,
-                                sizeof(send_block) / sizeof(send_block[0]));
+    result = master->writeBlock(send_block);
   }
   return result;
 }
@@ -141,18 +137,14 @@
 }
 
 error_code DS28E17::sendPacket(Command command, const uint_least8_t * I2C_addr,
-                               const uint_least8_t * write_data,
-                               size_t write_data_len, uint_least8_t * read_data,
-                               size_t read_data_len,
+                               span<const uint_least8_t> write_data,
+                               span<uint_least8_t> read_data,
                                uint_least8_t * wr_status) {
   const int pollLimit = 10000;
-  const size_t minDataLen = 1;
-  const size_t maxDataLen = 255;
+  const span<const uint_least8_t>::index_type maxDataLen = 255;
 
-  if ((write_data &&
-       (write_data_len < minDataLen || write_data_len > maxDataLen)) ||
-      (read_data &&
-       (read_data_len < minDataLen || read_data_len > maxDataLen))) {
+  if ((!write_data.empty() && write_data.size() > maxDataLen) ||
+      (!read_data.empty() && read_data.size() > maxDataLen)) {
     return make_error_code(OutOfRangeError);
   }
 
@@ -172,21 +164,21 @@
       return result;
     }
   }
-  if (write_data) {
-    crc16 = calculateCrc16(static_cast<uint_fast8_t>(write_data_len), crc16);
-    result = master->writeByte(static_cast<uint_least8_t>(write_data_len));
+  if (!write_data.empty()) {
+    crc16 = calculateCrc16(static_cast<uint_fast8_t>(write_data.size()), crc16);
+    result = master->writeByte(static_cast<uint_least8_t>(write_data.size()));
     if (result) {
       return result;
     }
-    crc16 = calculateCrc16(write_data, write_data_len, crc16);
-    result = master->writeBlock(write_data, write_data_len);
+    crc16 = calculateCrc16(write_data, crc16);
+    result = master->writeBlock(write_data);
     if (result) {
       return result;
     }
   }
-  if (read_data) {
-    crc16 = calculateCrc16(static_cast<uint_fast8_t>(read_data_len), crc16);
-    result = master->writeByte(static_cast<uint_least8_t>(read_data_len));
+  if (!read_data.empty()) {
+    crc16 = calculateCrc16(static_cast<uint_fast8_t>(read_data.size()), crc16);
+    result = master->writeByte(static_cast<uint_least8_t>(read_data.size()));
     if (result) {
       return result;
     }
@@ -194,8 +186,7 @@
   crc16 ^= 0xFFFFU;
   const uint_least8_t crc16Bytes[] = {static_cast<uint_least8_t>(crc16),
                                       static_cast<uint_least8_t>(crc16 >> 8)};
-  result = master->writeBlock(crc16Bytes,
-                              sizeof(crc16Bytes) / sizeof(crc16Bytes[0]));
+  result = master->writeBlock(crc16Bytes);
   if (result) {
     return result;
   }
@@ -225,7 +216,7 @@
   if ((status & 0x8) == 0x8) {
     return make_error_code(InvalidStartError);
   }
-  if (write_data) {
+  if (!write_data.empty()) {
     result = master->readByte(status);
     if (result) {
       return result;
@@ -237,8 +228,8 @@
       return make_error_code(WriteNackError);
     }
   }
-  if (read_data) {
-    result = master->readBlock(read_data, read_data_len);
+  if (!read_data.empty()) {
+    result = master->readBlock(read_data);
   }
   return result;
 }