155 lines
5.8 KiB
C++
155 lines
5.8 KiB
C++
/**
|
|
* @file JAModeControlGAM.cpp
|
|
* @brief Source file for class JAModeControlGAM
|
|
* @date Jan, 2019
|
|
* @author kuchida
|
|
*
|
|
* @copyright Copyright 2015 F4E | European Joint Undertaking for ITER and
|
|
* the Development of Fusion Energy ('Fusion for Energy').
|
|
* Licensed under the EUPL, Version 1.1 or - as soon they will be approved
|
|
* by the European Commission - subsequent versions of the EUPL (the "Licence")
|
|
* You may not use this work except in compliance with the Licence.
|
|
* You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
|
|
*
|
|
* @warning Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the Licence is distributed on an "AS IS"
|
|
* basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
|
* or implied. See the Licence permissions and limitations under the Licence.
|
|
|
|
* @details This source file contains the definition of all the methods for
|
|
* the class JAModeControlGAM (public, protected, and private). Be aware that some
|
|
* methods, such as those inline could be defined on the header file, instead.
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Standard header includes */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Project header includes */
|
|
/*---------------------------------------------------------------------------*/
|
|
#include "JAModeControlGAM.h"
|
|
#include "AdvancedErrorManagement.h"
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Static definitions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Method definitions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
JAModeControlGAM::JAModeControlGAM() {
|
|
inputSignals = NULL_PTR(MARTe::uint32 **);
|
|
outputSignal = NULL_PTR(MARTe::uint32 *);
|
|
pulseLengthLimit = 360000000u;
|
|
resetRemainingTime = true;
|
|
previousState = 0u;
|
|
}
|
|
|
|
JAModeControlGAM::~JAModeControlGAM() {
|
|
if (inputSignals != NULL_PTR(MARTe::uint32 **)) {
|
|
delete[] inputSignals;
|
|
}
|
|
}
|
|
|
|
bool JAModeControlGAM::Initialise(MARTe::StructuredDataI & data) {
|
|
/* read hard coded on cfg file parameter values by using key name. */
|
|
using namespace MARTe;
|
|
return GAM::Initialise(data);
|
|
}
|
|
|
|
bool JAModeControlGAM::Setup() {
|
|
/* read GAM Input signal */
|
|
using namespace MARTe;
|
|
/* read 4 mode bits and 4 shot length limit values */
|
|
|
|
bool ok = numberOfInputSignals == 11;
|
|
if (ok) {
|
|
uint32 i;
|
|
for (i = 0u; (i < numberOfInputSignals) && (ok); i++) {
|
|
TypeDescriptor inputType = GetSignalType(InputSignals, i);
|
|
ok = inputType == UnsignedInteger32Bit;
|
|
if (!ok) {
|
|
StreamString signalName;
|
|
(void) GetSignalName(InputSignals, i, signalName);
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "InputSignel %s shall be defined as uint32", signalName.Buffer());
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "Eleven input signals shall be defined.");
|
|
}
|
|
if (ok) {
|
|
ok = numberOfOutputSignals == 1;
|
|
if (!ok) {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "One output signal shall be defined.");
|
|
}
|
|
else {
|
|
TypeDescriptor type = GetSignalType(OutputSignals, 0);
|
|
ok = type == UnsignedInteger32Bit;
|
|
if (!ok) {
|
|
StreamString signalName;
|
|
(void) GetSignalName(OutputSignals, 0, signalName);
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "Signal %s shall be defined as uint32", signalName.Buffer());
|
|
}
|
|
}
|
|
}
|
|
if (ok) {
|
|
outputSignal = reinterpret_cast<uint32 *>(GetOutputSignalMemory(0));
|
|
inputSignals = new uint32*[numberOfInputSignals];
|
|
uint32 i;
|
|
for (i = 0u; i < 11; i++) {
|
|
inputSignals[i] = reinterpret_cast<uint32 *>(GetInputSignalMemory(i));
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool JAModeControlGAM::PrepareNextState(const MARTe::char8 * const currentStateName, const MARTe::char8 * const nextStateName) {
|
|
*outputSignal = 0u;
|
|
previousState = 0u;
|
|
resetRemainingTime = true;
|
|
return true;
|
|
}
|
|
|
|
bool JAModeControlGAM::Execute() {
|
|
using namespace MARTe;
|
|
//When RT state goes to RFON state, update the limit.
|
|
if(previousState == 0u && *inputSignals[8] == 1u && resetRemainingTime) {
|
|
rfonTime = *inputSignals[9];
|
|
resetRemainingTime = false;
|
|
pulseLengthLimit = CalcPulseLengthLimit(inputSignals);
|
|
REPORT_ERROR(ErrorManagement::Debug, "Pulse Length was set to Limit:%d", pulseLengthLimit);
|
|
}
|
|
// Turn on the flag during RFON if the pulse legth over the limit.
|
|
if ((*inputSignals[9] - rfonTime <= pulseLengthLimit) && (previousState == 1u)) {
|
|
*outputSignal = 0u;
|
|
return true;
|
|
} else if(*inputSignals[9] == 1u){
|
|
resetRemainingTime = true;
|
|
*outputSignal = 1u;
|
|
}
|
|
|
|
previousState = *inputSignals[8];
|
|
return true;
|
|
}
|
|
|
|
|
|
MARTe::uint32 JAModeControlGAM::CalcPulseLengthLimit(MARTe::uint32 **inputSignals) {
|
|
if (*inputSignals[0] == 1) {
|
|
return *inputSignals[1];
|
|
} else if (*inputSignals[2] == 1) {
|
|
return *inputSignals[3];
|
|
} else if (*inputSignals[4] == 1) {
|
|
return *inputSignals[5];
|
|
} else if (*inputSignals[6] == 1) {
|
|
return *inputSignals[7];
|
|
} else {
|
|
return 3600000000;//us
|
|
}
|
|
}
|
|
|
|
|
|
CLASS_REGISTER(JAModeControlGAM, "1.0")
|