martino/ec-gn-ja-pcf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed types and feedback

Browse Source
This commit is contained in:
Martino Ferrari
2026-02-06 18:15:42 +01:00
parent 872baa1dc2
commit cdd700bf4e
2 changed files with 235 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

455
EC-GN-JA-PCF-IN/src/main/c++/GAMs/JARampupGAM/JARampupGAM.cpp
View File

@@ -41,255 +41,268 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
JARampupGAM::JARampupGAM() : GAM() { JARampupGAM::JARampupGAM() : GAM() {
current_setpoint = NULL_PTR(MARTe::float32 *); target_value = NULL_PTR(MARTe::float32 *);
target_value = NULL_PTR(MARTe::float32 *); rampup_time = NULL_PTR(MARTe::float32 *);
rampup_time = NULL_PTR(MARTe::float32 *); start = NULL_PTR(MARTe::uint32 *);
start = NULL_PTR(MARTe::uint32 *); standby = NULL_PTR(MARTe::uint8 *);
standby = NULL_PTR(MARTe::uint32 *); isAuto = NULL_PTR(MARTe::uint32 *);
isAuto = NULL_PTR(MARTe::uint32 *); FHPS_PrePro = NULL_PTR(MARTe::float32 *);
FHPS_PrePro = NULL_PTR(MARTe::float32 *);
output = NULL_PTR(MARTe::float32 *); output = NULL_PTR(MARTe::float32 *);
state = NULL_PTR(MARTe::uint32 *); state = NULL_PTR(MARTe::uint32 *);
rampup_rate = 0.0f; rampup_rate = 0.0f;
inRampup = false; inRampup = false;
resetFlag = true; resetFlag = true;
inWaitHVON = false; inWaitHVON = false;
inWaitStandby = false; inWaitStandby = false;
} }
JARampupGAM::~JARampupGAM() { JARampupGAM::~JARampupGAM() {}
}
bool JARampupGAM::Initialise(MARTe::StructuredDataI & data) { bool JARampupGAM::Initialise(MARTe::StructuredDataI &data) {
using namespace MARTe; using namespace MARTe;
return GAM::Initialise(data); return GAM::Initialise(data);
} }
bool JARampupGAM::Setup() { bool JARampupGAM::Setup() {
using namespace MARTe; using namespace MARTe;
bool ok = (numberOfInputSignals == 7u); bool ok = (numberOfInputSignals == 6u);
if (ok) { if (ok) {
ok = (numberOfOutputSignals == 2u); ok = (numberOfOutputSignals == 2u);
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Two output signals shall be defined."); REPORT_ERROR(ErrorManagement::ParametersError,
} "Two output signals shall be defined.");
} }
else { } else {
REPORT_ERROR(ErrorManagement::ParametersError, "Six input signals shall be defined."); REPORT_ERROR(ErrorManagement::ParametersError,
} "Six input signals shall be defined.");
uint32 currentspvIndex; }
uint32 targetvIndex; uint32 currentspvIndex;
uint32 timeIndex; uint32 targetvIndex;
uint32 startIndex; uint32 timeIndex;
uint32 standbyIndex; uint32 startIndex;
uint32 isAutoIndex; uint32 standbyIndex;
uint32 fhpsPreProIndex; uint32 isAutoIndex;
uint32 fhpsPreProIndex;
if (ok) { if (ok) {
StreamString signalName = "Currspv"; StreamString signalName = "Currspv";
ok = GetSignalIndex(InputSignals, currentspvIndex, signalName.Buffer()); ok = GetSignalIndex(InputSignals, currentspvIndex, signalName.Buffer());
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Currspv input signal shall be defined."); REPORT_ERROR(ErrorManagement::ParametersError,
} "Currspv input signal shall be defined.");
else { } else {
TypeDescriptor inputType = GetSignalType(InputSignals, currentspvIndex); TypeDescriptor inputType = GetSignalType(InputSignals, currentspvIndex);
ok = (inputType == Float32Bit); ok = (inputType == Float32Bit);
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Signal Currspv shall be defined as float32."); REPORT_ERROR(ErrorManagement::ParametersError,
} "Signal Currspv shall be defined as float32.");
} }
} }
if (ok) { }
StreamString signalName = "Targetv"; if (ok) {
ok = GetSignalIndex(InputSignals, targetvIndex, signalName.Buffer()); StreamString signalName = "Targetv";
if (!ok) { ok = GetSignalIndex(InputSignals, targetvIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "Targetv input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "Targetv input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, targetvIndex); } else {
ok = (inputType == Float32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, targetvIndex);
if (!ok) { ok = (inputType == Float32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "Signal Targetv shall be defined as float32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "Signal Targetv shall be defined as float32.");
}
} }
if (ok) { }
StreamString signalName = "Time"; if (ok) {
ok = GetSignalIndex(InputSignals, timeIndex, signalName.Buffer()); StreamString signalName = "Time";
if (!ok) { ok = GetSignalIndex(InputSignals, timeIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "Time input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "Time input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, timeIndex); } else {
ok = (inputType == Float32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, timeIndex);
if (!ok) { ok = (inputType == Float32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "Signal Time shall be defined as float32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "Signal Time shall be defined as float32.");
}
} }
if (ok) { }
StreamString signalName = "Start"; if (ok) {
ok = GetSignalIndex(InputSignals, startIndex, signalName.Buffer()); StreamString signalName = "Start";
if (!ok) { ok = GetSignalIndex(InputSignals, startIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "Start input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "Start input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, startIndex); } else {
ok = (inputType == UnsignedInteger32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, startIndex);
if (!ok) { ok = (inputType == UnsignedInteger32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "Start shall be defined as uint32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "Start shall be defined as uint32.");
}
} }
if (ok) { }
StreamString signalName = "PLC_STANDBY"; if (ok) {
ok = GetSignalIndex(InputSignals, standbyIndex, signalName.Buffer()); StreamString signalName = "PLC_STANDBY";
if (!ok) { ok = GetSignalIndex(InputSignals, standbyIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "PLC_STANDBY input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "PLC_STANDBY input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, standbyIndex); } else {
ok = (inputType == UnsignedInteger32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, standbyIndex);
if (!ok) { ok = (inputType == UnsignedInteger8Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "PLC_STANDBY shall be defined as uint32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "PLC_STANDBY shall be defined as uint8.");
}
} }
if (ok) { }
StreamString signalName = "MANUAL_AUTO"; if (ok) {
ok = GetSignalIndex(InputSignals, isAutoIndex, signalName.Buffer()); StreamString signalName = "MANUAL_AUTO";
if (!ok) { ok = GetSignalIndex(InputSignals, isAutoIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "MANUAL_AUTO input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "MANUAL_AUTO input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, isAutoIndex); } else {
ok = (inputType == UnsignedInteger32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, isAutoIndex);
if (!ok) { ok = (inputType == UnsignedInteger32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "MANUAL_AUTO shall be defined as uint32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "MANUAL_AUTO shall be defined as uint32.");
}
} }
if (ok) { }
StreamString signalName = "FHPS_PrePro"; if (ok) {
ok = GetSignalIndex(InputSignals, fhpsPreProIndex, signalName.Buffer()); StreamString signalName = "FHPS_PrePro";
if (!ok) { ok = GetSignalIndex(InputSignals, fhpsPreProIndex, signalName.Buffer());
REPORT_ERROR(ErrorManagement::ParametersError, "FHPS_PrePro input signal shall be defined."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
else { "FHPS_PrePro input signal shall be defined.");
TypeDescriptor inputType = GetSignalType(InputSignals, fhpsPreProIndex); } else {
ok = (inputType == Float32Bit); TypeDescriptor inputType = GetSignalType(InputSignals, fhpsPreProIndex);
if (!ok) { ok = (inputType == Float32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "Signal FHPS_PrePro shall be defined as float32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
} "Signal FHPS_PrePro shall be defined as float32.");
}
} }
}
if (ok) { if (ok) {
TypeDescriptor inputType = GetSignalType(OutputSignals, 0); TypeDescriptor inputType = GetSignalType(OutputSignals, 0);
ok = (inputType == Float32Bit); ok = (inputType == Float32Bit);
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Signal Output shall be defined as float32."); REPORT_ERROR(ErrorManagement::ParametersError,
} "Signal Output shall be defined as float32.");
} }
if (ok) { }
TypeDescriptor inputType = GetSignalType(OutputSignals, 1); if (ok) {
ok = (inputType == UnsignedInteger32Bit); TypeDescriptor inputType = GetSignalType(OutputSignals, 1);
if (!ok) { ok = (inputType == UnsignedInteger32Bit);
REPORT_ERROR(ErrorManagement::ParametersError, "Signal state shall be defined as float32."); if (!ok) {
} REPORT_ERROR(ErrorManagement::ParametersError,
"Signal state shall be defined as float32.");
} }
}
if (ok) { if (ok) {
current_setpoint = reinterpret_cast<float32 *>(GetInputSignalMemory(currentspvIndex)); target_value =
target_value = reinterpret_cast<float32 *>(GetInputSignalMemory(targetvIndex)); reinterpret_cast<float32 *>(GetInputSignalMemory(targetvIndex));
rampup_time = reinterpret_cast<float32 *>(GetInputSignalMemory(timeIndex)); rampup_time = reinterpret_cast<float32 *>(GetInputSignalMemory(timeIndex));
start = reinterpret_cast<uint32 *>(GetInputSignalMemory(startIndex)); start = reinterpret_cast<uint32 *>(GetInputSignalMemory(startIndex));
standby = reinterpret_cast<uint32 *>(GetInputSignalMemory(standbyIndex)); standby = reinterpret_cast<uint8 *>(GetInputSignalMemory(standbyIndex));
isAuto = reinterpret_cast<uint32 *>(GetInputSignalMemory(isAutoIndex)); isAuto = reinterpret_cast<uint32 *>(GetInputSignalMemory(isAutoIndex));
FHPS_PrePro = reinterpret_cast<float32 *>(GetInputSignalMemory(fhpsPreProIndex)); FHPS_PrePro =
reinterpret_cast<float32 *>(GetInputSignalMemory(fhpsPreProIndex));
output = reinterpret_cast<float32 *>(GetOutputSignalMemory(0));
state = reinterpret_cast<uint32 *>(GetOutputSignalMemory(1)); output = reinterpret_cast<float32 *>(GetOutputSignalMemory(0));
} state = reinterpret_cast<uint32 *>(GetOutputSignalMemory(1));
return ok; }
return ok;
} }
bool JARampupGAM::PrepareNextState(const MARTe::char8 * const currentStateName, const MARTe::char8 * const nextStateName){ bool JARampupGAM::PrepareNextState(const MARTe::char8 *const currentStateName,
if(strcmp(nextStateName, "WaitHVON_PREP")==0 || strcmp(nextStateName, "WaitHVON_SDN_PREP")==0 || const MARTe::char8 *const nextStateName) {
strcmp(nextStateName, "WaitHVON")==0 || strcmp(nextStateName, "WaitHVON_SDN")==0){ if (strcmp(nextStateName, "WaitHVON_PREP") == 0 ||
inWaitHVON = true; strcmp(nextStateName, "WaitHVON_SDN_PREP") == 0 ||
inWaitStandby = false; strcmp(nextStateName, "WaitHVON") == 0 ||
} else{ strcmp(nextStateName, "WaitHVON_SDN") == 0) {
inWaitHVON = false; inWaitHVON = true;
if(strcmp(nextStateName,"WaitStandby")==0 ){ inWaitStandby = false;
inWaitStandby = true; } else {
} else { inWaitHVON = false;
inWaitStandby = false; if (strcmp(nextStateName, "WaitStandby") == 0) {
} inWaitStandby = true;
} else {
inWaitStandby = false;
} }
return true; }
return true;
} }
bool JARampupGAM::Execute() { bool JARampupGAM::Execute() {
using namespace MARTe; using namespace MARTe;
if(!inWaitHVON){ float32 current_setpoint = *output;
if (*target_value <= 0.0f || *standby == 0u) { if (!inWaitHVON) {
*output = 0.0f; if (*target_value <= 0.0f || *standby == 0u) {
rampup_rate = 0.0f; *output = 0.0f;
if(*target_value <= 0.0f){ rampup_rate = 0.0f;
*state = 3u; if (*target_value <= 0.0f) {
} else { *state = 3u;
*state = 0u; } else {
} *state = 0u;
return true; }
} return true;
if(*start == 1u && *isAuto==0u){ //isAuto = 1.Manual, 0.auto-rampup.
inRampup = true;
resetFlag = true;
*output = 0.0f; //Enable if it should start always zero.
}
// Calcrate new rampup rate.
if(*rampup_time != 0 && resetFlag == true){
rampup_rate = (*target_value - *current_setpoint) / *rampup_time/1000.0f; // Volt/msec
resetFlag = false;
}
// Update Parameter
if(*standby == 1u ){
if(*isAuto == 1u){
if (inWaitStandby){
*output = *target_value;
} else{
*output = *FHPS_PrePro;
}
//*output = *target_value;
*state = 0u;
return true;
}
else if (inRampup){
if (*output + rampup_rate < *target_value && *rampup_time != 0){
*output = *output + rampup_rate;
*state = 1u;
} else {
*output = *target_value;
*state = 2u;
inRampup = false;
}
}
}
return true;
} else {
if(*isAuto == 0){
*output = *FHPS_PrePro;
} else{
*output = *target_value;
}
return true;
} }
if (*start == 1u && *isAuto == 0u) { // isAuto = 1.Manual, 0.auto-rampup.
inRampup = true;
resetFlag = true;
*output = 0.0f; // Enable if it should start always zero.
}
// Calcrate new rampup rate.
if (*rampup_time != 0 && resetFlag == true) {
rampup_rate = (*target_value - current_setpoint) / *rampup_time /
1000.0f; // Volt/msec
resetFlag = false;
}
// Update Parameter
if (*standby == 1u) {
if (*isAuto == 1u) {
if (inWaitStandby) {
*output = *target_value;
} else {
*output = *FHPS_PrePro;
}
//*output = *target_value;
*state = 0u;
return true;
} else if (inRampup) {
if (*output + rampup_rate < *target_value && *rampup_time != 0) {
*output = *output + rampup_rate;
*state = 1u;
} else {
*output = *target_value;
*state = 2u;
inRampup = false;
}
}
}
return true;
} else {
if (*isAuto == 0) {
*output = *FHPS_PrePro;
} else {
*output = *target_value;
}
return true;
}
} }
CLASS_REGISTER(JARampupGAM, "1.0") CLASS_REGISTER(JARampupGAM, "1.0")

4
EC-GN-JA-PCF-IN/src/main/c++/GAMs/JARampupGAM/JARampupGAM.h
View File

@@ -97,8 +97,6 @@ public:
const MARTe::char8 * const nextStateName); const MARTe::char8 * const nextStateName);
private: private:
// Input signal containing current current_setpoint
MARTe::float32 *current_setpoint;
// Input signal containing the frequency of the waveform. // Input signal containing the frequency of the waveform.
MARTe::float32 *target_value; MARTe::float32 *target_value;
@@ -110,7 +108,7 @@ private:
MARTe::uint32 *start; MARTe::uint32 *start;
// Input signal PLC_STANDBY // Input signal PLC_STANDBY
MARTe::uint32 *standby; MARTe::uint8 *standby;
// MANUAL AUTO button // MANUAL AUTO button
MARTe::uint32 *isAuto; MARTe::uint32 *isAuto;