Fan.hpp

Go to the documentation of this file.

#ifndef IV_SRC_MIMICS_CONTROLS_FAN_HPP_
#define IV_SRC_MIMICS_CONTROLS_FAN_HPP_
 
#include "mimics/model/AbstractMimicElement.hpp"
#include "mimics/model/Channel.hpp"
#include "model/support/Maintenance.hpp"
#include "model/traits/AutomaticSemiAuto.hpp"
#include "model/traits/ControlLock.hpp"
#include "model/traits/RemoteLocal.hpp"
#include "model/traits/TripReset.hpp"
#include "ui/shapes/CRectangleGraphics.hpp"
 
namespace iv::mimics::elements
{
 
class Fan final : public iv::mimics::AbstractMimicElement,
                  iv::mimics::traits::AutomaticSemiAuto,
                  iv::mimics::traits::ControlLock,
                  iv::mimics::traits::RemoteLocal,
                  iv::mimics::traits::TripReset
 
{
public:
    Fan();
    explicit Fan(iv::mimics::eMimicElementType type);
    Fan(const Fan &other);
    ~Fan() override = default;
 
    bool load(const iv::file::xml::node &nodeControlMimic) override;
    bool save(iv::file::xml::node &nodeControlMimic) const override;
 
    // Controller
    void getChannels(const std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
                             &channelsInControl) const override;
    void mapChannels(const std::function<void(std::weak_ptr<iv::channels::AbstractChannel> &)> &mapFunction) override;
    void executeCommand(const std::string &strAction) const override;
    [[nodiscard]] std::shared_ptr<iv::mimics::AbstractMimicElement> clone() const override;
 
    [[nodiscard]] std::optional<iv::types::color> getColorWorkingState() const override;
    [[nodiscard]] std::optional<iv::types::color> getColorControlState() const override;
    [[nodiscard]] std::optional<std::string> getStringWorkingState() const override;
    [[nodiscard]] std::optional<std::string> getStringControlState() const override;
    [[nodiscard]] std::optional<iv::mimics::eAlarmState> getAlarmState() const override;
 
    // Draw
    void drawSpecific(IGraphics *graphics, std::optional<iv::types::color> colorWorkingState,
                      std::optional<iv::types::color> colorControlState, iv::eLanguage drawingLanguage) override;
 
    // UI
    AbstractComponentGUI *panelEditControl() override;
    void addOptionsMenu(const std::shared_ptr<iv::mimics::MimicControlMenu> &menu) override;
 
    enum class eAuxiliaryFanRunState
    {
        NoLinked,
        Stop,
        NoStop,
        NoRun,
        StopRunUndefined0,
        Undefined,
        Run,
        RunFast
    };
 
    enum class eAuxiliaryFanDirection
    {
        NoLinked,
        SupplyExhaustUndefined0,
        Undefined,
        Supply,
        NoSupply,
        Exhaust,
        NoExhaust
    };
 
private:
    struct FanElementsColors
    {
        iv::types::color leftArrowColor {iv::color::DiamarBlackBackground};
        iv::types::color leftFastArrowColor {iv::color::DiamarBlackBackground};
        iv::types::color rightArrowColor {iv::color::DiamarBlackBackground};
        iv::types::color rightFastArrowColor {iv::color::DiamarBlackBackground};
    };
 
    // Draw
    void drawSimpleFan(IGraphics *graphics, const std::optional<iv::types::color> &colorWorkingState) const;
    void drawSimpleWithFastFan(IGraphics *graphics, const std::optional<iv::types::color> &colorWorkingState,
                               const std::optional<iv::types::color> &colorControlState, eFanRunState stateRun) const;
    void drawReverseFan(IGraphics *graphics, const std::optional<iv::types::color> &colorWorkingState,
                        eFanRunState stateRun, eFanDirection stateDirection) const;
    void drawReverseWithFastFan(IGraphics *graphics, const std::optional<iv::types::color> &colorWorkingState,
                                const std::optional<iv::types::color> &colorControlState, eFanRunState runState,
                                eFanDirection directionState) const;
    void drawBladedFan(IGraphics *graphics, const std::optional<iv::types::color> &colorWorkingState,
                       const std::optional<iv::types::color> &colorControlState, eFanRunState stateRun,
                       eFanDirection stateDirection) const;
    static Fan::FanElementsColors calculateArrowElementsColors(iv::types::color colorWorkingState,
                                                               eFanRunState runState, eFanDirection directionState);
 
    // Running and Direction Behavior
    static void runningStateBehaviorModel(const std::shared_ptr<iv::channels::AbstractChannel> &runFeedback,
                                          eAuxiliaryFanRunState &lastState, bool isFast);
    [[nodiscard]] eFanRunState calculateFanRunState() const;
 
    static void supplyDirectionBehaviorModel(const std::shared_ptr<iv::channels::AbstractChannel> &runFeedbackSupply,
                                             Fan::eAuxiliaryFanDirection &lastState);
    static void exhaustDirectionBehaviorModel(const std::shared_ptr<iv::channels::AbstractChannel> &runFeedbackExhaust,
                                              Fan::eAuxiliaryFanDirection &lastState);
    [[nodiscard]] eFanDirection calculateFanDirection() const;
 
    //general
    iv::mimics::elements::eFanDesign m_fanDesign;
    iv::mimics::elements::eFanType m_fanType;
    iv::mimics::support::Maintenance m_maintenance;
 
    //misc
    iv::mimics::Channel m_speedFeedback;
    iv::mimics::Channel m_consignedSpeed;
    iv::mimics::Channel m_userConsignedSpeed;
 
    //feedback
    iv::mimics::Channel m_runFeedbackSupply;
    iv::mimics::Channel m_runFeedbackSupplyFast;
    iv::mimics::Channel m_runFeedbackExhaust;
    iv::mimics::Channel m_runFeedbackExhaustFast;
    iv::mimics::Channel m_stoppedFeedback;//el hasStoppedFeedback??
 
    //order
    iv::mimics::Channel m_startOrderSupply;
    iv::mimics::Channel m_startOrderSupplyFast;
    iv::mimics::Channel m_startOrderExhaust;
    iv::mimics::Channel m_startOrderExhaustFast;
    iv::mimics::Channel m_stopOrder;
 
    //command
    iv::mimics::Channel m_startCommandSupply;
    iv::mimics::Channel m_startCommandSupplyFast;
    iv::mimics::Channel m_startCommandExhaust;
    iv::mimics::Channel m_startCommandExhaustFast;
    iv::mimics::Channel m_stopCommand;
 
    // View
    std::unique_ptr<CRectangleGraphics> m_rectangleOpt {nullptr};
    static constexpr double kPrvRelationXY {0.7};
 
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::mimics::elements::eFanType fanMode {eFanType::Simple};
        static constexpr iv::mimics::elements::eFanDesign fanDesign {eFanDesign::Normal};
 
        struct Colors
        {
            static constexpr iv::types::color background {iv::color::White};
            static constexpr iv::types::color arrow {iv::color::DiamarBlackBackground};
 
            static constexpr iv::types::color workingStateStopped {iv::color::SedniElementNotWorkingBlack};
            static constexpr iv::types::color workingStateRunning {iv::color::SedniElementWorkingGreen};
            static constexpr iv::types::color workingStateUndefined {iv::color::SedniElementUndefined};
            static constexpr iv::types::color workingStateOffline {iv::color::SedniElementOfflineBlack};
 
            static constexpr iv::types::color controlStateLocal {iv::color::SedniLocal};
            static constexpr iv::types::color controlStateRemoteSemiAuto {iv::color::SedniSemiAuto};
            static constexpr iv::types::color controlStateRemoteAuto {iv::color::SedniAuto};
            static constexpr iv::types::color controlStateOffline {iv::color::SedniElementOfflineGrey};
        };
    };
    struct Keys
    {
        static constexpr std::string_view fanMode {"FanMode"};
        static constexpr std::string_view fanDesign {"FanDesign"};
    };
    struct Sections
    {
        //        static constexpr std::string_view hasStopConfirmation {"HasStopConfirmation"};
 
