#include "stdafx.h"
#include "example_signal_provider.h"
#ifdef GetObject
#undef GetObject
#endif
#ifdef GetCurrentTime
#undef GetCurrentTime
#endif
tResult cExampleSignalProvider::EnableSignal(ISignalRegistry::tSignalID nSignalID)
{
std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
m_oEnabledSignals.insert(nSignalID);
RETURN_NOERROR;
}
tResult cExampleSignalProvider::DisableSignal(ISignalRegistry::tSignalID nSignalID)
{
std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
m_oEnabledSignals.erase(nSignalID);
RETURN_NOERROR;
}
tResult cExampleSignalProvider::AddSignal(ISignalRegistry::tSignalID& nSignalID,
const cString& strName,
const cString& strDescription,
const cString& strUnit,
tFloat64 nMin,
tFloat64 nMax,
tFloat64 nIncrement
)
{
nSignalID = GetNextSignalID();
RETURN_IF_FAILED(m_pProvider->AddSignal({ nSignalID, strName, strUnit, strDescription, nMin ,nMax }, this));
tSignal sSignal;
sSignal.nIncrement = nIncrement;
sSignal.nValue = 0;
m_mapSignals[nSignalID] = sSignal;
RETURN_NOERROR;
}
tResult cExampleSignalProvider::AddSignalBatch(const cString &strPrefix, tSize nCount)
{
for (tSize i = 0;i < nCount;++i)
{
tSize nNextId = GetNextSignalID();
cString strName = strPrefix + cString::ToStringFromType(nNextId, "%d");
tResult nResult = AddSignal(nNextId, strName,
"desc",
"kmh",
0,
100,
static_cast<tInt>(nNextId));
if (IS_FAILED(nResult))
{
RETURN_ERROR_DESC(ERR_FAILED, "Error creating signal %s", strName.GetPtr());
}
}
RETURN_NOERROR;
}
tSize cExampleSignalProvider::GetNextSignalID()
{
tSize nMaxId = 0;
for (const auto& a : m_mapSignals)
{
if (a.first > nMaxId)
{
nMaxId = a.first;
}
}
return nMaxId + 1;
}
tResult cExampleSignalProvider::RemoveSignal(ISignalRegistry::tSignalID nSignalID)
{
RETURN_IF_FAILED(m_pProvider->RemoveSignal(nSignalID));
m_mapSignals.erase(nSignalID);
RETURN_NOERROR;
}
tResult cExampleSignalProvider::Init()
{
RETURN_IF_FAILED(_runtime->GetObject(m_pRegistry));
RETURN_IF_FAILED(m_pRegistry->CreateProvider("signals", m_pProvider));
RETURN_NOERROR;
}
cExampleSignalProvider::~cExampleSignalProvider()
{
for (const auto &oSignal : m_mapSignals)
{
m_pProvider->RemoveSignal(oSignal.first);
}
m_mapSignals.clear();
}
void cExampleSignalProvider::Process(tTimeStamp tmCurrent)
{
for (const auto& oItem : m_mapSignals)
{
ISignalRegistry::tSignalID nSigID = oItem.first;
m_mapSignals[nSigID].nValue = m_mapSignals[nSigID].nValue + m_mapSignals[nSigID].nIncrement;
std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
if (m_oEnabledSignals.count(oItem.first))
{
m_pProvider->UpdateSignal(oItem.first, { tmCurrent, static_cast<tFloat64>(m_mapSignals[nSigID].nValue) });
}
}
}
#include "stdafx.h"
#include "example_signal_provider.h"
#include "provider_widget.h"
#include "example_signal_provider_srv.h"
ADTF_PLUGIN_VERSION("Demo Signal Provider Service Plugin",
disptb,
DISPTB_VERSION_MAJOR,
DISPTB_VERSION_MINOR,
DISPTB_VERSION_PATCH,
cExampleSignalProviderSrv)
#ifdef GetObject
#undef GetObject
#endif
#ifdef GetCurrentTime
#undef GetCurrentTime
#endif
cExampleSignalProviderSrv::cExampleSignalProviderSrv()
{
m_strTitle = cString("Example Signal Provider");
m_pWidget = nullptr;
_runtime->GetObject(m_pClock);
m_tmProcessPeriod.SetDescription("Signal update rate in [us]");
RegisterPropertyVariable("signal_update_rate", m_tmProcessPeriod);
SetDescription("Use this Service to add custom signals to ADTF Signal Registry and provide signals for Signal Scope and Table View.");
SetHelpLink("$(ADTF_DISPLAY_TOOLBOX_DIR)/doc/displaytoolbox_html/page_signal_provider_example_readme.html");
}
QWidget* cExampleSignalProviderSrv::CreateView()
{
m_pProvider = new cExampleSignalProvider();
if (IS_FAILED(m_pProvider->Init()))
{
LOG_ERROR("Failed to initialize ExampleSignalProvider");
return nullptr;
}
m_pWidget = new cProviderWidget(m_pProvider);
InitView();
return m_pWidget;
}
tVoid cExampleSignalProviderSrv::ReleaseView()
{
delete m_pWidget;
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
#endif
delete m_pProvider;
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
m_oTimer.Stop();
m_pWidget = nullptr;
m_pProvider = nullptr;
}
tResult cExampleSignalProviderSrv::OnIdle()
{
RETURN_IF_POINTER_NULL(m_pWidget);
RETURN_NOERROR;
}
tVoid cExampleSignalProviderSrv::InitTimer()
{
m_oTimer = kernel_timer(adtf::services::IKernel::tTimerClock::ADTF,
adtf::services::IKernel::tSchedulingInfo(),
"example_signal_provider.timer",
m_tmProcessPeriod,
0,
[&]
{
const tTimeStamp tmCurrent = m_pClock->GetStreamTime();
m_pProvider->Process(tmCurrent);
});
}
tResult cExampleSignalProviderSrv::HandleEvent(const IEventSource & , const tVoid * pvEventData)
{
const auto pEventInfo = static_cast<const IReferenceClock::tReferenceClockEvent*>(pvEventData);
if (pEventInfo->nEventId == IReferenceClock::EVENT_TimeResetEnd)
{
InitTimer();
}
else if (pEventInfo->nEventId == IReferenceClock::EVENT_TimeResetBegin)
{
m_oTimer.Stop();
}
RETURN_NOERROR;
}
tResult cExampleSignalProviderSrv::ServiceEvent(tInt nEventId,
tUInt32 ui32Param1,
tUInt32 ui32Param2,
tVoid* pvData,
tInt szData)
{
if (nEventId == IService::SE_ChangeRunLevel)
{
const tADTFRunLevel eLevel = static_cast<tADTFRunLevel>(ui32Param1);
if (ui32Param2 == IRuntime::CRLF_PostIncrementLevel)
{
if (eLevel == tADTFRunLevel::RL_Running)
{
auto pEventSource = ucom_cast<IEventSource*>(m_pClock.Get());
RETURN_IF_POINTER_NULL(pEventSource);
RETURN_IF_FAILED(pEventSource->RegisterEventSink(*this));
InitTimer();
}
}
else if (ui32Param2 == IRuntime::CRLF_PostDecrementLevel)
{
m_oTimer.Stop();
if (eLevel == tADTFRunLevel::RL_Running)
{
auto pEventSource = ucom_cast<IEventSource*>(m_pClock.Get());
RETURN_IF_POINTER_NULL(pEventSource);
RETURN_IF_FAILED(pEventSource->UnregisterEventSink(*this));
}
}
}
return cQtUIService::ServiceEvent(nEventId, ui32Param1, ui32Param2, pvData, szData);
}
tResult cExampleSignalProviderSrv::InitView()
{
RETURN_NOERROR;
}
#include "stdafx.h"
#include "example_signal_provider.h"
#include "provider_widget.h"
cProviderWidget::cProviderWidget(cExampleSignalProvider* pProvider) : m_poProvider(pProvider)
{
CreateAddSignalsDialog();
CreateAddSignalDialog();
CreateRemoveSignalDialog();
m_msgBox = new QMessageBox(this);
auto poGridLayout = new QGridLayout(this);
m_pButtonAdd = new QPushButton(this);
m_pButtonAdd->setText("Add Signal");
m_pButtonRemove = new QPushButton(this);
m_pButtonRemove->setText("Remove Signal");
m_pButtonAddSignals = new QPushButton(this);
m_pButtonAddSignals->setText("Add Signals");
poGridLayout->addWidget(m_pButtonAdd, 0, 0);
poGridLayout->addWidget(m_pButtonRemove, 1, 0);
poGridLayout->addWidget(m_pButtonAddSignals, 2, 0);
setLayout(poGridLayout);
QObject::connect(m_pButtonAdd, &QPushButton::clicked, [this]{ m_pNewSignalDialog->exec(); });
QObject::connect(m_pButtonRemove, &QPushButton::clicked, [this] { m_pRemoveSignalDialog->exec(); });
QObject::connect(m_pButtonAddSignals, &QPushButton::clicked, [this] { m_pNewSignalsDialog->exec(); });
}
cProviderWidget::~cProviderWidget()
{
}
void cProviderWidget::addSignalAccept()
{
tSize nId;
tResult nResult = m_poProvider->AddSignal(nId,
m_lstAddSignalFields.at(0)->text().toStdString().c_str(),
m_lstAddSignalFields.at(1)->text().toStdString().c_str(),
m_lstAddSignalFields.at(2)->text().toStdString().c_str(),
m_lstAddSignalFields.at(3)->text().toFloat(),
m_lstAddSignalFields.at(4)->text().toFloat(),
m_lstAddSignalFields.at(5)->text().toFloat());
m_pNewSignalDialog->hide();
if IS_FAILED(nResult)
{
ShowError("The signal could not be created");
}
ShowMessage(cString::Format("The signal was created with ID '%d'", nId).GetPtr());
}
void cProviderWidget::removeSignalAccept()
{
tSize nSignalID = m_lstRemoveFields.at(0)->text().toInt();
tResult nResult = m_poProvider->RemoveSignal(nSignalID);
m_pRemoveSignalDialog->hide();
if IS_FAILED(nResult)
{
ShowError(nResult.GetDescription());
}
}
void cProviderWidget::addSignalReject()
{
m_pNewSignalDialog->hide();
}
void cProviderWidget::removeSignalReject()
{
m_pRemoveSignalDialog->hide();
}
void cProviderWidget::addSignalsAccept()
{
m_pNewSignalsDialog->hide();
if (m_lstAddSignalsFields.at(0)->text().compare("minMaxBoth")==0)
{
ISignalRegistry::tSignalID nId;
const tResult nResult = m_poProvider->AddSignal(nId, "minMaxBoth", "desc", "kmh",
-std::numeric_limits<tFloat64>::max(),
std::numeric_limits<tFloat64>::max(), 1);
if IS_FAILED(nResult)
{
ShowError("Error creating signal. %s", nResult.GetDescription());
}
return;
}
else
{
tSize nSignalCount = m_lstAddSignalsFields.at(0)->text().toInt();
const tResult nResult = m_poProvider->AddSignalBatch(cString("batch/signal_"), nSignalCount);
if IS_FAILED(nResult)
{
ShowError("Error creating batch signals. %s", nResult.GetDescription());
}
}
}
void cProviderWidget::addSignalsReject()
{
m_pNewSignalsDialog->hide();
}
void cProviderWidget::ShowError(const cString &strMessage, const cString &strTitle)
{
m_msgBox->setText(strMessage.GetPtr());
m_msgBox->setWindowTitle(strTitle.GetPtr());
m_msgBox->show();
}
void cProviderWidget::ShowMessage(const cString & strMessage, const cString & strTitle)
{
ShowError(strMessage, strTitle);
}
void cProviderWidget::CreateAddSignalsDialog()
{
m_pNewSignalsDialog = new QDialog(this);
auto pForm = new QFormLayout(m_pNewSignalsDialog);
pForm->addRow(new QLabel("How many signals do you want to create?"));
const auto lineName = new QLineEdit(m_pNewSignalsDialog);
pForm->addRow("Number of signals:", lineName);
m_lstAddSignalsFields << lineName;
const auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
Qt::Horizontal, m_pNewSignalsDialog);
pForm->addRow(buttonBox);
QObject::connect(buttonBox, &QDialogButtonBox::accepted, this, &cProviderWidget::addSignalsAccept);
QObject::connect(buttonBox, &QDialogButtonBox::rejected, this, &cProviderWidget::addSignalsReject);
}
void cProviderWidget::CreateRemoveSignalDialog()
{
m_pRemoveSignalDialog = new QDialog(this);
auto pForm = new QFormLayout(m_pRemoveSignalDialog);
pForm->addRow(new QLabel("Specify signal to remove"));
const auto lineName = new QLineEdit(m_pRemoveSignalDialog);
pForm->addRow("Signal ID:", lineName);
m_lstRemoveFields << lineName;
const auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
Qt::Horizontal, m_pRemoveSignalDialog);
pForm->addRow(buttonBox);
QObject::connect(buttonBox, &QDialogButtonBox::accepted, this, &cProviderWidget::removeSignalAccept);
QObject::connect(buttonBox, &QDialogButtonBox::rejected, this, &cProviderWidget::removeSignalReject);
}
void cProviderWidget::CreateAddSignalDialog()
{
m_pNewSignalDialog = new QDialog(this);
auto pForm = new QFormLayout(m_pNewSignalDialog);
pForm->addRow(new QLabel("Specify signal to add"));
const auto lineName = new QLineEdit(m_pNewSignalDialog);
const auto lineDescription = new QLineEdit(m_pNewSignalDialog);
const auto lineUnit = new QLineEdit(m_pNewSignalDialog);
const auto lineMin = new QLineEdit(m_pNewSignalDialog);
const auto lineMax = new QLineEdit(m_pNewSignalDialog);
const auto lineIncrement = new QLineEdit(m_pNewSignalDialog);
pForm->addRow("Signal name:", lineName);
pForm->addRow("Signal description:", lineDescription);
pForm->addRow("Signal unit:", lineUnit);
pForm->addRow("Signal min:", lineMin);
pForm->addRow("Signal max:", lineMax);
pForm->addRow("Signal increment:", lineIncrement);
m_lstAddSignalFields << lineName;
m_lstAddSignalFields << lineDescription;
m_lstAddSignalFields << lineUnit;
m_lstAddSignalFields << lineMin;
m_lstAddSignalFields << lineMax;
m_lstAddSignalFields << lineIncrement;
const auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
Qt::Horizontal, m_pNewSignalDialog);
pForm->addRow(buttonBox);
QObject::connect(buttonBox, &QDialogButtonBox::accepted, this, &cProviderWidget::addSignalAccept);
QObject::connect(buttonBox, &QDialogButtonBox::rejected, this, &cProviderWidget::addSignalReject);
}
#include "moc_provider_widget.cpp"