bernardo/MARTe2-isttok
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Testing UART output

Browse Source 
Signed-off-by: Bernardo Carvalho <bernardo.carvalho@tecnico.ulisboa.pt>
This commit is contained in:
Bernardo Brotas de Carvalho
2025-10-18 00:35:57 +01:00
parent ba6c07987e
commit 39176574a5
2 changed files with 497 additions and 483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
DataSources/UARTOutput/UARTOutput.cpp
View File

@@ -30,8 +30,8 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> // for close()
#include <math.h> #include <math.h>
#include <unistd.h> // for close()
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Project header includes */ /* Project header includes */
@@ -48,69 +48,69 @@
/* Method definitions */ /* Method definitions */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
namespace MARTe { namespace MARTe {
const float32 DAC_RANGE = 20.0; const float32 DAC_RANGE = 20.0;
const float32 ATCA_IOP_MAX_DAC_RANGE = 20.0; // const float32 ATCA_IOP_MAX_DAC_RANGE = 20.0;
UARTOutput::UARTOutput() : UARTOutput::UARTOutput() : DataSourceI(), MessageI() {
DataSourceI(), // boardFileDescriptor = -1;
MessageI() { // numberOfDACsEnabled = 0u;
//boardFileDescriptor = -1; // isMaster = 0u;
//numberOfDACsEnabled = 0u; // deviceName = "";
//isMaster = 0u; // boardId = 2u;
//deviceName = "";
//boardId = 2u;
triggerSet = false; triggerSet = false;
uint32 n; uint32 n;
//for (n = 0u; n < ATCA_IOP_MAX_DAC_CHANNELS; n++) { // for (n = 0u; n < ATCA_IOP_MAX_DAC_CHANNELS; n++) {
//dacEnabled[n] = false; // dacEnabled[n] = false;
outputRange = ATCA_IOP_MAX_DAC_RANGE; outputRange = DAC_RANGE;
//} //}
//channelsMemory = NULL_PTR(float32 *); // channelsMemory = NULL_PTR(float32 *);
channelMemory = 0.0;//NULL_PTR(float32 *); channelValue = 0.0; // NULL_PTR(float32 *);
filter = ReferenceT<RegisteredMethodsMessageFilter>(GlobalObjectsDatabase::Instance()->GetStandardHeap()); filter = ReferenceT<RegisteredMethodsMessageFilter>(
GlobalObjectsDatabase::Instance()->GetStandardHeap());
filter->SetDestination(this); filter->SetDestination(this);
ErrorManagement::ErrorType ret = MessageI::InstallMessageFilter(filter); ErrorManagement::ErrorType ret = MessageI::InstallMessageFilter(filter);
if (!ret.ErrorsCleared()) { if (!ret.ErrorsCleared()) {
REPORT_ERROR(ErrorManagement::FatalError, "Failed to install message filters"); REPORT_ERROR(ErrorManagement::FatalError,
} "Failed to install message filters");
} }
}
/*lint -e{1551} the destructor must guarantee that the Timer SingleThreadService is stopped.*/ /*lint -e{1551} the destructor must guarantee that the Timer SingleThreadService
UARTOutput::~UARTOutput() { * is stopped.*/
if (boardFileDescriptor != -1) { UARTOutput::~UARTOutput() {
uint32 statusReg = 0; // REPORT_ERROR(ErrorManagement::Information, " Close Device Status Reg %d,
//REPORT_ERROR(ErrorManagement::Information, " Close Device Status Reg %d, 0x%x", rc, statusReg); // 0x%x", rc, statusReg); close(boardFileDescriptor);
close(boardFileDescriptor); serial.Close();
REPORT_ERROR(ErrorManagement::Information, "Close device %d OK. Status Reg 0x%x,", boardFileDescriptor, statusReg); REPORT_ERROR_PARAMETERS(ErrorManagement::Information, "Close %s OK.",
} portName);
/* /*
if (channelsMemory != NULL_PTR(float32 *)) { if (channelsMemory != NULL_PTR(float32 *)) {
delete[] channelsMemory; delete[] channelsMemory;
} }
*/ */
} }
bool UARTOutput::AllocateMemory() { bool UARTOutput::AllocateMemory() { return true; }
return true;
}
uint32 UARTOutput::GetNumberOfMemoryBuffers() { uint32 UARTOutput::GetNumberOfMemoryBuffers() { return 1u; }
return 1u;
}
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: The memory buffer is independent of the bufferIdx.*/ /*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification:
bool UARTOutput::GetSignalMemoryBuffer(const uint32 signalIdx, const uint32 bufferIdx, void*& signalAddress) { * The memory buffer is independent of the bufferIdx.*/
bool UARTOutput::GetSignalMemoryBuffer(const uint32 signalIdx,
const uint32 bufferIdx,
void *&signalAddress) {
bool ok = (signalIdx < (UART_MAX_CHANNELS)); bool ok = (signalIdx < (UART_MAX_CHANNELS));
if (ok) { if (ok) {
//if (channelsMemory != NULL_PTR(float32 *)) { // if (channelsMemory != NULL_PTR(float32 *)) {
signalAddress = &channelMemory; signalAddress = &channelValue;
//} //}
} }
return ok; return ok;
} }
const char8* UARTOutput::GetBrokerName(StructuredDataI& data, const SignalDirection direction) { const char8 *UARTOutput::GetBrokerName(StructuredDataI &data,
const SignalDirection direction) {
const char8 *brokerName = NULL_PTR(const char8 *); const char8 *brokerName = NULL_PTR(const char8 *);
if (direction == OutputSignals) { if (direction == OutputSignals) {
uint32 trigger = 0u; uint32 trigger = 0u;
@@ -121,22 +121,25 @@ namespace MARTe {
if (trigger == 1u) { if (trigger == 1u) {
brokerName = "MemoryMapSynchronisedOutputBroker"; brokerName = "MemoryMapSynchronisedOutputBroker";
triggerSet = true; triggerSet = true;
} } else {
else {
brokerName = "MemoryMapOutputBroker"; brokerName = "MemoryMapOutputBroker";
} }
} } else {
else { REPORT_ERROR(ErrorManagement::ParametersError,
REPORT_ERROR(ErrorManagement::ParametersError, "DataSource not compatible with InputSignals"); "DataSource not compatible with InputSignals");
} }
return brokerName; return brokerName;
} }
bool UARTOutput::GetInputBrokers(ReferenceContainer& inputBrokers, const char8* const functionName, void* const gamMemPtr) { bool UARTOutput::GetInputBrokers(ReferenceContainer &inputBrokers,
const char8 *const functionName,
void *const gamMemPtr) {
return false; return false;
} }
bool UARTOutput::GetOutputBrokers(ReferenceContainer& outputBrokers, const char8* const functionName, void* const gamMemPtr) { bool UARTOutput::GetOutputBrokers(ReferenceContainer &outputBrokers,
//Check if there is a Trigger signal for this function. const char8 *const functionName,
void *const gamMemPtr) {
// Check if there is a Trigger signal for this function.
uint32 functionIdx = 0u; uint32 functionIdx = 0u;
uint32 nOfFunctionSignals = 0u; uint32 nOfFunctionSignals = 0u;
uint32 i; uint32 i;
@@ -144,7 +147,8 @@ namespace MARTe {
bool ok = GetFunctionIndex(functionIdx, functionName); bool ok = GetFunctionIndex(functionIdx, functionName);
if (ok) { if (ok) {
ok = GetFunctionNumberOfSignals(OutputSignals, functionIdx, nOfFunctionSignals); ok = GetFunctionNumberOfSignals(OutputSignals, functionIdx,
nOfFunctionSignals);
} }
uint32 trigger = 0u; uint32 trigger = 0u;
for (i = 0u; (i < nOfFunctionSignals) && (ok) && (!triggerGAM); i++) { for (i = 0u; (i < nOfFunctionSignals) && (ok) && (!triggerGAM); i++) {
@@ -152,7 +156,8 @@ namespace MARTe {
triggerGAM = (trigger == 1u); triggerGAM = (trigger == 1u);
} }
if ((ok) && (triggerGAM)) { if ((ok) && (triggerGAM)) {
ReferenceT<MemoryMapSynchronisedOutputBroker> broker("MemoryMapSynchronisedOutputBroker"); ReferenceT<MemoryMapSynchronisedOutputBroker> broker(
"MemoryMapSynchronisedOutputBroker");
ok = broker.IsValid(); ok = broker.IsValid();
if (ok) { if (ok) {
@@ -161,21 +166,23 @@ namespace MARTe {
if (ok) { if (ok) {
ok = outputBrokers.Insert(broker); ok = outputBrokers.Insert(broker);
} }
//Must also add the signals which are not triggering but that belong to the same GAM... // Must also add the signals which are not triggering but that belong to the
// same GAM...
if (ok) { if (ok) {
if (nOfFunctionSignals > 1u) { if (nOfFunctionSignals > 1u) {
ReferenceT<MemoryMapOutputBroker> brokerNotSync("MemoryMapOutputBroker"); ReferenceT<MemoryMapOutputBroker> brokerNotSync(
"MemoryMapOutputBroker");
ok = brokerNotSync.IsValid(); ok = brokerNotSync.IsValid();
if (ok) { if (ok) {
ok = brokerNotSync->Init(OutputSignals, *this, functionName, gamMemPtr); ok = brokerNotSync->Init(OutputSignals, *this, functionName,
gamMemPtr);
} }
if (ok) { if (ok) {
ok = outputBrokers.Insert(brokerNotSync); ok = outputBrokers.Insert(brokerNotSync);
} }
} }
} }
} } else {
else {
ReferenceT<MemoryMapOutputBroker> brokerNotSync("MemoryMapOutputBroker"); ReferenceT<MemoryMapOutputBroker> brokerNotSync("MemoryMapOutputBroker");
ok = brokerNotSync.IsValid(); ok = brokerNotSync.IsValid();
if (ok) { if (ok) {
@@ -186,33 +193,38 @@ namespace MARTe {
} }
} }
return ok; return ok;
} }
/*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification: the counter and the timer are always reset irrespectively of the states being changed.*/ /*lint -e{715} [MISRA C++ Rule 0-1-11], [MISRA C++ Rule 0-1-12]. Justification:
bool UARTOutput::PrepareNextState(const char8* const currentStateName, const char8* const nextStateName) { * the counter and the timer are always reset irrespectively of the states being
* changed.*/
bool UARTOutput::PrepareNextState(const char8 *const currentStateName,
const char8 *const nextStateName) {
return true; return true;
} }
bool UARTOutput::Initialise(StructuredDataI& data) { bool UARTOutput::Initialise(StructuredDataI &data) {
bool ok = DataSourceI::Initialise(data); bool ok = DataSourceI::Initialise(data);
StreamString portName; // StreamString portName;
if (ok) { if (ok) {
ok = data.Read("PortName", portName); ok = data.Read("PortName", portName);
if (ok) { if (ok) {
REPORT_ERROR(ErrorManagement::Information, "The port name is set to %s", portName.Buffer()); REPORT_ERROR_PARAMETERS(ErrorManagement::Information,
} "The port name is set to %s", portName.Buffer());
else { } else {
REPORT_ERROR(ErrorManagement::ParametersError, "The port name property shall be set"); REPORT_ERROR(ErrorManagement::ParametersError,
"The port name property shall be set");
} }
} }
uint32 baudRate = 0u; uint32 baudRate = 0u;
if (ok) { if (ok) {
ok = data.Read("BaudRate", baudRate); ok = data.Read("BaudRate", baudRate);
if (ok) { if (ok) {
REPORT_ERROR(ErrorManagement::Information, "The baud rate is set to %d", baudRate); REPORT_ERROR_PARAMETERS(ErrorManagement::Information,
} "The baud rate is set to %d", baudRate);
else { } else {
REPORT_ERROR(ErrorManagement::ParametersError, "The baud rate property shall be set"); REPORT_ERROR(ErrorManagement::ParametersError,
"The baud rate property shall be set");
} }
} }
if (ok) { if (ok) {
@@ -220,30 +232,39 @@ namespace MARTe {
timeout = 1000u; timeout = 1000u;
} }
} }
/*
if (ok) { if (ok) {
ok = data.Read("SerialTimeout", serialTimeout); ok = data.Read("SerialTimeout", serialTimeout);
if (ok) { if (ok) {
REPORT_ERROR(ErrorManagement::Information, "The serial timeout is set to %d", serialTimeout); REPORT_ERROR(ErrorManagement::Information, "The serial timeout is set to
%d", serialTimeout);
} }
else { else {
REPORT_ERROR(ErrorManagement::ParametersError, "The serial timeout property shall be set"); REPORT_ERROR(ErrorManagement::ParametersError, "The serial timeout
property shall be set");
} }
} }
*/
if (ok) { if (ok) {
ok = serial.SetSpeed(baudRate); ok = serial.SetSpeed(baudRate);
} }
if (ok) { if (ok) {
ok = serial.Open(portName.Buffer()); ok = serial.Open(portName.Buffer());
} }
if (!ok) {
REPORT_ERROR_PARAMETERS(ErrorManagement::ParametersError,
"The port %s Not opened.", portName);
}
//Get individual signal parameters // Get individual signal parameters
uint32 i = 0u; uint32 i = 0u;
if (ok) { if (ok) {
ok = data.MoveRelative("Signals"); ok = data.MoveRelative("Signals");
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Could not move to the Signals section"); REPORT_ERROR(ErrorManagement::ParametersError,
"Could not move to the Signals section");
} }
//Do not allow to add signals in run-time // Do not allow to add signals in run-time
if (ok) { if (ok) {
ok = signalsDatabase.MoveRelative("Signals"); ok = signalsDatabase.MoveRelative("Signals");
} }
@@ -253,26 +274,28 @@ namespace MARTe {
if (ok) { if (ok) {
ok = signalsDatabase.MoveToAncestor(1u); ok = signalsDatabase.MoveToAncestor(1u);
} }
// while ((i < ATCA_IOP_MAX_DAC_CHANNELS) && (ok)) { // while ((i < ATCA_IOP_MAX_DAC_CHANNELS) && (ok)) {
if (data.MoveRelative(data.GetChildName(0))) { if (data.MoveRelative(data.GetChildName(0))) {
//uint32 channelId; // uint32 channelId;
float32 range; float64 range;
ok = data.Read("OutputRange", range); ok = data.Read("OutputRange", range);
if (ok) { if (ok) {
//if (data.Read("OutputRange", range)) { // if (data.Read("OutputRange", range)) {
ok = (range > 0.0) && (range <= ATCA_IOP_MAX_DAC_RANGE); ok = (range > 0.0) && (range <= DAC_RANGE);
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Invalid OutputRange specified."); REPORT_ERROR(ErrorManagement::ParametersError,
"Invalid OutputRange specified.");
} }
if (ok) { if (ok) {
outputRange = range; outputRange = range;
REPORT_ERROR_PARAMETERS(ErrorManagement::Information, " Parameter DAC Output Range %f", range); REPORT_ERROR_PARAMETERS(ErrorManagement::Information,
//dacEnabled[i] = true; " Parameter DAC Output Range %f", range);
//numberOfDACsEnabled++; // dacEnabled[i] = true;
// numberOfDACsEnabled++;
} }
} } else {
else { REPORT_ERROR(ErrorManagement::ParametersError,
REPORT_ERROR(ErrorManagement::ParametersError, "The OutputRange shall be specified."); "The OutputRange shall be specified.");
} }
if (ok) { if (ok) {
ok = data.MoveToAncestor(1u); ok = data.MoveToAncestor(1u);
@@ -282,15 +305,17 @@ namespace MARTe {
if (ok) { if (ok) {
ok = data.MoveToAncestor(1u); ok = data.MoveToAncestor(1u);
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "Could not move to the parent section"); REPORT_ERROR(ErrorManagement::ParametersError,
"Could not move to the parent section");
} }
} }
//REPORT_ERROR_PARAMETERS(ErrorManagement::Information, "numberOfDACsEnabled %d", numberOfDACsEnabled); // REPORT_ERROR_PARAMETERS(ErrorManagement::Information, "numberOfDACsEnabled
// %d", numberOfDACsEnabled);
return ok; return ok;
} }
bool UARTOutput::SetConfiguredDatabase(StructuredDataI& data) { bool UARTOutput::SetConfiguredDatabase(StructuredDataI &data) {
uint32 i; uint32 i;
bool ok = DataSourceI::SetConfiguredDatabase(data); bool ok = DataSourceI::SetConfiguredDatabase(data);
@@ -298,20 +323,22 @@ namespace MARTe {
ok = triggerSet; ok = triggerSet;
} }
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "At least one Trigger signal shall be set."); REPORT_ERROR(ErrorManagement::ParametersError,
"At least one Trigger signal shall be set.");
} }
if (ok) { if (ok) {
//for (i = 0u; (i < numberOfDACsEnabled) && (ok); i++) { // for (i = 0u; (i < numberOfDACsEnabled) && (ok); i++) {
ok = (GetSignalType(0u) == Float32Bit); ok = (GetSignalType(0u) == Float32Bit);
//} //}
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "All the DAC signals shall be of type Float32Bit"); REPORT_ERROR(ErrorManagement::ParametersError,
"All the DAC signals shall be of type Float32Bit");
} }
} }
uint32 nOfFunctions = GetNumberOfFunctions(); uint32 nOfFunctions = GetNumberOfFunctions();
uint32 functionIdx; uint32 functionIdx;
//Check that the number of samples for all the signals is one // Check that the number of samples for all the signals is one
for (functionIdx = 0u; (functionIdx < nOfFunctions) && (ok); functionIdx++) { for (functionIdx = 0u; (functionIdx < nOfFunctions) && (ok); functionIdx++) {
uint32 nOfSignals = 0u; uint32 nOfSignals = 0u;
ok = GetFunctionNumberOfSignals(OutputSignals, functionIdx, nOfSignals); ok = GetFunctionNumberOfSignals(OutputSignals, functionIdx, nOfSignals);
@@ -323,65 +350,48 @@ namespace MARTe {
ok = (nSamples == 1u); ok = (nSamples == 1u);
} }
if (!ok) { if (!ok) {
REPORT_ERROR(ErrorManagement::ParametersError, "The number of samples shall be exactly one"); REPORT_ERROR(ErrorManagement::ParametersError,
"The number of samples shall be exactly one");
} }
} }
} }
StreamString fullDeviceName;
//Configure the board
if (ok) {
ok = fullDeviceName.Printf("%s_dac_%d", deviceName.Buffer(), boardId);
//ok = fullDeviceName.Printf("%s", deviceName.Buffer());
}
if (ok) {
ok = fullDeviceName.Seek(0LLU);
}
if (ok) {
boardFileDescriptor = open(fullDeviceName.Buffer(), O_RDWR);
ok = (boardFileDescriptor > -1);
if (!ok) {
REPORT_ERROR_PARAMETERS(ErrorManagement::ParametersError, "Could not open device %s", fullDeviceName);
}
else
REPORT_ERROR_PARAMETERS(ErrorManagement::Information, "Open device %s OK", fullDeviceName);
}
if (ok) {
//Allocate memory
//channelsMemory = new float32[ATCA_IOP_MAX_DAC_CHANNELS];
}
return ok; return ok;
} }
bool UARTOutput::Synchronise() {
bool UARTOutput::Synchronise() {
uint32 i; uint32 i;
int32 w = 24; int32 w = 24;
bool ok = true; bool ok = true;
//if (channelsMemory != NULL_PTR(float32 *)) { char8 text[] = "ola";
// if (channelsMemory != NULL_PTR(float32 *)) {
// value = channelsMemory[0] / DAC_RANGE; // value = channelsMemory[0] / DAC_RANGE;
//for (i = 0u; (i < 2u) && (ok); i++) { // for (i = 0u; (i < numberOfDACsEnabled ) && (ok); i++) {
//for (i = 0u; (i < numberOfDACsEnabled ) && (ok); i++) { int32 ser_value = channelValue / outputRange * 1000000.0;
float32 value = channelMemory / outputRange; REPORT_ERROR_PARAMETERS(ErrorManagement::Information,
//w = SetDacReg(i, value); "Synchronise called. value: %f, %d", channelValue,
write(boardFileDescriptor, &w, 4); ser_value);
// value = channelsMemory[1] / DAC_RANGE; // w = SetDacReg(i, value);
//value = channelsMemory[1] / DAC_RANGE * pow(2,17); char8 *data = reinterpret_cast<char8 *>(&ser_value);
// w = SetDacReg(1, value); serial.Write(data, sizeof(int32));
//w = 0x000FFFFF & static_cast<uint32>(value); // serial.Write(text, 4);
// write(boardFileDescriptor, &w, 4); // write(boardFileDescriptor, &w, 4);
//REPORT_ERROR(ErrorManagement::Information, " Writing DAC 0 0x%x", w); // value = channelsMemory[1] / DAC_RANGE;
// value = channelsMemory[1] / DAC_RANGE * pow(2,17);
// w = SetDacReg(1, value);
// w = 0x000FFFFF & static_cast<uint32>(value);
// write(boardFileDescriptor, &w, 4);
// REPORT_ERROR(ErrorManagement::Information, " Writing DAC 0 0x%x", w);
/* /*
w = dacValues[i]; w = dacValues[i];
} }
*/ */
return ok; return ok;
} }
/* /*
int32 UARTOutput::SetDacReg(uint32 channel, float32 val) const { int32 UARTOutput::SetDacReg(uint32 channel, float32 val) const {
if (val > 1.0) if (val > 1.0)
val = 1.0; val = 1.0;
@@ -397,6 +407,6 @@ namespace MARTe {
return dacReg; return dacReg;
} }
*/ */
CLASS_REGISTER(UARTOutput, "1.0") CLASS_REGISTER(UARTOutput, "1.0")
} } // namespace MARTe
// vim: syntax=cpp ts=2 sw=2 sts=2 sr et // vim: syntax=cpp ts=2 sw=2 sts=2 sr et