        static constexpr std::string_view fan {"Fan"};
        static constexpr std::string_view maintenance {"Maintenance"};
 
        static constexpr std::string_view automaticSemiAuto {"AutomaticSemiAuto"};
        static constexpr std::string_view controlLock {"ControlLock"};
        static constexpr std::string_view remoteLocal {"RemoteLocal"};
        static constexpr std::string_view tripReset {"TripReset"};
 
        static constexpr std::string_view speedFeedback {"SpeedFeedback"};
        static constexpr std::string_view consignedSpeed {"ConsignedSpeed"};
        static constexpr std::string_view userConsignedSpeed {"UserConsignedSpeed"};
 
        static constexpr std::string_view runFeedbackSupply {"RunFeedbackSupply"};
        static constexpr std::string_view runFeedbackSupplyFast {"RunFeedbackSupplyFast"};
        static constexpr std::string_view runFeedbackExhaust {"RunFeedbackExhaust"};
        static constexpr std::string_view runFeedbackExhaustFast {"RunFeedbackExhaustFast"};
        static constexpr std::string_view stoppedFeedback {"StoppedFeedback"};
 
        static constexpr std::string_view startOrderSupply {"StartOrderSupply"};
        static constexpr std::string_view startOrderSupplyFast {"StartOrderSupplyFast"};
        static constexpr std::string_view startOrderExhaust {"StartOrderExhaust"};
        static constexpr std::string_view startOrderExhaustFast {"StartOrderExhaustFast"};
        static constexpr std::string_view stopOrder {"StopOrder"};
 
        static constexpr std::string_view startCommandSupply {"StartCommandSupply"};
        static constexpr std::string_view startCommandSupplyFast {"StartCommandSupplyFast"};
        static constexpr std::string_view startCommandExhaust {"StartCommandExhaust"};
        static constexpr std::string_view startCommandExhaustFast {"StartCommandExhaustFast"};
        static constexpr std::string_view stopCommand {"StopCommand"};
    };
};
 
}// namespace iv::mimics::elements
 
#endif//IV_SRC_MIMICS_CONTROLS_FAN_HPP_