HealthComponentAc.hpp

Go to the documentation of this file.

// ======================================================================
// \title  HealthComponentAc.hpp
// \author Auto-generated
// \brief  hpp file for Health component base class
//
// \copyright
// Copyright 2009-2015, by the California Institute of Technology.
// ALL RIGHTS RESERVED.  United States Government Sponsorship
// acknowledged.
//
// ======================================================================
 
#ifndef HEALTH_COMP_HPP_
#define HEALTH_COMP_HPP_
 
#include <FpConfig.hpp>
#include <Fw/Port/InputSerializePort.hpp>
#include <Fw/Port/OutputSerializePort.hpp>
#include <Fw/Comp/ActiveComponentBase.hpp>
#include <Fw/Cmd/CmdString.hpp>
#include <Fw/Tlm/TlmString.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogString.hpp>
#include <Fw/Cmd/CmdArgBuffer.hpp>
#include <Fw/Tlm/TlmBuffer.hpp>
#include <Fw/Time/Time.hpp>
#include <Fw/Log/LogBuffer.hpp>
#include <Fw/Log/TextLogString.hpp>
#include <Svc/Sched/SchedPortAc.hpp>
#include <Svc/Ping/PingPortAc.hpp>
#include <Svc/WatchDog/WatchDogPortAc.hpp>
#include <Fw/Cmd/CmdPortAc.hpp>
#include <Fw/Cmd/CmdResponsePortAc.hpp>
#include <Fw/Cmd/CmdRegPortAc.hpp>
#include <Fw/Tlm/TlmPortAc.hpp>
#include <Fw/Time/TimePortAc.hpp>
#include <Fw/Log/LogPortAc.hpp>
#if FW_ENABLE_TEXT_LOGGING == 1
#include <Fw/Log/LogTextPortAc.hpp>
#endif
 
namespace Svc {
 
  class HealthComponentBase :
    public Fw::QueuedComponentBase
  {
 
    // ----------------------------------------------------------------------
    // Friend classes
    // ----------------------------------------------------------------------
 
    friend class HealthComponentBaseFriend;
 
  public:
 
    // ----------------------------------------------------------------------
    // Getters for typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputPingPort* get_PingReturn_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Svc::InputSchedPort* get_Run_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    Fw::InputCmdPort* get_CmdDisp_InputPort(
        NATIVE_INT_TYPE portNum 
    );
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect typed input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_PingSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputPingPort *port 
    );
 
    void set_WdogStroke_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Svc::InputWatchDogPort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdResponsePort *port 
    );
 
    void set_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputCmdRegPort *port 
    );
 
    void set_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTlmPort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputTimePort *port 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogPort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputLogTextPort *port 
    );
#endif
 
#if FW_PORT_SERIALIZATION
 
  public:
 
    // ----------------------------------------------------------------------
    // Connect serialization input ports to typed output ports
    // ----------------------------------------------------------------------
 
    void set_PingSend_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_WdogStroke_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Time_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
    void set_Log_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    void set_LogText_OutputPort(
        NATIVE_INT_TYPE portNum, 
        Fw::InputSerializePort *port 
    );
#endif
 