120
DataSources/UARTOutput/UARTOutput.h
View File

@@ -37,42 +37,44 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#include "BasicUART.h" #include "BasicUART.h"
#include "DataSourceI.h" #include "DataSourceI.h"
#include "EventSem.h"
#include "EmbeddedServiceMethodBinderI.h" #include "EmbeddedServiceMethodBinderI.h"
#include "SingleThreadService.h" #include "EventSem.h"
#include "MessageI.h" #include "MessageI.h"
#include "RegisteredMethodsMessageFilter.h" #include "RegisteredMethodsMessageFilter.h"
#include "SingleThreadService.h"
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Class declaration */ /* Class declaration */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
namespace MARTe { namespace MARTe {
/** /**
* The number of signals * The number of signals
*/ */
const uint32 ATCA_IOP_N_DACs = 2u; // const uint32 ATCA_IOP_N_DACs = 2u;
const uint32 UART_MAX_CHANNELS = 1u; const uint32 UART_MAX_CHANNELS = 1u;
/** /**
* @brief A DataSource which provides an analogue output interface to the ATCA IOP boards. * @brief A DataSource which provides an analogue output interface to the ATCA
IOP boards.
* @details The configuration syntax is (names are only given as an example): * @details The configuration syntax is (names are only given as an example):
* *
* <pre> * <pre>
* +AtcaIop_0_DAC = { * +AtcaIop_UartOut = {
* Class = AtcaIop::UARTOutput * Class = AtcaIop::UARTOutput
* DeviceName = "/dev/atca_v6_dac_2" //Mandatory * PortName = "/dev/ttyUSB0" //Name of the UART port, Mandatory
* PortName = "/dev/ttyUSB0" //Name of the UART port
* BaudRate = 115200 //BAUD UART rate * BaudRate = 115200 //BAUD UART rate
* Timeout = 200000 //Maximum time to wait for data * //Timeout = 200000 //Maximum time to wait for data
* CPUMask = 8 //Affinity of the CPU of where to read data from * CPUMask = 8 //Affinity of the CPU of where to read data from
* Signals = { * Signals = {
* DAC0_0 = { * SerialOut = {
* Type = float32 //Mandatory. Only type that is supported. * Type = float32//Mandatory. Only type that is supported.
* OutputRange = 10.0 //Mandatory. The channel Module Output Range in volt. * OutputRange = 10.0 //Mandatory. The channel Module Output Range
* //OutputPolarity = Bipolar //Optional. Possible values: Bipolar, Unipolar. Default value Unipolar. in volt.
* //OutputPolarity = Bipolar //Optional. Possible values: Bipolar,
Unipolar. Default value Unipolar.
* } * }
* Packet = { //Actual data to write * Packet = { //Actual data to write
* Type = uint8 * Type = uint8
@@ -82,10 +84,12 @@ namespace MARTe {
* } * }
* } * }
* </pre> * </pre>
* Note that at least one of the GAMs writing to this DataSource must have set one of the signals with Trigger=1 (which forces the writing of all the signals to the DAC). * Note that at least one of the GAMs writing to this DataSource must have set
one of the signals with Trigger=1 (which forces the writing of all the signals
to the DAC).
*/ */
class UARTOutput: public DataSourceI, public MessageI { class UARTOutput : public DataSourceI, public MessageI {
public: public:
CLASS_REGISTER_DECLARATION() CLASS_REGISTER_DECLARATION()
/** /**
* @brief Default constructor * @brief Default constructor
@@ -93,7 +97,7 @@ namespace MARTe {
* Counter = 0 * Counter = 0
* Time = 0 * Time = 0
*/ */
UARTOutput (); UARTOutput();
/** /**
* @brief Destructor. Stops the EmbeddedThread. * @brief Destructor. Stops the EmbeddedThread.
@@ -119,67 +123,71 @@ namespace MARTe {
const uint32 bufferIdx, const uint32 bufferIdx,
void *&signalAddress); void *&signalAddress);
/** /**
* @brief See DataSourceI::GetNumberOfMemoryBuffers. * @brief See DataSourceI::GetNumberOfMemoryBuffers.
* @details Only OutputSignals are supported. * @details Only OutputSignals are supported.
* @return MemoryMapSynchronisedOutputBroker if Trigger == 1 for any of the signals, MemoryMapOutputBroker otherwise. * @return MemoryMapSynchronisedOutputBroker if Trigger == 1 for any of the
* signals, MemoryMapOutputBroker otherwise.
*/ */
virtual const char8 *GetBrokerName(StructuredDataI &data, const SignalDirection direction); virtual const char8 *GetBrokerName(StructuredDataI &data,
const SignalDirection direction);
/** /**
* @brief See DataSourceI::GetInputBrokers. * @brief See DataSourceI::GetInputBrokers.
* @return false. * @return false.
*/ */
virtual bool GetInputBrokers(ReferenceContainer &inputBrokers, virtual bool GetInputBrokers(ReferenceContainer &inputBrokers,
const char8* const functionName, const char8 *const functionName,
void * const gamMemPtr); void *const gamMemPtr);
/** /**
* @brief See DataSourceI::GetOutputBrokers. * @brief See DataSourceI::GetOutputBrokers.
* @details If the functionName is one of the functions which requested a Trigger, * @details If the functionName is one of the functions which requested a
* it adds a MemoryMapSynchronisedOutputBroker instance to the outputBrokers, * Trigger, it adds a MemoryMapSynchronisedOutputBroker instance to the
* otherwise it adds a MemoryMapOutputBroker instance to the outputBrokers. * outputBrokers, otherwise it adds a MemoryMapOutputBroker instance to the
* outputBrokers.
* @param[out] outputBrokers where the BrokerI instances have to be added to. * @param[out] outputBrokers where the BrokerI instances have to be added to.
* @param[in] functionName name of the function being queried. * @param[in] functionName name of the function being queried.
* @param[in] gamMemPtr the GAM memory where the signals will be read from. * @param[in] gamMemPtr the GAM memory where the signals will be read from.
* @return true if the outputBrokers can be successfully configured. * @return true if the outputBrokers can be successfully configured.
*/ */
virtual bool GetOutputBrokers(ReferenceContainer &outputBrokers, virtual bool GetOutputBrokers(ReferenceContainer &outputBrokers,
const char8* const functionName, const char8 *const functionName,
void * const gamMemPtr); void *const gamMemPtr);
/** /**
* @brief See StatefulI::PrepareNextState. * @brief See StatefulI::PrepareNextState.
* @details NOOP. * @details NOOP.
* @return true. * @return true.
*/ */
virtual bool PrepareNextState(const char8 * const currentStateName, virtual bool PrepareNextState(const char8 *const currentStateName,
const char8 * const nextStateName); const char8 *const nextStateName);
/** /**
* @brief Loads and verifies the configuration parameters detailed in the class description. * @brief Loads and verifies the configuration parameters detailed in the
* @return true if all the mandatory parameters are correctly specified and if the specified optional parameters have valid values. * class description.
* @return true if all the mandatory parameters are correctly specified and if
* the specified optional parameters have valid values.
*/ */
virtual bool Initialise(StructuredDataI & data); virtual bool Initialise(StructuredDataI &data);
/** /**
* @brief Final verification of all the parameters and setup of the board configuration. * @brief Final verification of all the parameters and setup of the board
* @details This method verifies that all the parameters (e.g. number of samples) requested by the GAMs interacting with this DataSource * configuration.
* are valid and consistent with the board parameters set during the initialisation phase. * @details This method verifies that all the parameters (e.g. number of
* In particular the following conditions shall be met: * samples) requested by the GAMs interacting with this DataSource are valid
* - At least one triggering signal was requested by a GAM (with the property Trigger = 1) * and consistent with the board parameters set during the initialisation
* phase. In particular the following conditions shall be met:
* - At least one triggering signal was requested by a GAM (with the property
* Trigger = 1)
* - All the DAC channels have type float32. * - All the DAC channels have type float32.
* - The number of samples of all the DAC channels is exactly one. * - The number of samples of all the DAC channels is exactly one.
* @return true if all the parameters are valid and consistent with the board parameters and if the board can be successfully configured with * @return true if all the parameters are valid and consistent with the board
* these parameters. * parameters and if the board can be successfully configured with these
* parameters.
*/ */
virtual bool SetConfiguredDatabase(StructuredDataI & data); virtual bool SetConfiguredDatabase(StructuredDataI &data);
/** /**
* @details Writes the value of all the DAC channels to the board. * @details Writes the value of all the DAC channels to the board.
@@ -187,12 +195,11 @@ namespace MARTe {
*/ */
virtual bool Synchronise(); virtual bool Synchronise();
private:
private:
/** /**
* The board device name * The board device name
*/ */
StreamString deviceName; StreamString portName;
/** /**
* The board identifier * The board identifier
*/ */
@@ -200,7 +207,7 @@ namespace MARTe {
/** /**
* The board file descriptor * The board file descriptor
*/ */
int32 boardFileDescriptor; // int32 boardFileDescriptor;
/** /**
* The UART interface. * The UART interface.
*/ */
@@ -209,23 +216,21 @@ namespace MARTe {
/** /**
* Timeout to wait for data to be available. * Timeout to wait for data to be available.
*/ */
uint32 serialTimeout; // uint32 serialTimeout;
/** /**
*/ */
uint32 timeout; uint32 timeout;
/** /**
* DAC values * DAC values
*/ */
int32 dacValues[ATCA_IOP_N_DACs]; // int32 dacValues[ATCA_IOP_N_DACs];
/** /**
* The signal memory * The signal memory
*/ */
float32 channelMemory; float32 channelValue;
/** /**
* The DACs that are enabled * The DACs that are enabled
@@ -252,10 +257,9 @@ namespace MARTe {
*/ */
bool triggerSet; bool triggerSet;
//int32 SetDacReg(uint32 channel, float32 val) const; // int32 SetDacReg(uint32 channel, float32 val) const;
};
}; } // namespace MARTe
}
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Inline method definitions */ /* Inline method definitions */