BaosDevice.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2026 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
 
#ifndef __BAOSLIB_INTERFACE_H__
#define __BAOSLIB_INTERFACE_H__
 
#include "baos/config.h"
 
#include "baos/device/BaosDeviceDataTypes.h"
#include "baos/device/BaosDevicesMeta.h"
#include "baos/protocol/Defines.h"
 
#include "BlockReader.h"
 
#include "wzcpp/features/algorithm/append.h"
#include "wzcpp/features/utils/ByteArray.h"
#include "wzcpp/features/utils/Memory.h"
 
#include <memory>
#include <optional>
#include <utility>
 
namespace wz::baos
{
// Forward declaration
class BaosConnection;
using BaosConnection_UPtr = std::unique_ptr<BaosConnection>;  
 
 
/**********************************************
 * Helper functions
 **********************************************/
 
BAOSLIB_EXPORT std::uint16_t getAvailableBufferSize(const DeviceStaticInfo& staticInfo, const DeviceConfigInfo& configInfo);
 
BAOSLIB_EXPORT std::uint16_t getAvailablePayloadSize(const DeviceStaticInfo& staticInfo, const DeviceConfigInfo& configInfo);
 
/**************************************************
 * BaosDevice
 * ***********************************************/
 
class BAOSLIB_EXPORT BaosDevice
{
public:
    using ConnectionEventCb      = std::function<void(ConnectionEvent&)>;  
    using ServerItemIndicationCb = std::function<void(
        const protocol::ServerItems&)>;  
    using DatapointValueCb       = std::function<void(
        const protocol::DatapointValues&)>;  
 
    BaosDevice()          = default;
    virtual ~BaosDevice() = default;
 
    virtual void close(); 
    /************************ Information about the device ************************/
 
    DeviceStaticInfo getStaticInfo(bool reload = false);
 
 
    DeviceConfigInfo getConfigInfo(bool reload = false);
 
    DeviceRuntimeInfo getRuntimeInfo(bool reload = false);
 
    void setBoolServerItem(protocol::ServerItemId id, bool value);
 
 
    /************************ Parameter bytes ***************************************/
 
    protocol::ParameterBytes getParameterBytes(std::uint16_t byteIndex     = 1,
                                               std::uint16_t numberOfBytes = UINT16_MAX,
                                               bool reload                 = false);
 
    protocol::ParameterBytes getAllParameterBytes(bool reload = false);
 
    /**************************** Datapoints *****************************************/
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~ Datapoint configurations ~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    std::optional<DatapointConfig> getDpConfiguration(std::uint16_t dpId   = 1,
                                                      bool withDescStrings = true,
                                                      bool reload          = false);
 
    DatapointConfigurations getDpConfigurations(std::uint16_t startDpId = 1,
                                                std::uint16_t endDpId   = UINT16_MAX,
                                                bool withDescStrings    = true,
                                                bool reload             = false);
 
 
    DatapointConfigurations getAllDpConfigurations(bool reload = false);
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~ Datapoint values ~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    void setDpValue(std::uint16_t dpId,
                    Buffer dpData,
                    protocol::DatapointSetCommand command = protocol::DatapointSetCommand::SetNewValueAndSendOnBus);
 
    void setDpValues(std::map<std::uint16_t, Buffer>&& values,
                     protocol::DatapointSetCommand command = protocol::DatapointSetCommand::SetNewValueAndSendOnBus);
 
    void readDpValueFromBus(std::uint16_t dpId);
 
    void readDpValuesFromBus(std::vector<std::uint16_t>&& dpIds);
 
    void readDpValuesFromBus(const std::vector<std::uint16_t>& dpIds);
 
 
    std::optional<protocol::DatapointValue> getDpValueRaw(std::uint16_t dpId, bool reload = false);
 
    template<class T>
    std::optional<T> getDatapointValue(std::uint16_t dpId, bool reload = false)
    {
        auto value = getDpValueRaw(dpId);
        if (value.has_value())
        {
            return T(value);
        }
        else
        {
            return {};
        }
    }
 