#endif
 
  public:
 
    // ----------------------------------------------------------------------
    // Command registration
    // ----------------------------------------------------------------------
 
    void regCommands(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Component construction, initialization, and destruction
    // ----------------------------------------------------------------------
 
#if FW_OBJECT_NAMES == 1
    HealthComponentBase(
        const char* compName 
    );
#else
    HealthComponentBase(void);
#endif
 
    void init(
        NATIVE_INT_TYPE queueDepth, 
        NATIVE_INT_TYPE instance = 0 
    );
 
    virtual ~HealthComponentBase(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Handlers to implement for typed input ports
    // ----------------------------------------------------------------------
 
    //
    virtual void PingReturn_handler(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    ) = 0;
 
    //
    virtual void Run_handler(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Port handler base-class functions for typed input ports.
    // ----------------------------------------------------------------------
    // Call these functions directly to bypass the corresponding ports.
    // ----------------------------------------------------------------------
 
    void PingReturn_handlerBase(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    void Run_handlerBase(
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for typed async input ports.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing a message
    // on the corresponding port. By default they do nothing. You can
    // override them to provide specific pre-message behavior.
    // ----------------------------------------------------------------------
 
    virtual void PingReturn_preMsgHook(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Invocation functions for typed output ports
    // ----------------------------------------------------------------------
 
    void PingSend_out(
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    void WdogStroke_out(
        NATIVE_INT_TYPE portNum, 
        U32 code 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of input ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_PingReturn_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_Run_InputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdDisp_InputPorts(void);
 
 
    // ----------------------------------------------------------------------
    // Enumerations for number of ports
    // ----------------------------------------------------------------------
 
    enum {
       NUM_PINGRETURN_INPUT_PORTS = 25           ,
       NUM_RUN_INPUT_PORTS = 1,
       NUM_CMDDISP_INPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Getters for numbers of output ports
    // ----------------------------------------------------------------------
 
    NATIVE_INT_TYPE getNum_PingSend_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_WdogStroke_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdStatus_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_CmdReg_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Tlm_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Time_OutputPorts(void);
 
    NATIVE_INT_TYPE getNum_Log_OutputPorts(void);
 
#if FW_ENABLE_TEXT_LOGGING == 1
    NATIVE_INT_TYPE getNum_LogText_OutputPorts(void);
#endif
 
 
    enum {
       NUM_PINGSEND_OUTPUT_PORTS = 25           ,
       NUM_WDOGSTROKE_OUTPUT_PORTS = 1,
       NUM_CMDSTATUS_OUTPUT_PORTS = 1,
       NUM_CMDREG_OUTPUT_PORTS = 1,
       NUM_TLM_OUTPUT_PORTS = 1,
       NUM_TIME_OUTPUT_PORTS = 1,
       NUM_LOG_OUTPUT_PORTS = 1,
       NUM_LOGTEXT_OUTPUT_PORTS = 1,
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Connection status queries for output ports
    // ----------------------------------------------------------------------
 
    bool isConnected_PingSend_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_WdogStroke_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdStatus_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_CmdReg_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Tlm_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Time_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
    bool isConnected_Log_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
 
#if FW_ENABLE_TEXT_LOGGING == 1
    bool isConnected_LogText_OutputPort(
        NATIVE_INT_TYPE portNum 
    );
#endif
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Message dispatch
    // ----------------------------------------------------------------------
 
    virtual MsgDispatchStatus doDispatch(void);
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      HLTH_CHK_DISABLED, /*  */
      HLTH_CHK_ENABLED, /*  */
      HealthEnabled_MAX
    } HealthEnabled;
 
    typedef enum {
      HLTH_PING_DISABLED, /*  */
      HLTH_PING_ENABLED, /*  */
      PingEnabled_MAX
    } PingEnabled;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command opcodes
    // ----------------------------------------------------------------------
 
    enum {
      OPCODE_HLTH_ENABLE = 0x0, /* A command to enable or disable health checks */
      OPCODE_HLTH_PING_ENABLE = 0x1, /* Ignore a particular ping entry */
      OPCODE_HLTH_CHNG_PING = 0x2, /* Change ping value */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handlers to implement
    // ----------------------------------------------------------------------
 
    /* A command to enable or disable health checks */
    virtual void HLTH_ENABLE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        HealthEnabled enable 
    ) = 0;
 
    /* Ignore a particular ping entry */
    virtual void HLTH_PING_ENABLE_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& entry, 
        PingEnabled enable 
    ) = 0;
 
    /* Change ping value */
    virtual void HLTH_CHNG_PING_cmdHandler(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        const Fw::CmdStringArg& entry, 
        U32 warningValue, 
        U32 fatalValue 
    ) = 0;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Pre-message hooks for async commands.
    // ----------------------------------------------------------------------
    // Each of these functions is invoked just before processing the
    // corresponding command. By default they do nothing. You can
    // override them to provide specific pre-command behavior.
    // ----------------------------------------------------------------------
 
    virtual void HLTH_ENABLE_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void HLTH_PING_ENABLE_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
    virtual void HLTH_CHNG_PING_preMsgHook(
        FwOpcodeType opCode, 
        U32 cmdSeq 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command handler base-class functions.
    // Call these functions directly to bypass the command input port.
    // ----------------------------------------------------------------------
 
    void HLTH_ENABLE_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void HLTH_PING_ENABLE_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
    void HLTH_CHNG_PING_cmdHandlerBase(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Command response
    // ----------------------------------------------------------------------
 
    void cmdResponse_out(
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CommandResponse response 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event IDs
    // ----------------------------------------------------------------------
 
    enum {
      EVENTID_HLTH_PING_WARN = 0x0, /* Warn that a ping target is longer than the warning value */
      EVENTID_HLTH_PING_LATE = 0x1, /* Declare FATAL since task is no longer responding */
      EVENTID_HLTH_PING_WRONG_KEY = 0x2, /* Declare FATAL since task is no longer responding */
      EVENTID_HLTH_CHECK_ENABLE = 0x3, /* Report checking turned on or off */
      EVENTID_HLTH_CHECK_PING = 0x4, /* Report a particular entry on or off */
      EVENTID_HLTH_CHECK_LOOKUP_ERROR = 0x5, /* Entry was not found */
      EVENTID_HLTH_PING_UPDATED = 0x6, /* Report changed ping */
      EVENTID_HLTH_PING_INVALID_VALUES = 0x7, /* Report changed ping */
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event enums
    // ----------------------------------------------------------------------
 
    typedef enum {
      HEALTH_CHECK_DISABLED, /*  */
      HEALTH_CHECK_ENABLED, /*  */
      HealthIsEnabled_MAX
    } HealthIsEnabled;
 
    typedef enum {
      HEALTH_PING_DISABLED, /*  */
      HEALTH_PING_ENABLED, /*  */
      HealthPingIsEnabled_MAX
    } HealthPingIsEnabled;
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Event logging functions
    // ----------------------------------------------------------------------
 
    /* Warn that a ping target is longer than the warning value */
    void log_WARNING_HI_HLTH_PING_WARN(
        Fw::LogStringArg& entry 
    );
 
 
    /* Declare FATAL since task is no longer responding */
    void log_FATAL_HLTH_PING_LATE(
        Fw::LogStringArg& entry 
    );
 
 
    /* Declare FATAL since task is no longer responding */
    void log_FATAL_HLTH_PING_WRONG_KEY(
        Fw::LogStringArg& entry, 
        U32 badKey 
    );
 
 
    /* Report checking turned on or off */
    void log_ACTIVITY_HI_HLTH_CHECK_ENABLE(
        HealthIsEnabled enabled 
    );
 
 
    /* Report a particular entry on or off */
    void log_ACTIVITY_HI_HLTH_CHECK_PING(
        HealthPingIsEnabled enabled, 
        Fw::LogStringArg& entry 
    );
 
 
    /* Entry was not found */
    void log_WARNING_LO_HLTH_CHECK_LOOKUP_ERROR(
        Fw::LogStringArg& entry 
    );
 
 
    /* Report changed ping */
    void log_ACTIVITY_HI_HLTH_PING_UPDATED(
        Fw::LogStringArg& entry, 
        U32 warn, 
        U32 fatal 
    );
 
 
    /* Report changed ping */
    void log_WARNING_HI_HLTH_PING_INVALID_VALUES(
        Fw::LogStringArg& entry, 
        U32 warn, 
        U32 fatal 
    );
 
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Channel IDs
    // ----------------------------------------------------------------------
 
    enum {
      CHANNELID_PINGLATEWARNINGS = 0x0, 
    };
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Telemetry write functions
    // ----------------------------------------------------------------------
 
    /* Number of overrun warnings */
    void tlmWrite_PingLateWarnings(
        U32 arg 
    );
 
  PROTECTED:
 
    // ----------------------------------------------------------------------
    // Time
    // ----------------------------------------------------------------------
 
    Fw::Time getTime(void);
 
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed input ports
    // ----------------------------------------------------------------------
 
    Svc::InputPingPort m_PingReturn_InputPort[NUM_PINGRETURN_INPUT_PORTS];
 
    Svc::InputSchedPort m_Run_InputPort[NUM_RUN_INPUT_PORTS];
 
    Fw::InputCmdPort m_CmdDisp_InputPort[NUM_CMDDISP_INPUT_PORTS];
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Typed output ports
    // ----------------------------------------------------------------------
 
    Svc::OutputPingPort m_PingSend_OutputPort[NUM_PINGSEND_OUTPUT_PORTS];
 
    Svc::OutputWatchDogPort m_WdogStroke_OutputPort[NUM_WDOGSTROKE_OUTPUT_PORTS];
 
    Fw::OutputCmdResponsePort m_CmdStatus_OutputPort[NUM_CMDSTATUS_OUTPUT_PORTS];
 
    Fw::OutputCmdRegPort m_CmdReg_OutputPort[NUM_CMDREG_OUTPUT_PORTS];
 
    Fw::OutputTlmPort m_Tlm_OutputPort[NUM_TLM_OUTPUT_PORTS];
 
    Fw::OutputTimePort m_Time_OutputPort[NUM_TIME_OUTPUT_PORTS];
 
    Fw::OutputLogPort m_Log_OutputPort[NUM_LOG_OUTPUT_PORTS];
 
#if FW_ENABLE_TEXT_LOGGING == 1
    Fw::OutputLogTextPort m_LogText_OutputPort[NUM_LOGTEXT_OUTPUT_PORTS];
#endif
 
  PRIVATE:
 
    // ----------------------------------------------------------------------
    // Calls for messages received on typed input ports
    // ----------------------------------------------------------------------
 
    static void m_p_PingReturn_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        U32 key 
    );
 
    static void m_p_Run_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        NATIVE_UINT_TYPE context 
    );
 
    static void m_p_CmdDisp_in(
        Fw::PassiveComponentBase* callComp, 
        NATIVE_INT_TYPE portNum, 
        FwOpcodeType opCode, 
        U32 cmdSeq, 
        Fw::CmdArgBuffer &args 
    );
 
 
  PRIVATE:
    // ----------------------------------------------------------------------
    // Counter values for event throttling
    // ----------------------------------------------------------------------
 
  };
 
} // end namespace Svc
#endif