libupm: sync with upstream (SHA1: 1849e22)

am: 4de2569d39

Change-Id: I1324e4eed5908383f5942bb23a43890dc8554dec

1 files changed, 925 insertions, 0 deletions

diff --git a/peripheral/libupm/src/bacnetmstp/bacnetutil.cxx b/peripheral/libupm/src/bacnetmstp/bacnetutil.cxx
new file mode 100644
index 0000000..17d555a
--- /dev/null
+++ b/peripheral/libupm/src/bacnetmstp/bacnetutil.cxx
@@ -0,0 +1,925 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+#include "bacnetutil.hpp"
+
+using namespace upm;
+using namespace std;
+
+
+BACNETUTIL::BACNETUTIL(uint32_t targetDeviceObjectID) :
+  m_instance(0)
+{
+  // Save our device's ID
+  m_targetDeviceObjectID = targetDeviceObjectID;
+
+  // create the BACNETMSTP instance here if it does not already exist,
+  // and store the pointer in our class to save on some typing.
+
+  m_instance = BACNETMSTP::instance();
+
+  // now see if it has been initialized yet for init()
+  m_initialized = m_instance->isInitialized();
+
+  setDebug(false);
+
+  // we disable this by default for performance reasons
+  checkReliability(false);
+
+  // empty our unit caches
+  m_avUnitCache.clear();
+  m_aiUnitCache.clear();
+
+  // empty our msv info store
+  m_msvInfo.clear();
+
+  // empty our binary info stores
+  m_bvInfo.clear();
+  m_biInfo.clear();
+}
+
+BACNETUTIL::~BACNETUTIL()
+{
+}
+
+void BACNETUTIL::initMaster(std::string port, int baudRate,
+                            int deviceInstanceID, int macAddr, int maxMaster,
+                            int maxInfoFrames)
+{
+  // first we check to see if the bacnetmstp instance has already been
+  // initialized (determined in the ctor).  If not, we will do so here
+  // with the arguments specified.  If it has already been
+  // initialized, then we do not bother calling bacnetmstp's init
+  // again as it will just be ignored.
+
+  if (!m_initialized)
+    m_instance->initMaster(port, baudRate, deviceInstanceID,
+                           macAddr, maxMaster, maxInfoFrames);
+
+  // either it threw an exception, was already initialized or it's
+  // initialized now...
+  m_initialized = true;
+}
+
+void BACNETUTIL::setDebug(bool enable)
+{
+  m_debugging = enable;
+
+  // we also enable/disable debugging in BACNETMSTP
+  m_instance->setDebug(enable);
+}
+
+float BACNETUTIL::getAnalogValue(uint32_t objInstance)
+{
+  // check reliability first, if enabled
+  if (m_checkReliability)
+    {
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_VALUE,
+                                   objInstance, PROP_RELIABILITY))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": (reliability): " << getAllErrorString()
+                 << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + getAllErrorString());
+        }
+
+      BACNET_RELIABILITY reliable =
+        static_cast<BACNET_RELIABILITY>(m_instance->getDataTypeEnum());
+
+      if (reliable != RELIABILITY_NO_FAULT_DETECTED)
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": Reliability check failed" << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + ": Reliability check failed");
+        }
+    }
+
+  // now get the value
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_VALUE,
+                               objInstance, PROP_PRESENT_VALUE))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": (value): " << getAllErrorString()
+             << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  return m_instance->getDataTypeReal();
+}
+
+void BACNETUTIL::setAnalogValue(uint32_t objInstance,
+                                float value)
+{
+  // Write the value
+  BACNET_APPLICATION_DATA_VALUE myData =
+    m_instance->createDataReal(value);
+
+  // write it
+  if (m_instance->writeProperty(m_targetDeviceObjectID, OBJECT_ANALOG_VALUE,
+                                objInstance, PROP_PRESENT_VALUE,
+                                &myData))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+}
+
+string BACNETUTIL::getAnalogValueUnits(uint32_t objInstance)
+{
+  // see if it exists
+  if (m_avUnitCache.count(objInstance) == 0)
+    {
+      // then we need to fetch it
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_VALUE,
+                                   objInstance, PROP_UNITS))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+          // set to empty string
+          m_avUnitCache[objInstance] = string("");
+        }
+      else
+        {
+          // cache it for future calls
+          m_avUnitCache[objInstance] =
+            string(bactext_engineering_unit_name(m_instance->getDataTypeEnum()));
+        }
+    }
+
+  return m_avUnitCache[objInstance];
+}
+
+float BACNETUTIL::getAnalogInput(uint32_t objInstance)
+{
+  // check reliability first, if enabled
+  if (m_checkReliability)
+    {
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_INPUT,
+                                   objInstance, PROP_RELIABILITY))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": (reliability): "
+                 << getAllErrorString() << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + getAllErrorString());
+        }
+
+      BACNET_RELIABILITY reliable =
+        static_cast<BACNET_RELIABILITY>(m_instance->getDataTypeEnum());
+
+      if (reliable != RELIABILITY_NO_FAULT_DETECTED)
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": Reliability check failed" << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + ": Reliability check failed");
+        }
+    }
+
+  // now get the value
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_INPUT,
+                               objInstance, PROP_PRESENT_VALUE))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": (value): " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  return m_instance->getDataTypeReal();
+}
+
+bool BACNETUTIL::getBinaryInput(uint32_t objInstance)
+{
+  // check the BV info, and update/cache the data if needed
+  updateBinaryInputInfo(objInstance);
+
+  // check reliability first, if enabled
+  if (m_checkReliability)
+    {
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_BINARY_INPUT,
+                                   objInstance, PROP_RELIABILITY))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": (reliability): "
+                 << getAllErrorString() << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + getAllErrorString());
+        }
+
+      BACNET_RELIABILITY reliable =
+        static_cast<BACNET_RELIABILITY>(m_instance->getDataTypeEnum());
+
+      if (reliable != RELIABILITY_NO_FAULT_DETECTED)
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": Reliability check failed" << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + ": Reliability check failed");
+        }
+    }
+
+  // now get the value
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_BINARY_INPUT,
+                               objInstance, PROP_PRESENT_VALUE))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": (value): " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  BACNET_BINARY_PV bpv =
+    static_cast<BACNET_BINARY_PV>(m_instance->getDataTypeEnum());
+
+  return (bpv == BINARY_INACTIVE) ? false : true;
+}
+
+bool BACNETUTIL::getBinaryValue(uint32_t objInstance)
+{
+  // check the BV info, and update/cache the data if needed
+  updateBinaryValueInfo(objInstance);
+
+  // check reliability first, if enabled
+  if (m_checkReliability)
+    {
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_BINARY_VALUE,
+                                   objInstance, PROP_RELIABILITY))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": (reliability): "
+                 << getAllErrorString() << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + getAllErrorString());
+        }
+
+      BACNET_RELIABILITY reliable =
+        static_cast<BACNET_RELIABILITY>(m_instance->getDataTypeEnum());
+
+      if (reliable != RELIABILITY_NO_FAULT_DETECTED)
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": Reliability check failed" << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + ": Reliability check failed");
+        }
+    }
+
+  // now get the value
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_BINARY_VALUE,
+                               objInstance, PROP_PRESENT_VALUE))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": (value): " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  BACNET_BINARY_PV bpv =
+    static_cast<BACNET_BINARY_PV>(m_instance->getDataTypeEnum());
+
+  return (bpv == BINARY_INACTIVE) ? false : true;
+}
+
+void BACNETUTIL::setBinaryValue(uint32_t objInstance,
+                                bool value)
+{
+  BACNET_BINARY_PV bpv = (value) ? BINARY_ACTIVE : BINARY_INACTIVE;
+
+  // Write the value
+  BACNET_APPLICATION_DATA_VALUE myData =
+    m_instance->createDataEnum(bpv);
+
+  // write it
+  if (m_instance->writeProperty(m_targetDeviceObjectID, OBJECT_BINARY_VALUE,
+                                objInstance, PROP_PRESENT_VALUE,
+                                &myData))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+}
+
+string BACNETUTIL::getAnalogInputUnits(uint32_t objInstance)
+{
+  // see if it exists
+  if (m_aiUnitCache.count(objInstance) == 0)
+    {
+      // then we need to fetch it
+      if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_ANALOG_INPUT,
+                                   objInstance, PROP_UNITS))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+          // set to empty string
+          m_aiUnitCache[objInstance] = string("");
+        }
+      else
+        {
+          // cache it for future calls
+          m_aiUnitCache[objInstance] =
+            string(bactext_engineering_unit_name(m_instance->getDataTypeEnum()));
+        }
+    }
+
+  return m_aiUnitCache[objInstance];
+}
+
+unsigned int BACNETUTIL::getMultiStateValue(uint32_t objInstance)
+{
+  // check the MSV info, and update/cache the data if needed
+  updateMultiStateValueInfo(objInstance);
+
+  // check reliability first, if enabled
+  if (m_checkReliability)
+    {
+      if (m_instance->readProperty(m_targetDeviceObjectID,
+                                   OBJECT_MULTI_STATE_VALUE,
+                                   objInstance, PROP_RELIABILITY))
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": (reliability): "
+                 << getAllErrorString() << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + getAllErrorString());
+        }
+
+      BACNET_RELIABILITY reliable =
+        static_cast<BACNET_RELIABILITY>(m_instance->getDataTypeEnum());
+
+      if (reliable != RELIABILITY_NO_FAULT_DETECTED)
+        {
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": Reliability check failed" << endl;
+
+          throw std::runtime_error(std::string(__FUNCTION__)
+                                   + ": Reliability check failed");
+        }
+    }
+
+  // now get the value
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_MULTI_STATE_VALUE,
+                               objInstance, PROP_PRESENT_VALUE))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": (value): " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  return m_instance->getDataTypeUnsignedInt();
+}
+
+void BACNETUTIL::updateMultiStateValueInfo(uint32_t objInstance)
+{
+  // bail if we already have information on this msv
+  if (m_msvInfo.count(objInstance) != 0)
+    return;
+
+  // we need to fetch information on MSV's - number of states, and
+  // possibly the state-text, if present
+
+  // get the number of values possible (required)
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_MULTI_STATE_VALUE,
+                               objInstance, PROP_NUMBER_OF_STATES))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (number of states): "
+             << getAllErrorString()
+             << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+
+  // Add the entry...
+  m_msvInfo[objInstance].numStates = m_instance->getDataTypeUnsignedInt();
+
+  if (m_debugging)
+    cerr << __FUNCTION__
+         << ": number of states: "
+         << m_msvInfo[objInstance].numStates
+         << endl;
+
+  // now get the state-text.  This is optional, so we will not throw
+  // here.
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_MULTI_STATE_VALUE,
+                               objInstance, PROP_STATE_TEXT))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (state-text): "
+             << getAllErrorString()
+             << endl;
+    }
+
+  // store them
+  int numElements = m_instance->getDataNumElements();
+
+  if (m_debugging)
+    cerr << __FUNCTION__ << ": numElements: " << numElements << endl;
+
+  if (numElements > 0)
+    {
+      for (int i=0; i<numElements; i++)
+        {
+          m_msvInfo[objInstance].stateList.push_back(m_instance->getDataTypeString(i));
+
+          if (m_debugging)
+            cerr << __FUNCTION__ << ": " << int(objInstance) << ", "
+                 << i << ": "
+                 << "added state text string: "
+                 << m_msvInfo[objInstance].stateList.at(i)
+                 << endl;
+        }
+    }
+
+  return;
+}
+
+void BACNETUTIL::deleteMultiStateValueInfo(uint32_t objInstance)
+{
+  // if there is no data stored for this objInstance yet, then we do
+  // not need to do anything.
+  if (m_msvInfo.count(objInstance) == 0)
+    return;
+
+  // Now, we just erase the entry, and it will be updated the next
+  // time the MSV is accessed.
+  m_msvInfo.erase(objInstance);
+
+  return;
+}
+
+string BACNETUTIL::lookupMultiStateValueText(uint32_t objInstance,
+                                             unsigned int value)
+{
+  // verify that we have the relevant object data cached. If not, go
+  // get it.
+  updateMultiStateValueInfo(objInstance);
+
+  // verify that value is valid for this object
+  if (value == 0 || value > m_msvInfo[objInstance].numStates)
+    throw std::out_of_range(std::string(__FUNCTION__)
+                            + ": value supplied is invalid. Maximum "
+                            + "allowed values are 1 to "
+                            + std::to_string(m_msvInfo[objInstance].numStates)
+                            + " for this object");
+
+
+  // at this point either it failed or suceeded.  If it suceeded, then
+  // we will see if any state text was retrieved.  If no text is
+  // available (it is an optional property), then we will simply
+  // return the value itself as a string.
+
+  if (m_msvInfo[objInstance].stateList.size() > 0)
+    {
+      // we have state-text and a usable value.
+
+      // value should never be 0 at this point, so compensate for
+      // indexing into stateList which is 0-based.
+      value--;
+
+      return m_msvInfo[objInstance].stateList.at(value);
+    }
+
+  // no stateList text available, so just return value as a string
+  return std::to_string(value);
+}
+
+unsigned int BACNETUTIL::getMultiStateValueMaxStates(uint32_t objInstance)
+{
+  // check the MSV info, and update/cache the data if needed
+  updateMultiStateValueInfo(objInstance);
+
+  return m_msvInfo[objInstance].numStates;
+}
+
+string BACNETUTIL::getMultiStateValueText(uint32_t objInstance)
+{
+  unsigned int value = getMultiStateValue(objInstance);
+
+  return lookupMultiStateValueText(objInstance, value);
+}
+
+void BACNETUTIL::setMultiStateValue(uint32_t objInstance,
+                                    unsigned int value)
+{
+  // check the MSV info, and update/cache the data if needed
+  updateMultiStateValueInfo(objInstance);
+
+  // Check value against the valid limits
+
+  if (value == 0 || value > m_msvInfo[objInstance].numStates)
+    throw std::invalid_argument(std::string(__FUNCTION__)
+                                + ": value supplied is invalid. Maximum "
+                                + "allowed values are 1 to "
+                                + std::to_string(m_msvInfo[objInstance].numStates)
+                                + " for this object");
+
+  // Write the value
+  BACNET_APPLICATION_DATA_VALUE myData =
+    m_instance->createDataUnsignedInt(value);
+
+  // write it
+  if (m_instance->writeProperty(m_targetDeviceObjectID,
+                                OBJECT_MULTI_STATE_VALUE,
+                                objInstance, PROP_PRESENT_VALUE,
+                                &myData))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      throw std::runtime_error(std::string(__FUNCTION__)
+                               + ": "
+                               + getAllErrorString());
+    }
+}
+
+void BACNETUTIL::updateBinaryValueInfo(uint32_t objInstance)
+{
+  // bail if we already have information on this object
+  if (m_bvInfo.count(objInstance) != 0)
+    return;
+
+  // fetch inactive/active text.  These are optional accordingto the
+  // spec, so we will not throw if they do not exist.
+
+  // get inactive text
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_BINARY_VALUE,
+                               objInstance, PROP_INACTIVE_TEXT))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (inactive text): "
+             << getAllErrorString()
+             << endl;
+
+      m_bvInfo[objInstance].inactiveText = "inactive";
+    }
+  else
+    {
+      m_bvInfo[objInstance].inactiveText = m_instance->getDataTypeString();
+    }
+
+  // get active text
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_BINARY_VALUE,
+                               objInstance, PROP_ACTIVE_TEXT))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (active text): "
+             << getAllErrorString()
+             << endl;
+
+      m_bvInfo[objInstance].activeText = "active";
+    }
+  else
+    {
+      m_bvInfo[objInstance].activeText = m_instance->getDataTypeString();
+    }
+
+  return;
+}
+
+void BACNETUTIL::deleteBinaryValueInfo(uint32_t objInstance)
+{
+  // if there is no data stored for this objInstance yet, then we do
+  // not need to do anything.
+  if (m_bvInfo.count(objInstance) == 0)
+    return;
+
+  // Now, we just erase the entry, and it will be updated the next
+  // time it is accessed.
+  m_bvInfo.erase(objInstance);
+
+  return;
+}
+
+void BACNETUTIL::updateBinaryInputInfo(uint32_t objInstance)
+{
+  // bail if we already have information on this object
+  if (m_biInfo.count(objInstance) != 0)
+    return;
+
+  // fetch inactive/active text.  These are optional accordingto the
+  // spec, so we will not throw if they do not exist.
+
+  // get inactive text
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_BINARY_INPUT,
+                               objInstance, PROP_INACTIVE_TEXT))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (inactive text): "
+             << getAllErrorString()
+             << endl;
+
+      m_biInfo[objInstance].inactiveText = "inactive";
+    }
+  else
+    {
+      m_biInfo[objInstance].inactiveText = m_instance->getDataTypeString();
+    }
+
+  // get active text
+  if (m_instance->readProperty(m_targetDeviceObjectID,
+                               OBJECT_BINARY_INPUT,
+                               objInstance, PROP_ACTIVE_TEXT))
+    {
+      if (m_debugging)
+        cerr << __FUNCTION__
+             << ": (active text): "
+             << getAllErrorString()
+             << endl;
+
+      m_biInfo[objInstance].activeText = "active";
+    }
+  else
+    {
+      m_biInfo[objInstance].activeText = m_instance->getDataTypeString();
+    }
+
+  return;
+}
+
+void BACNETUTIL::deleteBinaryInputInfo(uint32_t objInstance)
+{
+  // if there is no data stored for this objInstance yet, then we do
+  // not need to do anything.
+  if (m_biInfo.count(objInstance) == 0)
+    return;
+
+  // Now, we just erase the entry, and it will be updated the next
+  // time it is accessed.
+  m_biInfo.erase(objInstance);
+
+  return;
+}
+
+string BACNETUTIL::lookupBinaryInputText(uint32_t objInstance, bool value)
+{
+  // cache relevant data if necessary
+  updateBinaryInputInfo(objInstance);
+
+ if (value)
+    return m_biInfo[objInstance].activeText;
+  else
+    return m_biInfo[objInstance].inactiveText;
+}
+
+string BACNETUTIL::getBinaryInputText(uint32_t objInstance)
+{
+  bool value = getBinaryInput(objInstance);
+
+  return lookupBinaryInputText(objInstance, value);
+}
+
+string BACNETUTIL::lookupBinaryValueText(uint32_t objInstance, bool value)
+{
+  // cache relevant data if necessary
+  updateBinaryValueInfo(objInstance);
+
+ if (value)
+    return m_bvInfo[objInstance].activeText;
+  else
+    return m_bvInfo[objInstance].inactiveText;
+}
+
+string BACNETUTIL::getBinaryValueText(uint32_t objInstance)
+{
+  bool value = getBinaryValue(objInstance);
+
+  return lookupBinaryValueText(objInstance, value);
+}
+
+BACNETMSTP::BACERR_TYPE_T BACNETUTIL::getErrorType()
+{
+  return m_instance->getErrorType();
+}
+
+uint8_t BACNETUTIL::getRejectReason()
+{
+  return m_instance->getRejectReason();
+}
+
+std::string BACNETUTIL::getRejectString()
+{
+  return m_instance->getRejectString();
+}
+
+uint8_t BACNETUTIL::getAbortReason()
+{
+  return m_instance->getAbortReason();
+}
+
+std::string BACNETUTIL::getAbortString()
+{
+  return m_instance->getAbortString();
+}
+
+BACNET_ERROR_CLASS BACNETUTIL::getErrorClass()
+{
+  return m_instance->getErrorClass();
+}
+
+BACNET_ERROR_CODE BACNETUTIL::getErrorCode()
+{
+  return m_instance->getErrorCode();
+}
+
+std::string BACNETUTIL::getUPMErrorString()
+{
+  return m_instance->getUPMErrorString();
+}
+
+std::string BACNETUTIL::getErrorString()
+{
+  return m_instance->getErrorString();
+};
+
+string BACNETUTIL::getAllErrorString()
+{
+  switch (m_instance->getErrorType())
+    {
+    case BACNETMSTP::BACERR_TYPE_NONE:
+      return string("No Error");
+      break;
+
+    case BACNETMSTP::BACERR_TYPE_REJECT:
+      return string("Reject: ") + getRejectString();
+      break;
+
+    case BACNETMSTP::BACERR_TYPE_ABORT:
+      return string("Abort: ") + getAbortString();
+      break;
+
+    case BACNETMSTP::BACERR_TYPE_ERROR:
+      return string("Error: ") + getErrorString();
+      break;
+
+    case BACNETMSTP::BACERR_TYPE_UPM:
+      return string("UPM Error: ") + getUPMErrorString();
+      break;
+    }
+}
+
+string BACNETUTIL::getDeviceDescription()
+{
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_DEVICE,
+                               m_targetDeviceObjectID, PROP_DESCRIPTION))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      return "";
+    }
+
+  return m_instance->getDataTypeString();
+}
+
+string BACNETUTIL::getDeviceLocation()
+{
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_DEVICE,
+                               m_targetDeviceObjectID, PROP_LOCATION))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      return "";
+    }
+
+  return m_instance->getDataTypeString();
+}
+
+bool BACNETUTIL::setDeviceLocation(string location)
+{
+  BACNET_APPLICATION_DATA_VALUE myLocation =
+    m_instance->createDataString(location);
+
+  // write the Device Object Location
+  if (m_instance->writeProperty(m_targetDeviceObjectID, OBJECT_DEVICE,
+                                m_targetDeviceObjectID, PROP_LOCATION,
+                                &myLocation))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      return false;
+    }
+
+  return true;
+}
+
+string BACNETUTIL::getDeviceName()
+{
+  if (m_instance->readProperty(m_targetDeviceObjectID, OBJECT_DEVICE,
+                               m_targetDeviceObjectID, PROP_OBJECT_NAME))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      return "";
+    }
+
+  return m_instance->getDataTypeString();
+}
+
+bool BACNETUTIL::setDeviceName(string name)
+{
+  if (name.size() < 1)
+    {
+      throw std::invalid_argument(std::string(__FUNCTION__)
+                                  + ": name must have at least one character");
+    }
+
+  BACNET_APPLICATION_DATA_VALUE myName =
+    m_instance->createDataString(name);
+
+  // write the Device Object Location
+  if (m_instance->writeProperty(m_targetDeviceObjectID, OBJECT_DEVICE,
+                                m_targetDeviceObjectID, PROP_OBJECT_NAME,
+                                &myName))
+    {
+      // error occurred
+      if (m_debugging)
+        cerr << __FUNCTION__ << ": " << getAllErrorString() << endl;
+
+      return false;
+    }
+
+  return true;
+}