StationLogics.hpp

Go to the documentation of this file.

#ifndef IV_SRC_LOGIC_STATIONLOGICS_HPP_
#define IV_SRC_LOGIC_STATIONLOGICS_HPP_
 
#include "channels/AbstractChannel.hpp"
#include "core/defines.hpp"
#include "logic/defines.hpp"
#include "logic/structs.hpp"
 
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace iv::logic
{
 
namespace station
{
struct StationBlockParam
{
    iv::logic::eDBBlockParamType m_type {iv::logic::eDBBlockParamType::Without};// Tipo del param
 
    // Puede ser la MI o el valor del parametro
    uint32_t m_globalIdOrValueParameter {0};
    std::uint16_t m_channelUnitId {0};
    std::uint16_t m_channelId {0};
 
    // IO parameters
    std::optional<std::weak_ptr<iv::channels::AbstractChannel>> m_connectedChannel;
    std::optional<uint32_t> m_connectedBlockId;
 
    // IN parameters
    // If param is input, it might be connected to another block param
    std::optional<std::weak_ptr<StationBlockParam>> m_inputConnectedBlockParam;
 
    // OUT parameters
    std::atomic<std::optional<iv::types::channelValue>> m_outputValue {std::nullopt};
 
    // Other parameters
    std::optional<uint32_t> m_value;
};
 
struct StationBlock
{
    uint16_t m_orderOfExecution {};
    std::string m_name {};
    uint8_t m_type {};
    uint8_t m_subType {};
 
    std::vector<std::shared_ptr<StationBlockParam>> m_params {};
};
 
struct StationLogicBlocks
{
    iv::logic::InfoLogicTxt m_infoLogic;
    std::vector<std::shared_ptr<StationBlock>> m_stationBlocks;
};
 
}// namespace station
 
class StationLogics
{
public:
    explicit StationLogics(iv::types::unitId unitId);
    ~StationLogics();
    bool readStationLomFile(const std::string &file);
    void clear() const;
    void update(const iv::logic::StationLogics &other);
 
    [[nodiscard]] bool hasLogic() const;
    [[nodiscard]] iv::types::unitId getUnitID() const;
 
    void processLogic() const;
    std::shared_ptr<iv::logic::station::StationLogicBlocks> getStationLogicBlocks();
 
private:
    [[nodiscard]] bool processLoadedStationLogicBlocks() const;
    static void processLoadedStationLogicBlockIOParameter(
            const std::shared_ptr<iv::logic::station::StationBlockParam> &blockParameter);
    [[nodiscard]] std::optional<std::weak_ptr<iv::logic::station::StationBlockParam>>
    findOutputParameterWithGlobalId(uint32_t globalId) const;
 
    iv::types::unitId m_unitID;
    std::shared_ptr<iv::logic::station::StationLogicBlocks> m_stationLogics;
 
    static void prvProcessFollower(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAdd(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessSub(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessDiv(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessMult(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnd(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessOr(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessCompare(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessNot(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessMean(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessIfElse(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAbs(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnalogConstant(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnalogRoot(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnalogAlmType(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnalogAlmType2Limits(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static void prvProcessAnalogAlmState(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
 
    static std::vector<std::shared_ptr<iv::logic::station::StationBlockParam>>
    prvGetInputsParams(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static std::vector<std::shared_ptr<iv::logic::station::StationBlockParam>>
    prvGetOutputsParams(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock);
    static std::vector<std::shared_ptr<iv::logic::station::StationBlockParam>>
    prvGetParamsOfType(const std::shared_ptr<iv::logic::station::StationBlock> &pBlock,
                       iv::logic::eDBBlockParamType paramType);
 
    static std::optional<iv::types::channelValue>
    prvGetInputValue(const std::shared_ptr<iv::logic::station::StationBlockParam> &inputParam);
    static void prvSetOutputValue(const std::shared_ptr<iv::logic::station::StationBlockParam> &outputParam,
                                  iv::types::channelValue);
    static void prvInvalidateOutputValue(const std::shared_ptr<iv::logic::station::StationBlockParam> &outputParam);
};
 
}// namespace iv::logic
 
#endif