Diff: MaximInterfaceDevices/DS9481P_300.cpp

Revision:

8:5ea891c7d1a1

Parent:

7:9cd16581b578

--- a/MaximInterfaceDevices/DS9481P_300.cpp	Mon Jul 22 11:44:07 2019 -0500
+++ b/MaximInterfaceDevices/DS9481P_300.cpp	Mon Sep 16 11:13:37 2019 -0500
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright (C) 2017 Maxim Integrated Products, Inc., All Rights Reserved.
+* Copyright (C) Maxim Integrated Products, Inc., All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
@@ -33,6 +33,8 @@
 #include <MaximInterfaceCore/Error.hpp>
 #include "DS9481P_300.hpp"
 
+#define TRY MaximInterfaceCore_TRY
+
 namespace MaximInterfaceDevices {
 
 using namespace Core;
@@ -41,209 +43,149 @@
     : serialPort(&serialPort), currentBus(OneWire), ds2480b(sleep, serialPort),
       oneWireMaster_(*this), ds9400(serialPort), i2cMaster_(*this) {}
 
-error_code DS9481P_300::connect(const std::string & portName) {
-  error_code result = serialPort->connect(portName);
-  if (!result) {
+Result<void> DS9481P_300::connect(const std::string & portName) {
+  Result<void> result = serialPort->connect(portName);
+  if (result) {
     result = selectOneWire();
     if (result) {
-      serialPort->disconnect();
+      currentBus = OneWire;
     } else {
-      currentBus = OneWire;
-    }
-  }
-  return result;
-}
-
-error_code DS9481P_300::disconnect() { return serialPort->disconnect(); }
-
-bool DS9481P_300::connected() const { return serialPort->connected(); }
-
-std::string DS9481P_300::portName() const { return serialPort->portName(); }
-
-error_code DS9481P_300::selectOneWire() {
-  // Escape DS9400 mode.
-  error_code result = ds9400.escape();
-  if (!result) {
-    result = ds2480b.initialize();
-  }
-  return result;
-}
-
-error_code DS9481P_300::selectBus(Bus newBus) {
-  error_code result;
-  if (currentBus != newBus) {
-    switch (currentBus) {
-    case OneWire: // Next bus I2C.
-      // Escape DS2480 Mode.
-      result = ds2480b.escape();
-      if (!result) {
-        // Wait for awake notification.
-        result = ds9400.waitAwake();
-      }
-      break;
-
-    case I2C: // Next bus OneWire.
-      result = selectOneWire();
-      break;
-    }
-    if (!result) {
-      currentBus = newBus;
+      serialPort->disconnect();
     }
   }
   return result;
 }
 
-error_code DS9481P_300::OneWireMaster::reset() {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::reset();
-  }
-  return result;
+Result<void> DS9481P_300::disconnect() { return serialPort->disconnect(); }
+
+Result<void> DS9481P_300::selectOneWire() {
+  // Escape DS9400 mode.
+  TRY(ds9400.escape());
+  TRY(ds2480b.initialize());
+  return none;
 }
 
-error_code DS9481P_300::OneWireMaster::touchBitSetLevel(bool & sendRecvBit,
-                                                        Level afterLevel) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::touchBitSetLevel(sendRecvBit, afterLevel);
+Result<void> DS9481P_300::selectBus(Bus newBus) {
+  if (currentBus != newBus) {
+    switch (currentBus) {
+    case OneWire: // Next bus I2C.
+      // Escape DS2480 Mode.
+      TRY(ds2480b.escape());
+      // Wait for awake notification.
+      TRY(ds9400.waitAwake());
+      break;
+
+    case I2C: // Next bus OneWire.
+      TRY(selectOneWire());
+      break;
+    }
+    currentBus = newBus;
   }
-  return result;
-}
-
-error_code DS9481P_300::OneWireMaster::writeByteSetLevel(uint_least8_t sendByte,
-                                                         Level afterLevel) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::writeByteSetLevel(sendByte, afterLevel);
-  }
-  return result;
+  return none;
 }
 
-error_code
-DS9481P_300::OneWireMaster::readByteSetLevel(uint_least8_t & recvByte,
-                                             Level afterLevel) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::readByteSetLevel(recvByte, afterLevel);
-  }
-  return result;
+Result<void> DS9481P_300::OneWireMaster::reset() {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::reset();
 }
 
-error_code
-DS9481P_300::OneWireMaster::writeBlock(span<const uint_least8_t> sendBuf) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::writeBlock(sendBuf);
-  }
-  return result;
+Result<bool> DS9481P_300::OneWireMaster::touchBitSetLevel(bool sendBit,
+                                                          Level afterLevel) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::touchBitSetLevel(sendBit, afterLevel);
 }
 
