367 lines
14 KiB
C++
367 lines
14 KiB
C++
/**
|
|
* @file JAEPICSCAInput.cpp
|
|
* @brief Source file for class JAEPICSCAInput
|
|
* @date 20/04/2017
|
|
* @author Andre Neto
|
|
*
|
|
* @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 JAEPICSCAInput (public, protected, and private). Be aware that some
|
|
* methods, such as those inline could be defined on the header file, instead.
|
|
*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Standard header includes */
|
|
/*---------------------------------------------------------------------------*/
|
|
#include "JAEPICSCAInput.h"
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Project header includes */
|
|
/*---------------------------------------------------------------------------*/
|
|
#include "AdvancedErrorManagement.h"
|
|
#include "MemoryMapInputBroker.h"
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Static definitions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
namespace MARTe {
|
|
/**
|
|
* @brief Callback function for the ca_create_subscription. Single point of access which
|
|
* delegates the events to the corresponding JAEPICSPV instance.
|
|
*/
|
|
static FastPollingMutexSem eventCallbackFastMux;
|
|
/*lint -e{1746} function must match required prototype and thus cannot be changed to constant reference.*/
|
|
void JAEPICSCAInputEventCallback(struct event_handler_args const args) {
|
|
(void) eventCallbackFastMux.FastLock();
|
|
PVWrapper *pv = static_cast<PVWrapper *>(args.usr);
|
|
if (pv != NULL_PTR(PVWrapper *)) {
|
|
(void) MemoryOperationsHelper::Copy(pv->memory, args.dbr, pv->memorySize);
|
|
}
|
|
eventCallbackFastMux.FastUnLock();
|
|
}
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Method definitions */
|
|
/*---------------------------------------------------------------------------*/
|
|
namespace MARTe {
|
|
JAEPICSCAInput::JAEPICSCAInput() :
|
|
DataSourceI(), EmbeddedServiceMethodBinderI(), executor(*this) {
|
|
pvs = NULL_PTR(PVWrapper *);
|
|
stackSize = THREADS_DEFAULT_STACKSIZE * 4u;
|
|
cpuMask = 0xffu;
|
|
eventCallbackFastMux.Create();
|
|
}
|
|
|
|
/*lint -e{1551} must stop the SingleThreadService in the destructor.*/
|
|
JAEPICSCAInput::~JAEPICSCAInput() {
|
|
if (!executor.Stop()) {
|
|
if (!executor.Stop()) {
|
|
REPORT_ERROR(ErrorManagement::FatalError, "Could not stop SingleThreadService.");
|
|
}
|
|
}
|
|
(void) eventCallbackFastMux.FastLock();
|
|
uint32 nOfSignals = GetNumberOfSignals();
|
|
if (pvs != NULL_PTR(PVWrapper *)) {
|
|
uint32 n;
|
|
for (n = 0u; (n < nOfSignals); n++) {
|
|
if (pvs[n].memory != NULL_PTR(void *)) {
|
|
GlobalObjectsDatabase::Instance()->GetStandardHeap()->Free(pvs[n].memory);
|
|
}
|
|
}
|
|
delete[] pvs;
|
|
}
|
|
eventCallbackFastMux.FastUnLock();
|
|
}
|
|
|
|
bool JAEPICSCAInput::Initialise(StructuredDataI & data) {
|
|
bool ok = DataSourceI::Initialise(data);
|
|
if (ok) {
|
|
if (!data.Read("CPUs", cpuMask)) {
|
|
REPORT_ERROR(ErrorManagement::Information, "No CPUs defined. Using default = %d", cpuMask);
|
|
}
|
|
if (!data.Read("StackSize", stackSize)) {
|
|
REPORT_ERROR(ErrorManagement::Information, "No StackSize defined. Using default = %d", stackSize);
|
|
}
|
|
executor.SetStackSize(stackSize);
|
|
executor.SetCPUMask(cpuMask);
|
|
}
|
|
if (ok) {
|
|
ok = data.MoveRelative("Signals");
|
|
if (!ok) {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "Could not move to the Signals section");
|
|
}
|
|
if (ok) {
|
|
ok = data.Copy(originalSignalInformation);
|
|
}
|
|
if (ok) {
|
|
ok = originalSignalInformation.MoveToRoot();
|
|
}
|
|
//Do not allow to add signals in run-time
|
|
if (ok) {
|
|
ok = signalsDatabase.MoveRelative("Signals");
|
|
}
|
|
if (ok) {
|
|
ok = signalsDatabase.Write("Locked", 1u);
|
|
}
|
|
if (ok) {
|
|
ok = signalsDatabase.MoveToAncestor(1u);
|
|
}
|
|
}
|
|
if (ok) {
|
|
ok = data.MoveToAncestor(1u);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool JAEPICSCAInput::SetConfiguredDatabase(StructuredDataI & data) {
|
|
bool ok = DataSourceI::SetConfiguredDatabase(data);
|
|
//Check the signal index of the timing signal.
|
|
uint32 nOfSignals = GetNumberOfSignals();
|
|
if (ok) {
|
|
ok = (nOfSignals > 0u);
|
|
if (!ok) {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "At least one signal shall be defined");
|
|
}
|
|
}
|
|
if (ok) {
|
|
//Do not allow samples
|
|
uint32 functionNumberOfSignals = 0u;
|
|
uint32 n;
|
|
if (GetFunctionNumberOfSignals(InputSignals, 0u, functionNumberOfSignals)) {
|
|
for (n = 0u; (n < functionNumberOfSignals) && (ok); n++) {
|
|
uint32 nSamples;
|
|
ok = GetFunctionSignalSamples(InputSignals, 0u, n, nSamples);
|
|
if (ok) {
|
|
ok = (nSamples == 1u);
|
|
}
|
|
if (!ok) {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "The number of samples shall be exactly 1");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (ok) {
|
|
pvs = new PVWrapper[nOfSignals];
|
|
uint32 n;
|
|
for (n = 0u; (n < nOfSignals); n++) {
|
|
pvs[n].memory = NULL_PTR(void *);
|
|
}
|
|
for (n = 0u; (n < nOfSignals) && (ok); n++) {
|
|
//Note that the RealTimeApplicationConfigurationBuilder is allowed to change the order of the signals w.r.t. to the originalSignalInformation
|
|
StreamString orderedSignalName;
|
|
ok = GetSignalName(n, orderedSignalName);
|
|
if (ok) {
|
|
//Have to mix and match between the original setting of the DataSource signal
|
|
//and the ones which are later added by the RealTimeApplicationConfigurationBuilder
|
|
ok = originalSignalInformation.MoveRelative(orderedSignalName.Buffer());
|
|
}
|
|
StreamString pvName;
|
|
if (ok) {
|
|
ok = originalSignalInformation.Read("PVName", pvName);
|
|
if (!ok) {
|
|
uint32 nn = n;
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "No PVName specified for signal at index %d", nn);
|
|
}
|
|
}
|
|
TypeDescriptor td = GetSignalType(n);
|
|
if (ok) {
|
|
(void) StringHelper::CopyN(&pvs[n].pvName[0], pvName.Buffer(), PV_NAME_MAX_SIZE);
|
|
if (td == CharString) {
|
|
pvs[n].pvType = DBR_STRING;
|
|
}
|
|
else if (td == Character8Bit) {
|
|
pvs[n].pvType = DBR_STRING;
|
|
}
|
|
else if (td == SignedInteger8Bit) {
|
|
pvs[n].pvType = DBR_CHAR;
|
|
}
|
|
else if (td == UnsignedInteger8Bit) {
|
|
pvs[n].pvType = DBR_CHAR;
|
|
}
|
|
else if (td == SignedInteger16Bit) {
|
|
pvs[n].pvType = DBR_SHORT;
|
|
}
|
|
else if (td == UnsignedInteger16Bit) {
|
|
pvs[n].pvType = DBR_SHORT;
|
|
}
|
|
else if (td == SignedInteger32Bit) {
|
|
pvs[n].pvType = DBR_LONG;
|
|
}
|
|
else if (td == UnsignedInteger32Bit) {
|
|
pvs[n].pvType = DBR_LONG;
|
|
}
|
|
else if (td == Float32Bit) {
|
|
pvs[n].pvType = DBR_FLOAT;
|
|
}
|
|
else if (td == Float64Bit) {
|
|
pvs[n].pvType = DBR_DOUBLE;
|
|
}
|
|
else {
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "Type %s is not supported", TypeDescriptor::GetTypeNameFromTypeDescriptor(td));
|
|
ok = false;
|
|
}
|
|
}
|
|
uint32 numberOfElements = 1u;
|
|
if (ok) {
|
|
ok = GetSignalNumberOfElements(n, numberOfElements);
|
|
}
|
|
if (ok) {
|
|
if (pvs[n].pvType == DBR_STRING) {
|
|
ok = (numberOfElements == 40u);
|
|
}
|
|
if (!ok) {
|
|
//Could support arrays of strings with multiples of char8[40]
|
|
REPORT_ERROR(ErrorManagement::ParametersError, "Strings shall be defined with 40 elements char8[40]. Arrays of strings are not currently supported");
|
|
}
|
|
}
|
|
if (ok) {
|
|
pvs[n].numberOfElements = numberOfElements;
|
|
}
|
|
if (ok) {
|
|
pvs[n].memorySize = td.numberOfBits;
|
|
pvs[n].memorySize /= 8u;
|
|
pvs[n].memorySize *= numberOfElements;
|
|
pvs[n].memory = GlobalObjectsDatabase::Instance()->GetStandardHeap()->Malloc(pvs[n].memorySize);
|
|
ok = originalSignalInformation.MoveToAncestor(1u);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ok) {
|
|
ok = (executor.Start() == ErrorManagement::NoError);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool JAEPICSCAInput::AllocateMemory() {
|
|
return true;
|
|
}
|
|
|
|
uint32 JAEPICSCAInput::GetNumberOfMemoryBuffers() {
|
|
return 1u;
|
|
}
|
|
|
|
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: The signalAddress is independent of the bufferIdx.*/
|
|
bool JAEPICSCAInput::GetSignalMemoryBuffer(const uint32 signalIdx, const uint32 bufferIdx, void*& signalAddress) {
|
|
bool ok = (pvs != NULL_PTR(PVWrapper *));
|
|
if (ok) {
|
|
ok = (signalIdx < GetNumberOfSignals());
|
|
}
|
|
if (ok) {
|
|
//lint -e{613} pvs cannot as otherwise ok would be false
|
|
signalAddress = pvs[signalIdx].memory;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: The brokerName only depends on the direction */
|
|
const char8* JAEPICSCAInput::GetBrokerName(StructuredDataI& data, const SignalDirection direction) {
|
|
const char8* brokerName = "";
|
|
if (direction == InputSignals) {
|
|
brokerName = "MemoryMapInputBroker";
|
|
}
|
|
return brokerName;
|
|
}
|
|
|
|
bool JAEPICSCAInput::GetInputBrokers(ReferenceContainer& inputBrokers, const char8* const functionName, void* const gamMemPtr) {
|
|
ReferenceT<MemoryMapInputBroker> broker("MemoryMapInputBroker");
|
|
bool ok = broker->Init(InputSignals, *this, functionName, gamMemPtr);
|
|
if (ok) {
|
|
ok = inputBrokers.Insert(broker);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: OutputBrokers are not supported. Function returns false irrespectively of the parameters.*/
|
|
bool JAEPICSCAInput::GetOutputBrokers(ReferenceContainer& outputBrokers, const char8* const functionName, void* const gamMemPtr) {
|
|
return false;
|
|
}
|
|
|
|
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: NOOP at StateChange, independently of the function parameters.*/
|
|
bool JAEPICSCAInput::PrepareNextState(const char8* const currentStateName, const char8* const nextStateName) {
|
|
return true;
|
|
}
|
|
|
|
ErrorManagement::ErrorType JAEPICSCAInput::Execute(ExecutionInfo& info) {
|
|
ErrorManagement::ErrorType err = ErrorManagement::NoError;
|
|
if (info.GetStage() == ExecutionInfo::StartupStage) {
|
|
(void) eventCallbackFastMux.FastLock();
|
|
/*lint -e{9130} -e{835} -e{845} -e{747} Several false positives. lint is getting confused here for some reason.*/
|
|
if (ca_context_create(ca_enable_preemptive_callback) != ECA_NORMAL) {
|
|
err = ErrorManagement::FatalError;
|
|
REPORT_ERROR(err, "ca_enable_preemptive_callback failed");
|
|
}
|
|
|
|
uint32 n;
|
|
uint32 nOfSignals = GetNumberOfSignals();
|
|
if (pvs != NULL_PTR(PVWrapper *)) {
|
|
for (n = 0u; (n < nOfSignals); n++) {
|
|
/*lint -e{9130} -e{835} -e{845} -e{747} Several false positives. lint is getting confused here for some reason.*/
|
|
if (ca_create_channel(&pvs[n].pvName[0], NULL_PTR(caCh *), NULL_PTR(void *), 20u, &pvs[n].pvChid) != ECA_NORMAL) {
|
|
err = ErrorManagement::FatalError;
|
|
REPORT_ERROR(err, "ca_create_channel failed for PV with name %s", pvs[n].pvName);
|
|
}
|
|
if (err.ErrorsCleared()) {
|
|
/*lint -e{9130} -e{835} -e{845} -e{747} Several false positives. lint is getting confused here for some reason.*/
|
|
if (ca_create_subscription(pvs[n].pvType, pvs[n].numberOfElements, pvs[n].pvChid, DBE_VALUE, &JAEPICSCAInputEventCallback, &pvs[n],
|
|
&pvs[n].pvEvid) != ECA_NORMAL) {
|
|
err = ErrorManagement::FatalError;
|
|
REPORT_ERROR(err, "ca_create_subscription failed for PV %s", pvs[n].pvName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
eventCallbackFastMux.FastUnLock();
|
|
}
|
|
else if (info.GetStage() != ExecutionInfo::BadTerminationStage) {
|
|
Sleep::Sec(1.0F);
|
|
}
|
|
else {
|
|
(void) eventCallbackFastMux.FastLock();
|
|
uint32 n;
|
|
uint32 nOfSignals = GetNumberOfSignals();
|
|
if (pvs != NULL_PTR(PVWrapper *)) {
|
|
for (n = 0u; (n < nOfSignals); n++) {
|
|
(void) ca_clear_subscription(pvs[n].pvEvid);
|
|
(void) ca_clear_event(pvs[n].pvEvid);
|
|
(void) ca_clear_channel(pvs[n].pvChid);
|
|
}
|
|
}
|
|
ca_detach_context();
|
|
ca_context_destroy();
|
|
eventCallbackFastMux.FastUnLock();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
uint32 JAEPICSCAInput::GetStackSize() const {
|
|
return stackSize;
|
|
}
|
|
|
|
uint32 JAEPICSCAInput::GetCPUMask() const {
|
|
return cpuMask;
|
|
}
|
|
|
|
bool JAEPICSCAInput::Synchronise() {
|
|
return false;
|
|
}
|
|
|
|
CLASS_REGISTER(JAEPICSCAInput, "1.0")
|
|
|
|
}
|
|
|