    protocol::DatapointValues getDpValuesRaw(std::vector<std::uint16_t> dpIds, bool reload = false);
 
    protocol::DatapointValues getDpValuesRaw(
        std::uint16_t startDpId,
        std::uint16_t endDpId,
        bool reload                           = false,
        protocol::DatapointValueFilter filter = protocol::DatapointValueFilter::VALID);
 
    protocol::DatapointValues getAllDpValuesRaw(
        bool reload = false, protocol::DatapointValueFilter filter = protocol::DatapointValueFilter::VALID);
 
    /*************************************** Configuration of this class *****************************/
 
    ServerItemReadStrategy setServerItemReadStrategy(ServerItemReadStrategy strategy);
 
    bool enableCaching(bool state);
 
    bool isCachingEnabled() const
    {
        return config_.cacheEnabled;
    };
 
    void clearCaches();
 
    bool wasCacheHit()
    {
        return cacheHit_;
    }
 
    std::optional<DeviceMeta> getMetaInfo();
 
    void setMetaInfo(DeviceMeta&& meta);
 
 
    /*************************************** Callbacks on events *************************************/
 
    void registerServerItemCallback(ServerItemIndicationCb);
 
    void registerDPValueCallback(DatapointValueCb);
 
    void registerConnectionEventCallback(ConnectionEventCb callback);
 
 
    /************************************ Underlying BaosConnection *********************************/
 
    virtual BaosConnection_UPtr getConnection() = 0;
 
 
    void setInternalConnection(BaosConnection_UPtr& conn)
    {
        baosCon_ = std::move(conn);
    }
 
    BaosConnection& getInternalConnection()
    {
        if (!baosCon_)
        {
            throw WzSocketException(WZ_SL, "No internal connection available");
        }
        return *baosCon_;
    }
 
 
protected:
    void ensureConnection();
 
    void onServerItemsUpdate(const protocol::ServerItems& serverItems);
 
    void onDpValueUpdate(const protocol::DatapointValueStates& dpValueStates);
 
    void onConnectionEvent(ConnectionEvent event);
 
    void clearDeviceConfigs();
 
    protocol::ServerItems getAllServerItems();
 
    template<class TGetter>
    auto getElements(std::uint16_t start, std::uint16_t count, std::uint16_t maxLengthElement, TGetter cb)
    {
        if (config_.blockReadEnabled)
        {
            // Get current buffer size
            if (!deviceInfoLoaded_)
            {
                getConfigInfo();
            }
            assert(configInfo_.currentBufferSize > 16);
            // maxLengthElement: bytes per payload element
            std::uint16_t payloadAvailSize = getAvailablePayloadSize(getStaticInfo(), getConfigInfo()) /
                                             maxLengthElement;
            assert(payloadAvailSize > 0);
 
            std::uint16_t blockSize = payloadAvailSize;
            return utility::BlockReader::read(start, count, std::min(payloadAvailSize, blockSize), cb);
        }
        else
        {
            return cb(start, count);
        }
    }
 
 
protected:
    DeviceClassConfig config_{
        true, true, ServerItemReadStrategy::METADATAREADWITHFALLBACK};  
    std::optional<DeviceMeta> metaInfo_;                                
 
    bool cacheHit_{false};  
 
    // cached variables
    bool deviceInfoLoaded_{false};   
    DeviceStaticInfo staticInfo_;    
    DeviceConfigInfo configInfo_;    
    DeviceRuntimeInfo runtimeInfo_;  
 
    std::map<std::uint16_t, Buffer> dpCache_;  
    bool dpCacheFilled_{false};                
    protocol::ParameterBytes paramBytes_;      
 
    DatapointConfigurations dpConfig_;  
 
    std::vector<ServerItemIndicationCb> serverItemsCallbacks;  
    std::vector<DatapointValueCb> dpValueCallbacks;            
    std::vector<ConnectionEventCb> connectionEventCallbacks;    
 
    BaosConnection_UPtr baosCon_;  
 
};
 
}  // namespace wz::baos
 
#endif  // __BAOSLIB_INTERFACE_H__