bacnetutil.hpp

/*
 * 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.
 */
#pragma once

#include <string>
#include <map>
#include <vector>

#include "bacnetmstp.hpp"

namespace upm {

  class BACNETUTIL {
  public:

    BACNETUTIL(uint32_t targetDeviceObjectID);

    virtual ~BACNETUTIL();

    virtual void initMaster(std::string port, int baudRate,
                            int deviceInstanceNumber,
                            int macAddr, int maxMaster=DEFAULT_MAX_MASTER,
                            int maxInfoFrames=1);

    virtual void setDebug(bool enable);

    virtual float getAnalogValue(uint32_t objInstance);

    virtual void setAnalogValue(uint32_t objInstance,
                                float value);

    virtual float getAnalogInput(uint32_t objInstance);

    virtual std::string getAnalogValueUnits(uint32_t objInstance);

    virtual std::string getAnalogInputUnits(uint32_t objInstance);

    virtual bool getBinaryInput(uint32_t objInstance);

    virtual std::string lookupBinaryInputText(uint32_t objInstance, bool value);

    virtual std::string getBinaryInputText(uint32_t objInstance);

    virtual bool getBinaryValue(uint32_t objInstance);

    virtual void setBinaryValue(uint32_t objInstance,
                                bool value);

    virtual std::string lookupBinaryValueText(uint32_t objInstance, bool value);

    virtual std::string getBinaryValueText(uint32_t objInstance);

    virtual unsigned int getMultiStateValue(uint32_t objInstance);

    virtual std::string lookupMultiStateValueText(uint32_t objInstance,
                                                  unsigned int value);

    virtual std::string getMultiStateValueText(uint32_t objInstance);

    virtual unsigned int getMultiStateValueMaxStates(uint32_t objInstance);

    virtual void setMultiStateValue(uint32_t objInstance,
                                    unsigned int value);

    virtual void checkReliability(bool enable)
    {
      m_checkReliability = enable;
    };

    virtual std::string getDeviceDescription();

    virtual std::string getDeviceLocation();

    virtual bool setDeviceLocation(std::string location);

    virtual std::string getDeviceName();

    virtual bool setDeviceName(std::string name);

    virtual std::string getAllErrorString();

    virtual BACNETMSTP::BACERR_TYPE_T getErrorType();

    virtual uint8_t getRejectReason();

    virtual std::string getRejectString();

    virtual uint8_t getAbortReason();

    virtual std::string getAbortString();

    virtual BACNET_ERROR_CLASS getErrorClass();

    virtual BACNET_ERROR_CODE getErrorCode();

    virtual std::string getErrorString();

    virtual std::string getUPMErrorString();

  protected:
    // update our stored info for an MSV
    virtual void updateMultiStateValueInfo(uint32_t objInstance);
    // delete our stored info for an MSV
    virtual void deleteMultiStateValueInfo(uint32_t objInstance);

    // update our stored info for a BV
    virtual void updateBinaryValueInfo(uint32_t objInstance);
    // delete our stored info for a BV
    virtual void deleteBinaryValueInfo(uint32_t objInstance);

    // update our stored info for a BI
    virtual void updateBinaryInputInfo(uint32_t objInstance);
    // delete our stored info for a BI
    virtual void deleteBinaryInputInfo(uint32_t objInstance);

    // also enable mstp debugging in BACNETMSTP
    bool m_debugging;

    // whether or not to verify reliability before reading a value.
    bool m_checkReliability;

    // our target Device Object ID
    uint32_t m_targetDeviceObjectID;

    // a copy of the BACNETMSTP singleton instance pointer
    BACNETMSTP* m_instance;

    // are we initialized?
    bool m_initialized;

    // storage for Binary Input and Binary Value Data.  This will
    // generate SWIG warnings which can be ignored as we do not expose
    // this struct outside the class.
    typedef struct {
      std::string inactiveText;
      std::string activeText;
    } binaryData_t;

    typedef std::map<uint32_t, binaryData_t> binaryInfo_t;

    // storage for binary input/value information
    binaryInfo_t m_bvInfo;
    binaryInfo_t m_biInfo;

    // storage for multi-state data.  This will generate SWIG
    // warnings which can be ignored as we do not expose this struct
    // outside the class.
    typedef struct {
      unsigned int numStates;
      std::vector<std::string>stateList;
    } multiStateData_t;

    // our information storage for MSV's
    typedef std::map<uint32_t, multiStateData_t> multiStateInfo_t;

    multiStateInfo_t m_msvInfo;

    // Unit cache for AV
    typedef std::map<uint32_t, std::string> avCacheMap_t;
    avCacheMap_t m_avUnitCache;

    // Unit cache for AI
    typedef std::map<uint32_t, std::string> aiCacheMap_t;
    aiCacheMap_t m_aiUnitCache;

  private:
  };
}