-error_code DS9481P_300::OneWireMaster::readBlock(span<uint_least8_t> recvBuf) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::readBlock(recvBuf);
-  }
-  return result;
+Result<void>
+DS9481P_300::OneWireMaster::writeByteSetLevel(uint_least8_t sendByte,
+                                              Level afterLevel) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::writeByteSetLevel(sendByte, afterLevel);
 }
 
-error_code DS9481P_300::OneWireMaster::setSpeed(Speed newSpeed) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::setSpeed(newSpeed);
-  }
-  return result;
+Result<uint_least8_t>
+DS9481P_300::OneWireMaster::readByteSetLevel(Level afterLevel) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::readByteSetLevel(afterLevel);
 }
 
-error_code DS9481P_300::OneWireMaster::setLevel(Level newLevel) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::setLevel(newLevel);
-  }
-  return result;
+Result<void>
+DS9481P_300::OneWireMaster::writeBlock(span<const uint_least8_t> sendBuf) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::writeBlock(sendBuf);
+}
+
+Result<void>
+DS9481P_300::OneWireMaster::readBlock(span<uint_least8_t> recvBuf) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::readBlock(recvBuf);
 }
 
-error_code DS9481P_300::OneWireMaster::triplet(TripletData & data) {
-  error_code result = parent->selectBus(OneWire);
-  if (!result) {
-    result = OneWireMasterDecorator::triplet(data);
-  }
-  return result;
+Result<void> DS9481P_300::OneWireMaster::setSpeed(Speed newSpeed) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::setSpeed(newSpeed);
 }
 
-error_code DS9481P_300::I2CMaster::start(uint_least8_t address) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::start(address);
-  }
-  return result;
+Result<void> DS9481P_300::OneWireMaster::setLevel(Level newLevel) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::setLevel(newLevel);
 }
 
-error_code DS9481P_300::I2CMaster::stop() {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::stop();
-  }
-  return result;
+Result<OneWireMaster::TripletData>
+DS9481P_300::OneWireMaster::triplet(bool sendBit) {
+  TRY(parent->selectBus(OneWire));
+  return OneWireMasterDecorator::triplet(sendBit);
 }
 
-error_code DS9481P_300::I2CMaster::writeByte(uint_least8_t data) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::writeByte(data);
-  }
-  return result;
+Result<void> DS9481P_300::I2CMaster::start(uint_least8_t address) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::start(address);
 }
 
-error_code DS9481P_300::I2CMaster::writeBlock(span<const uint_least8_t> data) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::writeBlock(data);
-  }
-  return result;
+Result<void> DS9481P_300::I2CMaster::stop() {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::stop();
+}
+
+Result<void> DS9481P_300::I2CMaster::writeByte(uint_least8_t data) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::writeByte(data);
 }
 
-error_code DS9481P_300::I2CMaster::doWritePacket(uint_least8_t address,
-                                                 span<const uint_least8_t> data,
-                                                 bool sendStop) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::doWritePacket(address, data, sendStop);
-  }
-  return result;
+Result<void>
+DS9481P_300::I2CMaster::writeBlock(span<const uint_least8_t> data) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::writeBlock(data);
 }
 
-error_code DS9481P_300::I2CMaster::readByte(AckStatus status,
-                                            uint_least8_t & data) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::readByte(status, data);
-  }
-  return result;
+Result<void> DS9481P_300::I2CMaster::writePacket(uint_least8_t address,
+                                                 span<const uint_least8_t> data,
+                                                 DoStop doStop) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::writePacket(address, data, doStop);
 }
 
-error_code DS9481P_300::I2CMaster::readBlock(AckStatus status,
-                                             span<uint_least8_t> data) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::readBlock(status, data);
-  }
-  return result;
+Result<uint_least8_t> DS9481P_300::I2CMaster::readByte(DoAck doAck) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::readByte(doAck);
 }
 
-error_code DS9481P_300::I2CMaster::doReadPacket(uint_least8_t address,
-                                                span<uint_least8_t> data,
-                                                bool sendStop) {
-  error_code result = parent->selectBus(I2C);
-  if (!result) {
-    result = I2CMasterDecorator::doReadPacket(address, data, sendStop);
-  }
-  return result;
+Result<void> DS9481P_300::I2CMaster::readBlock(span<uint_least8_t> data,
+                                               DoAck doAck) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::readBlock(data, doAck);
 }
 
-error_code DS9481P_300::DS2480BWithEscape::escape() {
+Result<void> DS9481P_300::I2CMaster::readPacket(uint_least8_t address,
+                                                span<uint_least8_t> data,
+                                                DoStop doStop) {
+  TRY(parent->selectBus(I2C));
+  return I2CMasterDecorator::readPacket(address, data, doStop);
+}
+
+Result<void> DS9481P_300::DS2480BWithEscape::escape() {
   return sendCommand(0xE5);
 }
 
-error_code DS9481P_300::DS9400WithEscape::escape() { return configure('O'); }
+Result<void> DS9481P_300::DS9400WithEscape::escape() { return configure('O'); }
 
 } // namespace MaximInterfaceDevices