// ====================================================================== // \title SmInitialQueuedComponentAc.cpp // \author Generated by fpp-to-cpp // \brief cpp file for SmInitialQueued component base class // ====================================================================== #include "Fw/Types/Assert.hpp" #include "Fw/Types/ExternalString.hpp" #if FW_ENABLE_TEXT_LOGGING #include "Fw/Types/String.hpp" #endif #include "base/SmInitialQueuedComponentAc.hpp" namespace FppTest { namespace { // Constant definitions for the state machine signal buffer namespace SmSignalBuffer { // The serialized size static constexpr FwSizeType SERIALIZED_SIZE = 2 * sizeof(FwEnumStoreType); } enum MsgTypeEnum { SMINITIALQUEUED_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT, INTERNAL_STATE_MACHINE_SIGNAL, }; // Get the max size by constructing a union of the async input, command, and // internal port serialization sizes union BuffUnion { // Size of buffer for internal state machine signals // The internal SmSignalBuffer stores the state machine id, the // signal id, and the signal data BYTE internalSmBufferSize[SmSignalBuffer::SERIALIZED_SIZE]; }; // Define a message buffer class large enough to handle all the // asynchronous inputs to the component class ComponentIpcSerializableBuffer : public Fw::SerializeBufferBase { public: enum { // Offset into data in buffer: Size of message ID and port number DATA_OFFSET = sizeof(FwEnumStoreType) + sizeof(FwIndexType), // Max data size MAX_DATA_SIZE = sizeof(BuffUnion), // Max message size: Size of message id + size of port + max data size SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE }; Fw::Serializable::SizeType getBuffCapacity() const { return sizeof(m_buff); } U8* getBuffAddr() { return m_buff; } const U8* getBuffAddr() const { return m_buff; } private: // Should be the max of all the input ports serialized sizes... U8 m_buff[SERIALIZATION_SIZE]; }; } // ---------------------------------------------------------------------- // Types for internal state machines // ---------------------------------------------------------------------- SmInitialQueuedComponentBase::FppTest_SmInitial_Basic :: FppTest_SmInitial_Basic(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitial_Basic :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitial_Basic :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitial_Basic :: action_a(Signal signal) { this->m_component.FppTest_SmInitial_Basic_action_a(this->getId(), signal); } SmInitialQueuedComponentBase::FppTest_SmInitial_Choice :: FppTest_SmInitial_Choice(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitial_Choice :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitial_Choice :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitial_Choice :: action_a(Signal signal) { this->m_component.FppTest_SmInitial_Choice_action_a(this->getId(), signal); } bool SmInitialQueuedComponentBase::FppTest_SmInitial_Choice :: guard_g(Signal signal) const { return this->m_component.FppTest_SmInitial_Choice_guard_g(this->getId(), signal); } SmInitialQueuedComponentBase::FppTest_SmInitial_Nested :: FppTest_SmInitial_Nested(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitial_Nested :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitial_Nested :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitial_Nested :: action_a(Signal signal) { this->m_component.FppTest_SmInitial_Nested_action_a(this->getId(), signal); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic :: FppTest_SmInitialQueued_Basic(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic :: action_a(Signal signal) { this->m_component.FppTest_SmInitialQueued_Basic_action_a(this->getId(), signal); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice :: FppTest_SmInitialQueued_Choice(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice :: action_a(Signal signal) { this->m_component.FppTest_SmInitialQueued_Choice_action_a(this->getId(), signal); } bool SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice :: guard_g(Signal signal) const { return this->m_component.FppTest_SmInitialQueued_Choice_guard_g(this->getId(), signal); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Nested :: FppTest_SmInitialQueued_Nested(SmInitialQueuedComponentBase& component) : m_component(component) { } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Nested :: init(SmInitialQueuedComponentBase::SmId smId) { this->initBase(static_cast(smId)); } SmInitialQueuedComponentBase::SmId SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Nested :: getId() const { return static_cast(this->m_id); } void SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Nested :: action_a(Signal signal) { this->m_component.FppTest_SmInitialQueued_Nested_action_a(this->getId(), signal); } // ---------------------------------------------------------------------- // Component initialization // ---------------------------------------------------------------------- void SmInitialQueuedComponentBase :: init( FwSizeType queueDepth, FwEnumStoreType instance ) { // Initialize base class Fw::QueuedComponentBase::init(instance); // Initialize state machine instances this->m_stateMachine_basic1.init(SmId::basic1); this->m_stateMachine_basic2.init(SmId::basic2); this->m_stateMachine_choice.init(SmId::choice); this->m_stateMachine_nested.init(SmId::nested); this->m_stateMachine_smInitialBasic1.init(SmId::smInitialBasic1); this->m_stateMachine_smInitialBasic2.init(SmId::smInitialBasic2); this->m_stateMachine_smInitialChoice.init(SmId::smInitialChoice); this->m_stateMachine_smInitialNested.init(SmId::smInitialNested); // Connect input port schedIn for ( FwIndexType port = 0; port < static_cast(this->getNum_schedIn_InputPorts()); port++ ) { this->m_schedIn_InputPort[port].init(); this->m_schedIn_InputPort[port].addCallComp( this, m_p_schedIn_in ); this->m_schedIn_InputPort[port].setPortNum(port); #if FW_OBJECT_NAMES == 1 Fw::ObjectName portName; portName.format( "%s_schedIn_InputPort[%" PRI_FwIndexType "]", this->m_objName.toChar(), port ); this->m_schedIn_InputPort[port].setObjName(portName.toChar()); #endif } // Create the queue Os::Queue::Status qStat = this->createQueue( queueDepth, static_cast(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE) ); FW_ASSERT( Os::Queue::Status::OP_OK == qStat, static_cast(qStat) ); } // ---------------------------------------------------------------------- // Getters for typed input ports // ---------------------------------------------------------------------- Svc::InputSchedPort* SmInitialQueuedComponentBase :: get_schedIn_InputPort(FwIndexType portNum) { FW_ASSERT( (0 <= portNum) && (portNum < this->getNum_schedIn_InputPorts()), static_cast(portNum) ); return &this->m_schedIn_InputPort[portNum]; } // ---------------------------------------------------------------------- // Component construction and destruction // ---------------------------------------------------------------------- SmInitialQueuedComponentBase :: SmInitialQueuedComponentBase(const char* compName) : Fw::QueuedComponentBase(compName), m_stateMachine_basic1(*this), m_stateMachine_basic2(*this), m_stateMachine_choice(*this), m_stateMachine_nested(*this), m_stateMachine_smInitialBasic1(*this), m_stateMachine_smInitialBasic2(*this), m_stateMachine_smInitialChoice(*this), m_stateMachine_smInitialNested(*this) { } SmInitialQueuedComponentBase :: ~SmInitialQueuedComponentBase() { } // ---------------------------------------------------------------------- // Port handler base-class functions for typed input ports // // Call these functions directly to bypass the corresponding ports // ---------------------------------------------------------------------- void SmInitialQueuedComponentBase :: schedIn_handlerBase( FwIndexType portNum, U32 context ) { // Make sure port number is valid FW_ASSERT( (0 <= portNum) && (portNum < this->getNum_schedIn_InputPorts()), static_cast(portNum) ); // Call handler function this->schedIn_handler( portNum, context ); } // ---------------------------------------------------------------------- // State getter functions // ---------------------------------------------------------------------- SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic::State SmInitialQueuedComponentBase :: basic1_getState() const { return this->m_stateMachine_basic1.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Basic::State SmInitialQueuedComponentBase :: basic2_getState() const { return this->m_stateMachine_basic2.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Choice::State SmInitialQueuedComponentBase :: choice_getState() const { return this->m_stateMachine_choice.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitialQueued_Nested::State SmInitialQueuedComponentBase :: nested_getState() const { return this->m_stateMachine_nested.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitial_Basic::State SmInitialQueuedComponentBase :: smInitialBasic1_getState() const { return this->m_stateMachine_smInitialBasic1.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitial_Basic::State SmInitialQueuedComponentBase :: smInitialBasic2_getState() const { return this->m_stateMachine_smInitialBasic2.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitial_Choice::State SmInitialQueuedComponentBase :: smInitialChoice_getState() const { return this->m_stateMachine_smInitialChoice.getState(); } SmInitialQueuedComponentBase::FppTest_SmInitial_Nested::State SmInitialQueuedComponentBase :: smInitialNested_getState() const { return this->m_stateMachine_smInitialNested.getState(); } // ---------------------------------------------------------------------- // Message dispatch functions // ---------------------------------------------------------------------- Fw::QueuedComponentBase::MsgDispatchStatus SmInitialQueuedComponentBase :: doDispatch() { ComponentIpcSerializableBuffer _msg; FwQueuePriorityType _priority = 0; Os::Queue::Status _msgStatus = this->m_queue.receive( _msg, Os::Queue::NONBLOCKING, _priority ); if (Os::Queue::Status::EMPTY == _msgStatus) { return Fw::QueuedComponentBase::MSG_DISPATCH_EMPTY; } else { FW_ASSERT( _msgStatus == Os::Queue::OP_OK, static_cast(_msgStatus) ); } // Reset to beginning of buffer _msg.resetDeser(); FwEnumStoreType _desMsg = 0; Fw::SerializeStatus _deserStatus = _msg.deserializeTo(_desMsg); FW_ASSERT( _deserStatus == Fw::FW_SERIALIZE_OK, static_cast(_deserStatus) ); MsgTypeEnum _msgType = static_cast(_desMsg); if (_msgType == SMINITIALQUEUED_COMPONENT_EXIT) { return MSG_DISPATCH_EXIT; } FwIndexType portNum = 0; _deserStatus = _msg.deserializeTo(portNum); FW_ASSERT( _deserStatus == Fw::FW_SERIALIZE_OK, static_cast(_deserStatus) ); switch (_msgType) { // Handle signals to internal state machines case INTERNAL_STATE_MACHINE_SIGNAL: this->smDispatch(_msg); break; default: return MSG_DISPATCH_ERROR; } return MSG_DISPATCH_OK; } // ---------------------------------------------------------------------- // Helper functions for dispatching current messages // ---------------------------------------------------------------------- Fw::QueuedComponentBase::MsgDispatchStatus SmInitialQueuedComponentBase :: dispatchCurrentMessages() { // Dispatch all current messages unless ERROR or EXIT occur const FwSizeType currentMessageCount = this->m_queue.getMessagesAvailable(); MsgDispatchStatus messageStatus = MsgDispatchStatus::MSG_DISPATCH_EMPTY; for (FwSizeType i = 0; i < currentMessageCount; i++) { messageStatus = this->doDispatch(); if (messageStatus != QueuedComponentBase::MSG_DISPATCH_OK) { break; } } return messageStatus; } // ---------------------------------------------------------------------- // Calls for messages received on typed input ports // ---------------------------------------------------------------------- void SmInitialQueuedComponentBase :: m_p_schedIn_in( Fw::PassiveComponentBase* callComp, FwIndexType portNum, U32 context ) { FW_ASSERT(callComp); SmInitialQueuedComponentBase* compPtr = static_cast(callComp); compPtr->schedIn_handlerBase( portNum, context ); } // ---------------------------------------------------------------------- // Helper functions for state machine dispatch // ---------------------------------------------------------------------- void SmInitialQueuedComponentBase :: smDispatch(Fw::SerializeBufferBase& buffer) { // Deserialize the state machine ID and signal FwEnumStoreType storedSmId; FwEnumStoreType storedSignal; SmInitialQueuedComponentBase::deserializeSmIdAndSignal(buffer, storedSmId, storedSignal); // Select the target state machine instance const SmId smId = static_cast(storedSmId); switch (smId) { case SmId::basic1: { const FppTest_SmInitialQueued_Basic::Signal signal = static_cast(storedSignal); this->FppTest_SmInitialQueued_Basic_smDispatch(buffer, this->m_stateMachine_basic1, signal); break; } case SmId::basic2: { const FppTest_SmInitialQueued_Basic::Signal signal = static_cast(storedSignal); this->FppTest_SmInitialQueued_Basic_smDispatch(buffer, this->m_stateMachine_basic2, signal); break; } case SmId::choice: { const FppTest_SmInitialQueued_Choice::Signal signal = static_cast(storedSignal); this->FppTest_SmInitialQueued_Choice_smDispatch(buffer, this->m_stateMachine_choice, signal); break; } case SmId::nested: { const FppTest_SmInitialQueued_Nested::Signal signal = static_cast(storedSignal); this->FppTest_SmInitialQueued_Nested_smDispatch(buffer, this->m_stateMachine_nested, signal); break; } case SmId::smInitialBasic1: { const FppTest_SmInitial_Basic::Signal signal = static_cast(storedSignal); this->FppTest_SmInitial_Basic_smDispatch(buffer, this->m_stateMachine_smInitialBasic1, signal); break; } case SmId::smInitialBasic2: { const FppTest_SmInitial_Basic::Signal signal = static_cast(storedSignal); this->FppTest_SmInitial_Basic_smDispatch(buffer, this->m_stateMachine_smInitialBasic2, signal); break; } case SmId::smInitialChoice: { const FppTest_SmInitial_Choice::Signal signal = static_cast(storedSignal); this->FppTest_SmInitial_Choice_smDispatch(buffer, this->m_stateMachine_smInitialChoice, signal); break; } case SmId::smInitialNested: { const FppTest_SmInitial_Nested::Signal signal = static_cast(storedSignal); this->FppTest_SmInitial_Nested_smDispatch(buffer, this->m_stateMachine_smInitialNested, signal); break; } default: FW_ASSERT(0, static_cast(smId)); break; } } void SmInitialQueuedComponentBase :: deserializeSmIdAndSignal( Fw::SerializeBufferBase& buffer, FwEnumStoreType& smId, FwEnumStoreType& signal ) { // Move deserialization beyond the message type and port number Fw::SerializeStatus status = buffer.moveDeserToOffset(ComponentIpcSerializableBuffer::DATA_OFFSET); FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast(status)); // Deserialize the state machine ID status = buffer.deserializeTo(smId); FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast(status)); // Deserialize the signal status = buffer.deserializeTo(signal); FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast(status)); } void SmInitialQueuedComponentBase :: FppTest_SmInitial_Basic_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitial_Basic& sm, FppTest_SmInitial_Basic::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } void SmInitialQueuedComponentBase :: FppTest_SmInitial_Choice_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitial_Choice& sm, FppTest_SmInitial_Choice::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } void SmInitialQueuedComponentBase :: FppTest_SmInitial_Nested_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitial_Nested& sm, FppTest_SmInitial_Nested::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } void SmInitialQueuedComponentBase :: FppTest_SmInitialQueued_Basic_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitialQueued_Basic& sm, FppTest_SmInitialQueued_Basic::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } void SmInitialQueuedComponentBase :: FppTest_SmInitialQueued_Choice_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitialQueued_Choice& sm, FppTest_SmInitialQueued_Choice::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } void SmInitialQueuedComponentBase :: FppTest_SmInitialQueued_Nested_smDispatch( Fw::SerializeBufferBase& buffer, FppTest_SmInitialQueued_Nested& sm, FppTest_SmInitialQueued_Nested::Signal signal ) { switch (signal) { default: FW_ASSERT(0, static_cast(signal)); break; } } }