diff --git a/GAMs/ElectricProbesGAM/ElectricProbesGAM.cpp b/GAMs/ElectricProbesGAM/ElectricProbesGAM.cpp index ae43ac3..a7ab9a0 100644 --- a/GAMs/ElectricProbesGAM/ElectricProbesGAM.cpp +++ b/GAMs/ElectricProbesGAM/ElectricProbesGAM.cpp @@ -29,31 +29,46 @@ /* Project header includes */ /*---------------------------------------------------------------------------*/ #include "AdvancedErrorManagement.h" +#include "CLASSMETHODREGISTER.h" + #include "ElectricProbesGAM.h" +#include "RegisteredMethodsMessageFilter.h" /*---------------------------------------------------------------------------*/ /* Static definitions */ /*---------------------------------------------------------------------------*/ +//namespace MARTeIsttok { +namespace MARTe { +/** + * The number of signals + */ + const uint32 EP_NUM_INPUTS = 4u; + const uint32 EP_NUM_OUTPUTS = 2u; + /*---------------------------------------------------------------------------*/ /* Method definitions */ /*---------------------------------------------------------------------------*/ -namespace MARTeIsttok { +//namespace MARTeIsttok { ElectricProbesGAM::ElectricProbesGAM() : GAM(), MessageI() { gain = 0u; - //inputSignals = NULL_PTR(MARTe::float32 **); + numberOfSamplesAvg = 1u; + //outputSignals = NULL_PTR(MARTe::float32 **); -// outputSignal1 = NULL; inputElectricTop = NULL_PTR(MARTe::float32 *); inputElectricInner = NULL_PTR(MARTe::float32 *); inputElectricOuter = NULL_PTR(MARTe::float32 *); inputElectricBottom = NULL_PTR(MARTe::float32 *); + lastInputs = NULL_PTR(MARTe::float32**); + + outputEpR = NULL_PTR(MARTe::float32 *); outputEpZ = NULL_PTR(MARTe::float32 *); + resetInEachState = false; } ElectricProbesGAM::~ElectricProbesGAM() { @@ -64,6 +79,22 @@ namespace MARTeIsttok { delete[] outputSignals; } */ + if (lastInputs != NULL_PTR(MARTe::float32**)) { + MARTe::uint32 k; + for (k=0u; k < EP_NUM_INPUTS; k++) { + if (lastInputs[k] != NULL_PTR(MARTe::float32*)) { + delete[] lastInputs[k]; + } + } + delete[] lastInputs; + } +/* + for (k=0u; k < EP_NUM_INPUTS; k++) { + if(lastInputs[k] != NULL_PTR(MARTe::float32 *)) { + delete [] lastInputs[k]; + } + } +*/ } bool ElectricProbesGAM::Initialise(MARTe::StructuredDataI & data) { @@ -81,6 +112,37 @@ namespace MARTeIsttok { if (ok) { REPORT_ERROR(ErrorManagement::Information, "Parameter Gain set to %d", gain); } + if (ok) { + ok = data.Read("NumberOfSamplesAvg", numberOfSamplesAvg); + if (!ok) { + REPORT_ERROR(ErrorManagement::ParametersError, + "The parameter NumberOfSamplesAvg shall be set"); + } + } + if (ok) { + REPORT_ERROR(ErrorManagement::Information, "Parameter NumberOfSamplesAvg set to %d", + numberOfSamplesAvg); + } + if (ok) { + uint32 auxResetInEachState = 0u; + ok = data.Read("ResetInEachState", auxResetInEachState); + if (!ok) { + REPORT_ERROR(ErrorManagement::InitialisationError, "Error reading ResetInEachState"); + } + else { + if (auxResetInEachState == 1u) { + resetInEachState = true; + } + else if (auxResetInEachState == 0u) { + resetInEachState = false; + } + else { + ok = false; + REPORT_ERROR(ErrorManagement::InitialisationError, "Wrong value for ResetInEachState. Possible values 0 (false) or 1 (true)"); + } + } + } + return ok; } @@ -93,7 +155,22 @@ namespace MARTeIsttok { } if (ok) { + lastInputs = new float32*[numberOfInputSignals]; uint32 n; + if (lastInputs != NULL_PTR(MARTe::float32**)) { + for (n = 0u; n < numberOfInputSignals ; n++) { + if (numberOfSamplesAvg > 1u) { + lastInputs[n] = new float32[numberOfSamplesAvg - 1u]; + if (lastInputs[n] != NULL_PTR(MARTe::float32*)) { + uint32 i; + for (i = 0u; i < (numberOfSamplesAvg - 1u); i++) { + lastInputs[n][i] = 0.0F; + } + } + } + } + } + for (n = 0u; (n < numberOfInputSignals) && (ok); n++) { StreamString inputSignalName; ok = GetSignalName(InputSignals, n, inputSignalName); @@ -155,6 +232,7 @@ namespace MARTeIsttok { REPORT_ERROR(ErrorManagement::Information, "InputSignals reinterpret_cast OK"); } + } // OutputSignals @@ -217,6 +295,19 @@ namespace MARTeIsttok { outputEpZ = reinterpret_cast(GetOutputSignalMemory(1u)); } } + + // Install message filter + ReferenceT registeredMethodsMessageFilter("RegisteredMethodsMessageFilter"); + + if (ok) { + ok = registeredMethodsMessageFilter.IsValid(); + } + + if (ok) { + registeredMethodsMessageFilter->SetDestination(this); + ok = InstallMessageFilter(registeredMethodsMessageFilter); + } + return ok; } @@ -225,12 +316,75 @@ namespace MARTeIsttok { //*outputSignal = *inputSignal; *outputEpR = 4.3; // *outputEpZ = 3.4; - *outputEpZ = *inputElectricTop; + *outputEpZ = *inputElectricTop - *inputElectricOuter; //*outputSignal1 = *inputSignals[0]; // - *inputSignals[1]; //*outputSignal1 = *inputSignals[0] - *inputSignals[1]; + + //update the last values + for (MARTe::uint32 i = 0u; i < EP_NUM_INPUTS; i++) { + + if (numberOfSamplesAvg > 2u) { + /*lint -e{9117} implicit conversion is safe*/ + for (MARTe::uint32 k = (numberOfSamplesAvg - 1u); k > 0u; k--) { + lastInputs[i][k] = lastInputs[i][k - 1]; + } + } + } + if (numberOfSamplesAvg > 1u) { + lastInputs[0][0] = *inputElectricTop; + lastInputs[1][0] = *inputElectricInner; + lastInputs[2][0] = *inputElectricOuter; + lastInputs[3][0] = *inputElectricBottom; + //lastInputs[i][0] = input[i][numberOfSamples - 1u]; + } + return true; } + bool ElectricProbesGAM::PrepareNextState(const char8 * const currentStateName, + const char8 * const nextStateName) { + bool ret = true; + + if (resetInEachState) { + lastStateExecuted = nextStateName; + } +/* + bool cond1 = (stateVector.GetDataPointer() != NULL_PTR(float64 **)); + bool cond2 = (derivativeStateVector.GetDataPointer() != NULL_PTR(float64 **)); + if (cond1 && cond2) { + for (uint32 i = 0u; i < sizeStateVector; i++) { + stateVector(i, 0u) = 0.0; + derivativeStateVector(i, 0u) = 0.0; + } + } + else { + REPORT_ERROR(ErrorManagement::ParametersError, "stateVector or derivativeStateVector = NULL "); + ret = false; + } + + } + else { + //If the currentStateName and lastStateExecuted are different-> rest values + if (lastStateExecuted != currentStateName) { + bool cond1 = (stateVector.GetDataPointer() != NULL_PTR(float64 **)); + bool cond2 = (derivativeStateVector.GetDataPointer() != NULL_PTR(float64 **)); + if (cond1 && cond2) { + for (uint32 i = 0u; i < sizeStateVector; i++) { + stateVector(i, 0u) = 0.0; + derivativeStateVector(i, 0u) = 0.0; + } + } + else { + REPORT_ERROR(ErrorManagement::ParametersError, "stateVector or derivativeStateVector = NULL "); + ret = false; + } + } + lastStateExecuted = nextStateName; + } +*/ + return ret; + } + bool ElectricProbesGAM::ExportData(MARTe::StructuredDataI & data) { using namespace MARTe; @@ -247,9 +401,32 @@ namespace MARTeIsttok { return ok; } - CLASS_REGISTER(ElectricProbesGAM, "1.0") - //CLASS_METHOD_REGISTER(AtcaIopConfig, WriteEoWo) + ErrorManagement::ErrorType ElectricProbesGAM::CalcOffSets() { -} + ErrorManagement::ErrorType ret = MARTe::ErrorManagement::NoError; + REPORT_ERROR(ErrorManagement::Information, + "CalcOffSets. numberOfSamplesAvg: %d!", numberOfSamplesAvg); + if (numberOfSamplesAvg > 1u) { + for (uint32 i = 0u; i < EP_NUM_INPUTS; i++) { + inputOffsets[i] = 0.0f; + for (uint32 k = 0 ; k < numberOfSamplesAvg; k++) { + inputOffsets[i] += lastInputs[i][k]; + } + inputOffsets[i] /= numberOfSamplesAvg; + REPORT_ERROR(ErrorManagement::Information, + "CalcOffSets. Offset:%d= %f!", i, inputOffsets[i]); + } + } + + return ret; + } + + + CLASS_REGISTER(ElectricProbesGAM, "1.0") + +// CLASS_METHOD_REGISTER(ElectricProbesGAM, ElectricProbesGAM::CalcOffSets) + CLASS_METHOD_REGISTER(ElectricProbesGAM, CalcOffSets) + +} /* namespace MARTeIsttok */ // vim: syntax=cpp ts=4 sw=4 sts=4 sr et diff --git a/GAMs/ElectricProbesGAM/ElectricProbesGAM.h b/GAMs/ElectricProbesGAM/ElectricProbesGAM.h index b0d5ec2..adb49a0 100644 --- a/GAMs/ElectricProbesGAM/ElectricProbesGAM.h +++ b/GAMs/ElectricProbesGAM/ElectricProbesGAM.h @@ -38,101 +38,150 @@ /*---------------------------------------------------------------------------*/ /* Class declaration */ /*---------------------------------------------------------------------------*/ -namespace MARTeIsttok { -/** - * @brief An example of a GAM which has fixed inputs and outputs. - * - * @details This GAM multiplies the input signal by a Gain. - * The configuration syntax is (names and types are only given as an example): - * - * +GAMElectricProbes = { - * Class = ElectricProbesGAM - * Gain = 5 //Compulsory - * InputSignals = { - * Signal1 = { - * DataSource = "DDB1" - * Type = uint32 - * } - * } - * OutputSignals = { - * Signal1 = { - * DataSource = "DDB1" - * Type = uint32 - * } - * } - * } - */ -class ElectricProbesGAM : public MARTe::GAM, public MARTe::MessageI { -public: - CLASS_REGISTER_DECLARATION() +//namespace MARTeIsttok { +namespace MARTe { /** - * @brief Constructor. NOOP. + * @brief An example of a GAM which has fixed inputs and outputs. + * + * @details This GAM multiplies the input signal by a Gain. + * The configuration syntax is (names and types are only given as an example): + * + * +GAMElectricProbes = { + * Class = ElectricProbesGAM + * Gain = 5 //Compulsory + * NumberOfSamplesAvg = 4 //Compulsory + * ResetInEachState = 0//Compulsory. 1--> reset in each state, 0--> reset if the previous state is different from the next state + + * InputSignals = { + * Signal1 = { + * DataSource = "DDB1" + * Type = uint32 + * } + * } + * OutputSignals = { + * Signal1 = { + * DataSource = "DDB1" + * Type = uint32 + * } + * } + * } */ - ElectricProbesGAM(); + class ElectricProbesGAM : public MARTe::GAM, public MARTe::MessageI { + public: + CLASS_REGISTER_DECLARATION() + /** + * @brief Constructor. NOOP. + */ + ElectricProbesGAM(); - /** - * @brief Destructor. NOOP. - */ - virtual ~ElectricProbesGAM(); + /** + * @brief Destructor. NOOP. + */ + virtual ~ElectricProbesGAM(); - /** - * @brief Reads the Gain from the configuration file. - * @param[in] data see GAM::Initialise. The parameter Gain shall exist and will be read as an uint32. - * @return true if the parameter Gain can be read. - */ - virtual bool Initialise(MARTe::StructuredDataI & data); + /** + * @brief Reads the Gain from the configuration file. + * @param[in] data see GAM::Initialise. The parameter Gain shall exist and will be read as an uint32. + * @return true if the parameter Gain can be read. + */ + virtual bool Initialise(MARTe::StructuredDataI & data); - /** - * @brief Verifies correctness of the GAM configuration. - * @details Checks that the number of input signals is equal to the number of output signals is equal to one and that the same type is used. - * @return true if the pre-conditions are met. - * @pre - * SetConfiguredDatabase() && - * GetNumberOfInputSignals() == GetNumberOfOutputSignals() == 1 && - * GetSignalType(InputSignals, 0) == GetSignalType(OutputSignals, 0) == uint32 && - * GetSignalNumberOfDimensions(InputSignals, 0) == GetSignalNumberOfDimensions(OutputSignals, 0) == 0 && - * GetSignalNumberOfSamples(InputSignals, 0) == GetSignalNumberOfSamples(OutputSignals, 0) == 1 && - * GetSignalNumberOfElements(InputSignals, 0) == GetSignalNumberOfElements(OutputSignals, 0) == 1 - */ - virtual bool Setup(); + /** + * @brief Verifies correctness of the GAM configuration. + * @details Checks that the number of input signals is equal to the number of output signals is equal to one and that the same type is used. + * @return true if the pre-conditions are met. + * @pre + * SetConfiguredDatabase() && + * GetNumberOfInputSignals() == 4 + * GetNumberOfInputSignals() == + * GetSignalType(InputSignals, 0) == GetSignalType(OutputSignals, 0) == uint32 && + */ + virtual bool Setup(); - /** - * @brief Multiplies the input signal by the Gain. - * @return true. - */ - virtual bool Execute(); - - /** - * @brief Export information about the component - */ - virtual bool ExportData(MARTe::StructuredDataI & data); - -private: - - /** - * The input signals - */ -// MARTe::float32 **inputSignals; - - MARTe::float32 *inputElectricTop; - MARTe::float32 *inputElectricInner; - MARTe::float32 *inputElectricOuter; - MARTe::float32 *inputElectricBottom; - - /** - * The output signals - */ - // MARTe::float32 **outputSignals; - //MARTe::float32 *outputSignal1; - MARTe::float32 *outputEpR; - MARTe::float32 *outputEpZ; + /** + * @brief Multiplies the input signal by the Gain. + * @return true. + */ + virtual bool Execute(); + + /** + * @brief Reset the states if required. + * @details This functions has two operations modes: + * + * @param[in] currentStateName indicates the current state. + * @param[in] nextStateName indicates the next state. + * @return true if the state vectors are not NULL. + */ + virtual bool PrepareNextState(const char8 * const currentStateName, + const char8 * const nextStateName); - /** - * The configured gain. - */ - MARTe::uint32 gain; -}; + /** + * @brief CalcOffSets method. + * @details The method is registered as a messageable function. + * @return ErrorManagement::NoError if the pre-conditions are met, ErrorManagement::ParametersError + * otherwise. + */ + + MARTe::ErrorManagement::ErrorType CalcOffSets(); + + /** + * @brief Export information about the component + */ + virtual bool ExportData(MARTe::StructuredDataI & data); + + private: + + /** + * The configured gain. + */ + MARTe::uint32 gain; + + /** + * The configured numberOfSamplesAvg. + */ + uint32 numberOfSamplesAvg; + + /** + * The input signals + */ + + MARTe::float32 *inputElectricTop; + MARTe::float32 *inputElectricInner; + MARTe::float32 *inputElectricOuter; + MARTe::float32 *inputElectricBottom; + + MARTe::float32 inputOffsets[4]; + + MARTe::float32 **lastInputs; + + /** + * The output signals + */ + // MARTe::float32 **outputSignals; + //MARTe::float32 *outputSignal1; + float32 *outputEpR; + float32 *outputEpZ; + + /** + * Indicates the behaviour of the reset when MARTe changes the state + */ + bool resetInEachState; + + /** + * Remember the last executed state. + */ + StreamString lastStateExecuted; + + + }; } /*---------------------------------------------------------------------------*/ /* Inline method definitions */ @@ -140,3 +189,4 @@ private: #endif /* ELECTRICPROBESGAM_H_ */ +// vim: syntax=cpp ts=4 sw=4 sts=4 sr et