isobus_maintain_power_interface.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_MAINTAIN_POWER_INTERFACE_HPP
#define ISOBUS_MAINTAIN_POWER_INTERFACE_HPP
 
#include "isobus/isobus/can_internal_control_function.hpp"
#include "isobus/isobus/can_message.hpp"
#include "isobus/utility/event_dispatcher.hpp"
#include "isobus/utility/processing_flags.hpp"
 
#include <memory>
 
namespace isobus
{
    class MaintainPowerInterface
    {
    public:
        class MaintainPowerData
        {
        public:
            enum class ImplementInWorkState : std::uint8_t
            {
                ImplementNotInWorkState = 0,
                ImplementInWorkState = 1,
                ErrorIndication = 2,
                NotAvailable = 3
            };
 
            enum class ImplementReadyToWorkState
            {
                ImplementNotReadyForFieldWork = 0,
                ImplementReadyForFieldWork = 1,
                ErrorIndication = 2,
                NotAvailable = 3
            };
 
            enum class ImplementParkState
            {
                ImplementMayNotBeDisconnected = 0,
                ImplementMayBeDisconnected = 1,
                ErrorIndication = 2,
                NotAvailable = 3
            };
 
            enum class ImplementTransportState
            {
                ImplementMayNotBeTransported = 0,
                ImplementMayBeTransported = 1,
                ErrorIndication = 2,
                NotAvailable = 3
            };
 
            enum class MaintainActuatorPower
            {
                NoFurtherRequirementForPWR = 0,
                RequirementFor2SecondsMoreForPWR = 1,
                Reserved = 2,
                DontCare = 3
            };
 
            enum class MaintainECUPower
            {
                NoFurtherRequirementForECU_PWR = 0,
                RequirementFor2SecondsMoreForECU_PWR = 1,
                Reserved = 2,
                DontCare = 3
            };
 
            explicit MaintainPowerData(std::shared_ptr<ControlFunction> sendingControlFunction);
 
            bool set_implement_in_work_state(ImplementInWorkState inWorkState);
 
            ImplementInWorkState get_implement_in_work_state() const;
 
            bool set_implement_ready_to_work_state(ImplementReadyToWorkState readyToWorkState);
 
            ImplementReadyToWorkState get_implement_ready_to_work_state() const;
 
            bool set_implement_park_state(ImplementParkState parkState);
 
            ImplementParkState get_implement_park_state() const;
 
            bool set_implement_transport_state(ImplementTransportState transportState);
 
            ImplementTransportState get_implement_transport_state() const;
 
            bool set_maintain_actuator_power(MaintainActuatorPower maintainState);
 
            MaintainActuatorPower get_maintain_actuator_power() const;
 
            bool set_maintain_ecu_power(MaintainECUPower maintainState);
 
            MaintainECUPower get_maintain_ecu_power() const;
 
            std::shared_ptr<ControlFunction> get_sender_control_function() const;
 
            void set_timestamp_ms(std::uint32_t timestamp);
 
            std::uint32_t get_timestamp_ms() const;
 
        private:
            MaintainPowerData() = delete;
            std::shared_ptr<ControlFunction> sendingControlFunction = nullptr; 
            std::uint32_t timestamp_ms = 0; 
            ImplementInWorkState currentImplementInWorkState = ImplementInWorkState::NotAvailable; 
            ImplementReadyToWorkState currentImplementReadyToWorkState = ImplementReadyToWorkState::NotAvailable; 
            ImplementParkState currentImplementParkState = ImplementParkState::NotAvailable; 
            ImplementTransportState currentImplementTransportState = ImplementTransportState::NotAvailable; 
            MaintainActuatorPower currentMaintainActuatorPowerState = MaintainActuatorPower::DontCare; 
            MaintainECUPower currentMaintainECUPowerState = MaintainECUPower::DontCare; 
        };
 
        explicit MaintainPowerInterface(std::shared_ptr<InternalControlFunction> sourceControlFunction);
 
        ~MaintainPowerInterface();
 
        void initialize();
 
        bool get_initialized() const;
 
        void set_maintain_power_time(std::uint32_t timeToMaintainPower);
 
        std::uint32_t get_maintain_power_time() const;
 
        std::size_t get_number_received_maintain_power_sources() const;
 
        std::shared_ptr<MaintainPowerData> get_received_maintain_power(std::size_t index);
 
        EventDispatcher<const std::shared_ptr<MaintainPowerData>, bool> &get_maintain_power_data_event_publisher();
 
        EventDispatcher<> &get_key_switch_transition_off_event_publisher();
 
        MaintainPowerData maintainPowerTransmitData;
 
        void update();
 
    protected:
        bool send_maintain_power() const;
 
        static void process_flags(std::uint32_t flag, void *parentPointer);
 
        static void process_rx_message(const CANMessage &message, void *parentPointer);
 
        ProcessingFlags txFlags; 
 
    private:
        enum class TransmitFlags : std::uint32_t
        {
            SendMaintainPower = 0, 
 
            NumberOfFlags 
        };
 
        enum class KeySwitchState : std::uint8_t
        {
            Off = 0, 
            NotOff = 1, 
            Error = 2,
            NotAvailable = 3
        };
 
        static constexpr std::uint32_t MAINTAIN_POWER_TIMEOUT_MS = 2000; 
        std::vector<std::shared_ptr<MaintainPowerData>> receivedMaintainPowerMessages; 
        EventDispatcher<const std::shared_ptr<MaintainPowerData>, bool> maintainPowerDataEventPublisher; 
        EventDispatcher<> keySwitchOffEventPublisher; 
        std::uint32_t keyNotOffTimestamp = 0; 
        std::uint32_t keyOffTimestamp = 0; 
        std::uint32_t maintainPowerTransmitTimestamp_ms = 0; 
        std::uint32_t maintainPowerTime_ms = 0; 
        bool initialized = false; 
    };
} // namespace isobus
#endif // ISOBUS_MAINTAIN_POWER_INTERFACE_HPP