Merge story/release-validation-scope

Bring the validation-scope line (in-tree Jenkins CI copy, lcov coverage
wiring, step-by-step release-scope README, TetraIF unit tests, the
LogView runtime icon/resource fix, Dockerfile, rpmbuild and the
new_docker_build.sh driver with the DEB output path) on top of the
XmlPatterns branch pruned to the Release 2 scope.

Conflict policy:
- Out-of-scope targets/modules: keep the prune (deletion wins).
- In-scope files that validation had deleted: restored from
  story/release-2-cleanup (the Release 2 closure, with the
  pruned-module guards).
- In-scope sources carrying migration work: XmlPatterns versions
  (Qt XmlPatterns rework on QDomDocument, DDS member and logger
  fixes, first-build fixes).
- Scope-aware CMakeLists (top level, PluginInterfaces, LtsWidgets)
  and .envrc: story/release-2-cleanup / ours versions.
This commit is contained in:
berrux-dev committed 2026-11-16 18:49:14 +01:00
commit cfe15c72c4
521 files changed
+37159 -36635

No files matched your search

@@ -1,88 +1,87 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
//
// Implementation of the Class AppComponent
// **************************************************************************
#include "AppComponent.hpp"
namespace N_AppComponent
{
int32_t AppComponent::create(NGL::Settings *settings)
{
for (IAppComponent *c : m_Childs)
c->create(settings);
return 0;
}
int32_t AppComponent::destroy()
{
for (IAppComponent *c : m_Childs)
c->destroy();
return 0;
}
int32_t AppComponent::init()
{
for (IAppComponent *c : m_Childs)
c->init();
return 0;
}
int32_t AppComponent::deinit()
{
for (IAppComponent *c : m_Childs)
c->deinit();
return 0;
}
int32_t AppComponent::start()
{
for (IAppComponent *c : m_Childs)
c->start();
return 0;
}
int32_t AppComponent::stop()
{
for (IAppComponent *c : m_Childs)
c->stop();
return 0;
}
void AppComponent::addChild(IAppComponent *a_child, const QString &a_name)
{
if (a_child)
int32_t AppComponent::create(NGL::Settings *settings)
{
a_child->setName(a_name);
m_Childs.push_back(a_child);
for (IAppComponent *c : m_Childs)
c->create(settings);
return 0;
}
}
IAppComponent *AppComponent::getChild(const QString &a_name)
{
for (IAppComponent *c : m_Childs)
int32_t AppComponent::destroy()
{
if (a_name == c->getName())
return c;
for (IAppComponent *c : m_Childs)
c->destroy();
return 0;
}
return nullptr;
}
}
int32_t AppComponent::init()
{
for (IAppComponent *c : m_Childs)
c->init();
return 0;
}
int32_t AppComponent::deinit()
{
for (IAppComponent *c : m_Childs)
c->deinit();
return 0;
}
int32_t AppComponent::start()
{
for (IAppComponent *c : m_Childs)
c->start();
return 0;
}
int32_t AppComponent::stop()
{
for (IAppComponent *c : m_Childs)
c->stop();
return 0;
}
void AppComponent::addChild(IAppComponent *a_child, const QString &a_name)
{
if (a_child)
{
a_child->setName(a_name);
m_Childs.push_back(a_child);
}
}
IAppComponent *AppComponent::getChild(const QString &a_name)
{
for (IAppComponent *c : m_Childs)
{
if (a_name == c->getName())
return c;
}
return nullptr;
}
} // namespace N_AppComponent
@@ -1,14 +1,14 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
//
// Implementation of the Class AppComponent
// **************************************************************************
#pragma once
@@ -16,30 +16,32 @@
#include "IAppComponent.hpp"
#include "prtcnvlib_export.h"
namespace NGL {
class Settings;
namespace NGL
{
class Settings;
}
namespace N_AppComponent
{
class PRTCNVLIB_EXPORT AppComponent : public N_AppComponent::IAppComponent
{
public:
AppComponent() = default;
~AppComponent() = default;
class PRTCNVLIB_EXPORT AppComponent : public N_AppComponent::IAppComponent
{
public:
AppComponent() = default;
~AppComponent() = default;
int32_t create(NGL::Settings *settings) override;
int32_t deinit() override;
int32_t destroy() override;
int32_t init() override;
int32_t start() override;
int32_t stop() override;
int32_t create(NGL::Settings *settings) override;
int32_t deinit() override;
int32_t destroy() override;
int32_t init() override;
int32_t start() override;
int32_t stop() override;
protected:
void addChild(IAppComponent* a_child, const QString& a_name = QString());
IAppComponent* getChild(const QString& a_name);
private:
std::vector<IAppComponent*> m_Childs;
};
protected:
void addChild(IAppComponent *a_child, const QString &a_name = QString());
IAppComponent *getChild(const QString &a_name);
private:
std::vector<IAppComponent *> m_Childs;
};
}
@@ -5,10 +5,6 @@
#
#ADD_SUBDIRECTORY(TetraTestServer)
ADD_SUBDIRECTORY(LastTest)
ADD_SUBDIRECTORY(LastTestAuswertung)
SET(PrtCnv_SRCS
logger.h
logger.cpp
@@ -63,6 +59,7 @@ NGL_TARGET_LINK_LIBRARIES(PrtCnvLib
)
NGL_TARGET_INCLUDE_DIRECTORIES(PrtCnvLib
PUBLIC
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../
)
@@ -1,20 +1,21 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
//
// Implementation of the Class IAppComponent
// **************************************************************************
#pragma once
#include <QtCore/QString>
namespace NGL {
namespace NGL
{
class Settings;
}
@@ -44,14 +45,9 @@ namespace N_AppComponent
virtual int32_t stop() = 0;
inline const QString& getName() const
{
return m_Name;
}
inline void setName(const QString& newVal)
{
m_Name = newVal;
}
inline const QString &getName() const { return m_Name; }
inline void setName(const QString &newVal) { m_Name = newVal; }
protected:
QString m_Name;
};
@@ -13,7 +13,7 @@ int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
// Check alle 30 Sekunden
NGL::NGLLoggerBootstrap::createNGLRootLogger("log4cxx_tetra.props", false);
NGL::INGLLogger &logger(NGL::NGLLoggerBootstrap::getNGLRootLogger());
@@ -41,9 +41,7 @@ int main(int argc, char **argv)
TetraIF::usage();
}
const QString mode = args[3].toLower();
if (mode != QLatin1String("listen") &&
mode != QLatin1String("send_random") &&
mode != QLatin1String("send_file"))
if (mode != QLatin1String("listen") && mode != QLatin1String("send_random") && mode != QLatin1String("send_file"))
{
ERROR_LOG(logger) << "Invalid mode " << args[3];
TetraIF::usage();
@@ -1,5 +1,9 @@
/**
* Tetra-Interface für Lasttest
* $Id$
* $HeadURL$
* $Author$
*/
#pragma once
#include <QtCore/QObject>
#include <QtNetwork/QHostAddress>
@@ -28,8 +32,9 @@ protected Q_SLOTS:
void onReadyRead();
void onError(QAbstractSocket::SocketError);
void onSendData();
protected:
NGL::INGLLogger &m_logger;
NGL::INGLLogger &m_logger;
void doInitialLogin();
void handleReceivedTelegram(const QByteArray &data);
void handleRegisterRsp(const uint8_t a_registrationStatus);
@@ -10,10 +10,9 @@
#include <QtCore/QTimer>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
{
ui->setupUi(this);
init();
@@ -22,10 +21,10 @@ MainWindow::MainWindow(QWidget *parent) :
MainWindow::~MainWindow()
{
m_files.clear();
//m_logfile.~QString();
//delete m_logfileList;
// m_logZeiten.~QString();
//delete ui;
}
void MainWindow::changeEvent(QEvent *e)
@@ -33,20 +32,20 @@ void MainWindow::changeEvent(QEvent *e)
QMainWindow::changeEvent(e);
switch (e->type())
{
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void MainWindow::init()
{
//Connect Signals & Slots
connect(ui->pushButtonOrdnerFinden, &QPushButton::clicked, this, &MainWindow::slot_findFolder);
connect(ui->pushButtonAnalysieren, &QPushButton::clicked, this, &MainWindow::slot_analysieren);
//m_logfileList = new QList<LogfileInfo>();
ui->progressBar->setValue(0);
ui->labelResult->setText(QString());
QIntValidator intVal;
@@ -57,13 +56,19 @@ void MainWindow::init()
void MainWindow::slot_findFolder()
{
//hier liegt der fehler???, der erst beim zweiten mal ausführen des Dateibrowsers in erscheinung tritt
/*QFileDialog dial(this);
dial.setFileMode(QFileDialog::Directory);
dial.setViewMode(QFileDialog::List);
QStringList files;
if (dial.exec())
files = dial.selectedFiles();
QString name = files.at(0);
//testblabla
*/
QString name = QFileDialog::getExistingDirectory(this, tr("Choose folder"), QDir::homePath(), QFileDialog::DontResolveSymlinks);
ui->lineEditOrdner->setText(name);
ui->labelResult->setText(QString());
}
void MainWindow::slot_analysieren()
@@ -74,7 +79,7 @@ void MainWindow::slot_analysieren()
ISSI = QLatin1String("1");
m_logfileList.clear();
//alle DAteien in dem Ordner finden
QDir folder(ui->lineEditOrdner->text());
m_files = folder.entryList();
folder.~QDir();
@@ -83,7 +88,7 @@ void MainWindow::slot_analysieren()
const QString issitext = ISSI + QLatin1String("-1");
for (int i = 0; i < m_files.count(); i++)
{
//Dateinamen entfernen, die keine Payload-Logs sind
QString name = m_files[i];
if (name.contains(paytext))
{
@@ -136,7 +141,7 @@ void MainWindow::readFiles()
QFile file(filename);
if (file.open(QIODevice::ReadOnly))
{
//Datei auslesen
QByteArray ar = file.read(150);
file.close();
if (ar.size() > 36)
@@ -144,26 +149,25 @@ void MainWindow::readFiles()
QString issi = getISSI(ar);
QByteArray bytes = ar;
//Laufende Nummer
bytes.remove(0, 34);
bytes.remove(2, 150);
uint nr = bytes[0] & 255;
nr *= 256;
nr += bytes[1] & 255;
//BytesNr 34+35
//Sendezeit
bytes = ar;
bytes.remove(0, 30);
bytes.remove(4, 150);
const QByteArray test = bytes.toHex();
qint64 zeit = test.toLongLong(nullptr, 16);
//Byte 30-33
const QDateTime timeStart(QDateTime::fromMSecsSinceEpoch(zeit * 1000));
writeToLogfile(issi, timeStart, getTimestamp(m_files[j]), m_files[j], nr);
writeLogZeiten(timeStart, getTimestamp(m_files[j]), issi);
}
}
file.close();
@@ -172,9 +176,8 @@ void MainWindow::readFiles()
val *= (j + 1);
val += 20;
ui->progressBar->setValue(int(val));
// ui->progressBar->repaint();
}
}
void MainWindow::openLogfile(const QString &folder, int count)
@@ -196,14 +199,9 @@ void MainWindow::openLogfile(const QString &folder, int count)
file.write("ISSI;Sending Time ; Receiving Time\n");
file.close();
}
}
void MainWindow::writeToLogfile(const QString &issi,
const QDateTime &timestamp,
const QString &filename,
uint lfdNr,
const QString &bytes)
void MainWindow::writeToLogfile(const QString &issi, const QDateTime &timestamp, const QString &filename, uint lfdNr, const QString &bytes)
{
QString text = issi;
text += QLatin1String(": ");
@@ -228,11 +226,7 @@ void MainWindow::writeToLogfile(const QString &issi,
m_logfileList.append(info);
}
void MainWindow::writeToLogfile(const QString &issi,
const QDateTime &sendeZeit,
const QDateTime &timestamp,
const QString &filename,
uint lfdNr)
void MainWindow::writeToLogfile(const QString &issi, const QDateTime &sendeZeit, const QDateTime &timestamp, const QString &filename, uint lfdNr)
{
QString text = issi;
text += QLatin1String(": ");
@@ -262,7 +256,7 @@ QDateTime MainWindow::getTimestamp(const QString &filename) const
const auto list1 = filename.split(QLatin1Char('-'));
if (list1.size() < 2)
return {};
const QString &fn = list1.at(1);
const auto list2 = fn.split(QLatin1Char('.'));
auto str = list2.at(0);
@@ -273,11 +267,11 @@ QDateTime MainWindow::getTimestamp(const QString &filename) const
QString MainWindow::getISSI(QByteArray ar)
{
//wird nur für die "2-timestamp"-Dateien verwendet
ar.remove(0, 5);
ar.remove(4, 200);
QByteArray issi = ar.toHex();
if (ar.size() == 4)
{
if (ar[2] == '\0' && ar[3] == '\0')
@@ -292,7 +286,6 @@ QString MainWindow::getISSI(QByteArray ar)
hex[i] = c - '0';
else if (c >= 'a' && c <= 'f')
hex[i] = c - 'a' + 10;
}
int sum = 0;
sum += hex[1];
@@ -310,7 +303,7 @@ QString MainWindow::getISSI(QByteArray ar)
int MainWindow::auswerten()
{
//Logfile vorbereiten
QFile f(m_logfile);
if (!f.open(QIODevice::Append | QIODevice::Text))
return -1;
@@ -319,7 +312,7 @@ int MainWindow::auswerten()
issis.reserve(100);
for (int i = 0; i < m_logfileList.count(); i++)
{
//Unterschiedliche Issis finden
issis += m_logfileList.at(i).issi;
}
ui->progressBar->setValue(94);
@@ -329,7 +322,7 @@ int MainWindow::auswerten()
int i = 0;
for (const QString &issi : std::as_const(issis))
{
//für jede Issi die Nummern in timestampMap einlesen --> geordnet nach Zeitstempel
numList.clear();
for (int j = 0; j < m_logfileList.count(); j++)
{
@@ -344,7 +337,7 @@ int MainWindow::auswerten()
f.write(text);
fehlcount += fehlendeNumsEintragen(numList, f);
// delete numList;
double val = 5;
val /= issis.count();
@@ -360,7 +353,7 @@ int MainWindow::auswerten()
int MainWindow::fehlendeNumsEintragen(const QVector<uint> &numList, QFile &f)
{
//schreibt die fehlenden Nummern in das Logfile und die GUI
QVector<uint> fehlendeNums = getFehlendeNums(numList);
QByteArray text = QByteArray::number(fehlendeNums.count());
text += " lost messages\n";
@@ -370,7 +363,7 @@ int MainWindow::fehlendeNumsEintragen(const QVector<uint> &numList, QFile &f)
text += QByteArray::number(fehlendeNums.at(j));
text += ", ";
}
// delete fehlendeNums;
text += ")\n";
f.write(text);
@@ -380,13 +373,13 @@ int MainWindow::fehlendeNumsEintragen(const QVector<uint> &numList, QFile &f)
QVector<uint> MainWindow::getFehlendeNums(const QVector<uint> &numsDurchgang)
{
//ermittelt die fehlenden Nummern pro Durchgang
uint count = numsDurchgang.count();
uint maxnum = 0;
uint minnum = 999999;
for (uint k = 0; k < count; k++)
{
//höchste und niedrigste Num finden
if (numsDurchgang.at(k) > maxnum)
maxnum = numsDurchgang.at(k);
if (numsDurchgang.at(k) < minnum)
@@ -396,7 +389,7 @@ QVector<uint> MainWindow::getFehlendeNums(const QVector<uint> &numsDurchgang)
QVector<uint> fehlendeNum;
for (uint z = minnum; z <= maxnum; z++)
{
//liste nach fehlenden werten durchsuchen
bool vorhanden = false;
for (uint j = 0; j < count; j++)
{
@@ -425,5 +418,5 @@ void MainWindow::writeLogZeiten(const QDateTime &beginn, const QDateTime &end, c
file.write(msg.toUtf8());
file.close();
//delete end;
}
@@ -7,7 +7,7 @@
namespace Ui
{
class MainWindow;
class MainWindow;
}
struct LogfileInfo
@@ -41,17 +41,9 @@ private:
QString m_logfile;
QString m_logZeiten;
void openLogfile(const QString &folder, int count);
void writeToLogfile(const QString &issi,
const QDateTime &timestamp,
const QString &filename,
uint lfdNr,
const QString &bytes);
void writeToLogfile(const QString &issi,
const QDateTime &sendeZeit,
const QDateTime &timestamp,
const QString &filename,
uint lfdNr);
QString getISSI(QByteArray ar);
void writeToLogfile(const QString &issi, const QDateTime &timestamp, const QString &filename, uint lfdNr, const QString &bytes);
void writeToLogfile(const QString &issi, const QDateTime &sendeZeit, const QDateTime &timestamp, const QString &filename, uint lfdNr);
QString getISSI(QByteArray ar); //Für alte TPUS
int auswerten();
QVector<uint> getFehlendeNums(const QVector<uint> &numsDurchgang);
int fehlendeNumsEintragen(const QVector<uint> &numList, QFile &file);
@@ -65,5 +57,4 @@ private slots:
};
#endif
#endif // MAINWINDOW_H
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvApplication
// **************************************************************************
#include "PrtCnvApplication.hpp"
#include "PrtCnvThreadStarter.hpp"
@@ -28,382 +28,362 @@
namespace PrtCnv
{
static std::string threadIdToString(PrtCnvApplication::E_ThreadId id)
{
switch (id)
static std::string threadIdToString(PrtCnvApplication::E_ThreadId id)
{
case PrtCnvApplication::e_Central:
return "Central";
case PrtCnvApplication::e_Radio:
return "Radio";
case PrtCnvApplication::e_Db:
return "Db";
case PrtCnvApplication::e_Log:
return "Log";
case PrtCnvApplication::e_Injection:
return "Injection";
case PrtCnvApplication::e_RadioTraffic:
return "RadioTraffic";
case PrtCnvApplication::e_ThreadIdMax:
break;
switch (id)
{
case PrtCnvApplication::e_Central:
return "Central";
case PrtCnvApplication::e_Radio:
return "Radio";
case PrtCnvApplication::e_Db:
return "Db";
case PrtCnvApplication::e_Log:
return "Log";
case PrtCnvApplication::e_Injection:
return "Injection";
case PrtCnvApplication::e_RadioTraffic:
return "RadioTraffic";
case PrtCnvApplication::e_ThreadIdMax:
break;
}
return std::to_string(id);
}
return std::to_string(id);
}
PrtCnvApplication::PrtCnvApplication()
: m_Config(nullptr)
, m_exerciseId(0)
, m_logger(getLogger("PrtCnvApplication"))
{}
PrtCnvApplication::~PrtCnvApplication()
{
delete m_Config;
for (const auto &ti : m_threadInfo)
delete ti.thread;
}
void PrtCnvApplication::waitForCreate(const E_ThreadId a_threadId)
{
INFO_LOG(m_logger) << "Wait for others until we can create " << threadIdToString(a_threadId);
setConstructed(a_threadId);
switch (a_threadId)
PrtCnvApplication::PrtCnvApplication()
: m_Config(nullptr)
, m_exerciseId(0)
, m_logger(getLogger("PrtCnvApplication"))
{
case e_Central:
while (!(isConstructed(e_Db) &&
isConstructed(e_Radio) &&
isConstructed(e_Log) &&
isConstructed(e_Injection)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isConstructed(e_Db) &&
isConstructed(e_Central) &&
isConstructed(e_Log) &&
isConstructed(e_Injection)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Db:
while (!(isConstructed(e_Radio) &&
isConstructed(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
}
INFO_LOG(m_logger) << "Now we can create " << threadIdToString(a_threadId);
}
void PrtCnvApplication::waitForInit(E_ThreadId a_threadId)
{
INFO_LOG(m_logger) << "Wait for others until we can initialize " << threadIdToString(a_threadId);
setCreated(a_threadId);
switch (a_threadId)
PrtCnvApplication::~PrtCnvApplication()
{
case e_Central:
while (!(isCreated(e_Db) &&
isCreated(e_Radio)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isCreated(e_Db) &&
isCreated(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Db:
while (!(isCreated(e_Radio) &&
isCreated(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
delete m_Config;
for (const auto &ti : m_threadInfo)
delete ti.thread;
}
INFO_LOG(m_logger) << "Now we can initialize " << threadIdToString(a_threadId);
}
void PrtCnvApplication::waitForStart(E_ThreadId a_threadId)
{
INFO_LOG(m_logger) << "Wait for others until we can start " << threadIdToString(a_threadId);
setInitialized(a_threadId);
switch (a_threadId)
// ---------------------------------------------------------------
// Synchronisation of threads before create().
// ---------------------------------------------------------------
void PrtCnvApplication::waitForCreate(const E_ThreadId a_threadId)
{
case e_Central:
while (!(isStarted(e_Db) &&
isInitialized(e_Radio) &&
isStarted(e_Log) &&
isStarted(e_Injection)))
INFO_LOG(m_logger) << "Wait for others until we can create " << threadIdToString(a_threadId);
setConstructed(a_threadId);
switch (a_threadId)
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Central:
while (!(isConstructed(e_Db) && isConstructed(e_Radio) && isConstructed(e_Log) && isConstructed(e_Injection)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isStarted(e_Db) &&
isInitialized(e_Central) &&
isStarted(e_Log) &&
isStarted(e_Injection) &&
isInitialized(e_RadioTraffic)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isConstructed(e_Db) && isConstructed(e_Central) && isConstructed(e_Log) && isConstructed(e_Injection)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Db:
while (!(isInitialized(e_Radio) &&
isInitialized(e_Central) &&
isStarted(e_Log)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
case e_Db:
while (!(isConstructed(e_Radio) && isConstructed(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
}
break;
case e_RadioTraffic:
while (!(isInitialized(e_Radio) &&
isStarted(e_Log)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
INFO_LOG(m_logger) << "Now we can create " << threadIdToString(a_threadId);
}
INFO_LOG(m_logger) << "Now we can start " << threadIdToString(a_threadId);
}
void PrtCnvApplication::waitForExec(E_ThreadId a_threadId)
{
setStarted(a_threadId);
}
void PrtCnvApplication::startApp()
{
createApplication();
init();
start();
}
void PrtCnvApplication::shutdownApp()
{
stop();
deinit();
destroy();
for (const auto &ti : m_threadInfo)
ti.thread->quit();
for (const auto &ti : m_threadInfo)
ti.thread->wait();
for (auto &ti : m_threadInfo)
// ---------------------------------------------------------------
// Synchronisation of threads before init().
// ---------------------------------------------------------------
void PrtCnvApplication::waitForInit(E_ThreadId a_threadId)
{
delete ti.thread;
ti.thread = nullptr;
INFO_LOG(m_logger) << "Wait for others until we can initialize " << threadIdToString(a_threadId);
setCreated(a_threadId);
switch (a_threadId)
{
case e_Central:
while (!(isCreated(e_Db) && isCreated(e_Radio)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isCreated(e_Db) && isCreated(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Db:
while (!(isCreated(e_Radio) && isCreated(e_Central)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
}
INFO_LOG(m_logger) << "Now we can initialize " << threadIdToString(a_threadId);
}
}
void PrtCnvApplication::setCleanDb(bool bCleanDb)
{
PrtCnvThread::m_DoCleanDb = bCleanDb;
}
void PrtCnvApplication::setExerciseId(int exerciseId)
{
m_exerciseId = exerciseId;
}
void PrtCnvApplication::setConfigFile(const QString &configFile)
{
m_ConfigFileName = configFile;
}
int32_t PrtCnvApplication::createApplication()
{
setName(QStringLiteral("Common"));
if (m_ConfigFileName.isEmpty())
// ---------------------------------------------------------------
// Synchronisation of threads before start().
// ---------------------------------------------------------------
void PrtCnvApplication::waitForStart(E_ThreadId a_threadId)
{
m_ConfigFileName = QCoreApplication::applicationDirPath();
if (m_exerciseId > 0)
m_ConfigFileName += QStringLiteral("/PrtCnv_ex_") + QString::number(m_exerciseId) + QStringLiteral(".dat");
else
m_ConfigFileName += QStringLiteral("/PrtCnv.dat");
INFO_LOG(m_logger) << "Wait for others until we can start " << threadIdToString(a_threadId);
setInitialized(a_threadId);
switch (a_threadId)
{
case e_Central:
while (!(isStarted(e_Db) && isInitialized(e_Radio) && isStarted(e_Log) && isStarted(e_Injection)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Radio:
while (!(isStarted(e_Db) && isInitialized(e_Central) && isStarted(e_Log) && isStarted(e_Injection) && isInitialized(e_RadioTraffic)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_Db:
while (!(isInitialized(e_Radio) && isInitialized(e_Central) && isStarted(e_Log)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
case e_RadioTraffic:
while (!(isInitialized(e_Radio) && isStarted(e_Log)))
{
DEBUG_LOG(m_logger) << "wait...";
QThread::sleep(1);
}
break;
default:
break;
}
INFO_LOG(m_logger) << "Now we can start " << threadIdToString(a_threadId);
}
m_Config = new NGL::Settings(m_ConfigFileName);
std::cout << "Use config-file: " << qPrintable(m_ConfigFileName) << std::endl;
for (int i = 0; i < e_ThreadIdMax; i++)
m_threadInfo[i].thread = new PrtCnvThreadStarter((E_ThreadId)i, m_ConfigFileName, this);
N_AppComponent::AppComponent::create(m_Config);
return 0;
}
// ---------------------------------------------------------------
// Synchronisation of threads before execution of thread.
// ---------------------------------------------------------------
void PrtCnvApplication::waitForExec(E_ThreadId a_threadId)
{
setStarted(a_threadId);
}
// ---------------------------------------------------------------
// Starts the main-application
// ---------------------------------------------------------------
void PrtCnvApplication::startApp()
{
createApplication();
init();
start();
}
void PrtCnvApplication::shutdownApp()
{
stop();
deinit();
destroy();
for (const auto &ti : m_threadInfo)
ti.thread->quit();
for (const auto &ti : m_threadInfo)
ti.thread->wait();
for (auto &ti : m_threadInfo)
{
delete ti.thread;
ti.thread = nullptr;
}
}
void PrtCnvApplication::setCleanDb(bool bCleanDb)
{
PrtCnvThread::m_DoCleanDb = bCleanDb;
}
void PrtCnvApplication::setExerciseId(int exerciseId)
{
m_exerciseId = exerciseId;
}
void PrtCnvApplication::setConfigFile(const QString &configFile)
{
m_ConfigFileName = configFile;
}
// ---------------------------------------------------------------
// Creates the childs
// ---------------------------------------------------------------
int32_t PrtCnvApplication::createApplication()
{
setName(QStringLiteral("Common"));
if (m_ConfigFileName.isEmpty())
{
m_ConfigFileName = QCoreApplication::applicationDirPath();
if (m_exerciseId > 0)
m_ConfigFileName += QStringLiteral("/PrtCnv_ex_") + QString::number(m_exerciseId) + QStringLiteral(".dat");
else
m_ConfigFileName += QStringLiteral("/PrtCnv.dat");
}
m_Config = new NGL::Settings(m_ConfigFileName);
std::cout << "Use config-file: " << qPrintable(m_ConfigFileName) << std::endl;
for (int i = 0; i < e_ThreadIdMax; i++)
m_threadInfo[i].thread = new PrtCnvThreadStarter((E_ThreadId)i, m_ConfigFileName, this);
N_AppComponent::AppComponent::create(m_Config);
return 0;
}
// ---------------------------------------------------------------
// Starts the childs and then the main application
// ---------------------------------------------------------------
int32_t PrtCnvApplication::start()
{
// start and create threads
for (const auto &ti : m_threadInfo)
ti.thread->start();
N_AppComponent::AppComponent::start();
return 0;
}
int32_t PrtCnvApplication::start()
{
for (const auto &ti : m_threadInfo)
ti.thread->start();
// ---------------------------------------------------------------
// Returns the desired thread-starter
// ---------------------------------------------------------------
PrtCnv::PrtCnvThreadStarter *PrtCnvApplication::getThreadStarter(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return nullptr;
N_AppComponent::AppComponent::start();
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].thread;
}
return 0;
}
void PrtCnvApplication::setDatabaseConnectionParams(const QString &driver,
const QString &hostName,
const QString &database,
const QString &schemaName,
const QString &userName,
const QString &password)
{
m_dbDriver = driver;
m_dbHostName = hostName;
m_dbDatabaseName = database;
m_dbSchemaName = schemaName;
m_dbUserName = userName;
m_dbPassword = password;
}
void PrtCnvApplication::logWlsTelegram(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele, bool bIsSend)
{
const auto threadHandler = m_threadInfo[e_Log].thread;
PrtCnvTelegramLogThread *t = static_cast<PrtCnvTelegramLogThread *>(threadHandler ? threadHandler->getThread() : nullptr);
if (t)
t->writeWlsTelegramLog(tele, bIsSend, 0);
}
// ---------------------------------------------------------------
bool PrtCnvApplication::isConstructed(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isConstructed;
}
// ---------------------------------------------------------------
void PrtCnvApplication::setConstructed(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isConstructed = true;
}
// ---------------------------------------------------------------
bool PrtCnvApplication::isInitialized(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isInitialized;
}
PrtCnv::PrtCnvThreadStarter *PrtCnvApplication::getThreadStarter(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return nullptr;
// ---------------------------------------------------------------
void PrtCnvApplication::setInitialized(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isInitialized = true;
}
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].thread;
}
// ---------------------------------------------------------------
bool PrtCnvApplication::isCreated(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isCreated;
}
void PrtCnvApplication::setDatabaseConnectionParams(const QString &driver,
const QString &hostName,
const QString &database,
const QString &schemaName,
const QString &userName,
const QString &password)
{
m_dbDriver = driver;
m_dbHostName = hostName;
m_dbDatabaseName = database;
m_dbSchemaName = schemaName;
m_dbUserName = userName;
m_dbPassword = password;
}
// ---------------------------------------------------------------
void PrtCnvApplication::setCreated(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isCreated = true;
}
void PrtCnvApplication::logWlsTelegram(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele,
bool bIsSend)
{
const auto threadHandler = m_threadInfo[e_Log].thread;
PrtCnvTelegramLogThread *t = static_cast<PrtCnvTelegramLogThread*>(threadHandler ? threadHandler->getThread() : nullptr);
if (t)
t->writeWlsTelegramLog(tele, bIsSend, 0);
}
// ---------------------------------------------------------------
bool PrtCnvApplication::isStarted(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isStarted;
}
// ---------------------------------------------------------------
void PrtCnvApplication::setStarted(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isStarted = true;
}
bool PrtCnvApplication::isConstructed(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isConstructed;
}
void PrtCnvApplication::setConstructed(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isConstructed = true;
}
bool PrtCnvApplication::isInitialized(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isInitialized;
}
void PrtCnvApplication::setInitialized(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isInitialized = true;
}
bool PrtCnvApplication::isCreated(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isCreated;
}
void PrtCnvApplication::setCreated(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isCreated = true;
}
bool PrtCnvApplication::isStarted(const E_ThreadId a_threadId) const
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return false;
QMutexLocker l(&m_accessMutex);
return m_threadInfo[a_threadId].isStarted;
}
void PrtCnvApplication::setStarted(const E_ThreadId a_threadId)
{
if (a_threadId < e_Central || a_threadId >= e_ThreadIdMax)
return;
QMutexLocker l(&m_accessMutex);
m_threadInfo[a_threadId].isStarted = true;
}
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvApplication
// **************************************************************************
#pragma once
@@ -23,20 +23,33 @@
#include "prtcnvlib_export.h"
#include <TrainingAreaBase/training_area_telegrams.h>
/**
* Here are all project specific classes of protocol-converter implemented.
*/
namespace PrtCnv
{
class PrtCnvThreadStarter;
class PRTCNVLIB_EXPORT PrtCnvApplication : public QObject, public N_AppComponent::AppComponent
/**
* The main-application of protocol-converter. It is responsible for starting and
* controlling the threads of this application.
*
* @author alois.wismer
* @version 1.0
* @created 23-Jun-2009 17:48:47
*/
class PRTCNVLIB_EXPORT PrtCnvApplication
: public QObject
, public N_AppComponent::AppComponent
{
Q_OBJECT
public:
/**
* This enum will be used to unique identify the threads
*
* @author alois.wismer
* @version 1.0
* @created 19-Jan-2010 17:09:00
*/
enum E_ThreadId
{
e_Central,
@@ -50,8 +63,9 @@ namespace PrtCnv
PrtCnvApplication();
~PrtCnvApplication();
/**
* Starts the main-application
*/
void startApp();
void shutdownApp();
static void setCleanDb(bool bCleanDb);
@@ -59,33 +73,51 @@ namespace PrtCnv
int exerciseId() const { return m_exerciseId; }
void setConfigFile(const QString &configFile);
/**
* Starts the childs and then the main application
*/
int32_t start() override;
/**
* Synchronisation of threads before init().
*
* @param a_threadId id of the calling thread
*/
void waitForInit(E_ThreadId a_threadId);
/**
* Synchronisation of threads before start().
*
* @param a_threadId id of the calling thread
*/
void waitForStart(E_ThreadId a_threadId);
/**
* Synchronisation of threads before create().
*
* @param a_threadId Id of the calling thread
*/
void waitForCreate(const E_ThreadId a_threadId);
/**
* Synchronisation of threads before execution of thread.
*
* @param a_threadId id of the calling thread
*/
void waitForExec(E_ThreadId a_threadId);
PrtCnvThreadStarter* getThreadStarter(const E_ThreadId a_threadId);
/**
* Returns the desired thread-starter
*
* @param a_threadId Id of the desired thread-started (corresponding thread has
* the same id)
*/
PrtCnvThreadStarter *getThreadStarter(const E_ThreadId a_threadId);
/**
* @brief Set the database connection parameter when used as library
*/
void setDatabaseConnectionParams(const QString &driver,
const QString &hostName,
const QString &database,
@@ -99,54 +131,69 @@ namespace PrtCnv
QString databaseUserName() const { return m_dbUserName; }
QString databasePassword() const { return m_dbPassword; }
public slots:
public slots:
void logWlsTelegram(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele, bool bIsSend);
signals:
signals:
void textMessageFromPrtCnvToCentral(const QByteArray &ba);
void textMessageFromCentralToPrtCnv(const QByteArray &ba);
void outgoingBroadcastTelegramsRequest(int equipmentNumber, int broadcastIndex, int resetCounter);
void warehouseMessageFromPtrCnv(const QByteArray &jsonData);
protected:
protected:
/**
* Creates the childs
*/
int32_t createApplication();
/**
* Returns true when the specified thread is
* already constructed
*/
bool isConstructed(const E_ThreadId a_threadId) const;
/**
* The specifed thread is now constructed
*/
void setConstructed(const E_ThreadId a_threadId);
/**
* Returns true when the specified thread is
* already initialized
*/
bool isInitialized(const E_ThreadId a_threadId) const;
/**
* The specifed thread is now initialized
*/
void setInitialized(const E_ThreadId a_threadId);
/**
* Returns true when the specified thread is
* already created
*/
bool isCreated(const E_ThreadId a_threadId) const;
/**
* The specifed thread is now created
*/
void setCreated(const E_ThreadId a_threadId);
/**
* Returns true when the specified thread is
* already started
*/
bool isStarted(const E_ThreadId a_threadId) const;
/**
* The specifed thread is now started
*/
void setStarted(const E_ThreadId a_threadId);
protected:
protected:
/**
* Used to get configuration-parameter
*/
NGL::Settings *m_Config;
struct ThreadInfo
@@ -157,14 +204,15 @@ protected:
bool isInitialized = false;
bool isStarted = false;
} m_threadInfo[e_ThreadIdMax];
/**
* The name of the config-file
*/
QString m_ConfigFileName;
/**
* The exerciseId (or zero if not set)
*/
int m_exerciseId;
mutable QRecursiveMutex m_accessMutex;
@@ -176,6 +224,6 @@ protected:
QString m_dbPassword;
NGL::INGLLogger &m_logger;
};
};
}
File diff suppressed because it is too large. Load diff
@@ -1,15 +1,15 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
#pragma once
@@ -29,7 +29,7 @@
namespace N_CoPrtCnv
{
class CoPrtCnvRadioTelegram;
class CoPrtCnvRadioTelegram;
}
#define MAX_BROADCAST_INDEX 65535
@@ -37,321 +37,538 @@ class CoPrtCnvRadioTelegram;
namespace PrtCnv
{
class PrtCnvDbThread;
class PrtCnvDbThread;
class PrtCnvBroadcastMgr final : public QObject
{
Q_OBJECT
public:
enum E_State
/**
* This class is responsible for handling all the broadcast stuff. This includes:
* - sending the broadcast 3 times
* - sending Broadcast-Nachforderungen to TNE
* - store and manage the broadcast-list
* - measure the Broadcast-Nachforderung-statistic
* @author wia
* @version 1.0
* @updated 30-Apr-2010 11:21:05
*/
class PrtCnvBroadcastMgr final : public QObject
{
e_ST_UNDEFINED,
e_ST_COLLECT,
e_ST_SEND_NACHFORDERUNG
Q_OBJECT
public:
/**
* The different states the broadcast-manager can be.
* @author wia
* @version 1.0
* @updated 30-Apr-2010 11:21:05
*/
enum E_State
{
e_ST_UNDEFINED,
e_ST_COLLECT,
e_ST_SEND_NACHFORDERUNG
};
PrtCnvBroadcastMgr();
/**
* returns true when the telegram should be sent to central
*
* @param a_radioTelegram
*/
bool handleRadioTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
/**
* Creates all subcomponents
*/
int32_t create(NGL::Settings *settings);
/**
* Initializes the variables.
*/
int32_t init();
/**
* returns the next normal broadcast to send.
* a_doDelete is true, when the caller has to delete the telegram when no longer
* using it.
* Use the same a_actualTime in one tick-loop.
*
* @param a_beginSearchWithBroadcastIndex
* @param a_actualTime
* @param a_doDelete true if telegram must be deleted after using it
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextBroadcastTelegramToSend(const uint16_t a_beginSearchWithBroadcastIndex, const time_t a_currentTime);
/**
* sets the DbThread used for get the stored broadcast-telegrams
*
* @param a_dbThread
*/
void setDbThread(PrtCnvDbThread *a_dbThread);
/**
* Initializes the broadcast-manager. If a_deleteTelegrams is true, all stored
* telegrams and maps will be deleted.
*
* @param a_deleteTelegrams
*/
void cleanAndInit(const bool a_deleteTelegrams);
/**
* Removes all Nop out of broadcast-list and numerates the broadcast-index of kept
* broadcast-telegrams new.
*
* @param a_doRestore
*/
void handleOverrunOfBroadcastCounter(const bool a_doRestore = false);
/**
* returns the next broadcast to send for nachforderungen
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextNachforderungTelegramToSend();
/**
* dumps important values, only for debugging
*/
void dump();
/**
* Restores data after crash for seamless proceeding of work.
*/
void restoreAfterCrash();
/**
* Returns the actual broadcast-index for normal broadcasts.
*/
uint16_t getBroadcastIndex() const;
/**
* Returns the broadcastindex for the next broadcast
*/
uint16_t getNextBroadcastIndex();
/**
* Adds the telegram a_broadcastOnlyTelegram (which must have set already the
* broadcast-index) to the broadcast-map. The telegram will be attached to an
* already existing broadcast-telegram with same broadcast-index in the map,
* otherwise it will be marked as broadcast-only.
* If the there is already an broadcast-only-telegram attached, nothing will be
* done.
*
* @param a_broadcastOnlyTelegram
*/
void addBroadcastOnlyTelegramToMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_broadcastOnlyTelegram);
/**
* Increments the tick-counter of broadcast-manager and informs the broadcast-
* manager about the traffic-load.
*
* @param a_isHighLoad
* @param a_isFullLoad
*/
void incTickAndSetTrafficLoad(const bool a_isHighLoad, const bool a_isFullLoad);
/**
* Checks if the given id is in m_deactivatedAesMine2bcIndex/m_deactivatedDusMine2bcIndex/m_deactivatedFuncAreaMine2bcIndex
*
* @brief isEffectSimulationIdDeactivated
* @param effectsimulationId
* @return
*/
bool isEffectSimulationIdDeactivated(const uint16_t effectsimulationId) const;
/**
* Adds the TNE to the nachforderungs-list
*
* @param a_radioTelegram
*/
void handleNachforderungBroadcastTelegram(int identity, int broadcastIndex, int resetCounter);
protected:
struct EquipNoBcIndex
{
int equipNo = 0;
int bcIndex = 0;
EquipNoBcIndex() = default;
EquipNoBcIndex(int e, int b)
: equipNo(e)
, bcIndex(b)
{
}
};
/**
* Map of TNE, that sent a NachforderungBroadcast-Telegram.
* Key: identity of TNE; Value: broadcast-counter
*/
std::vector<EquipNoBcIndex> m_claimerArray;
/**
* Time (in SendGap-ticks) spent for collection NachforderungeBroadcast, before
* sending broadcasts begins
* This value will be used for normal load.
*/
uint16_t m_ClaimWindow;
/**
* the factor for widening claim-window before sending broadcasts when we have
* high load traffic
*/
uint16_t m_HighLoadFactor;
/**
* the number of TPUs needed for sending the broadcasts as broadcast instead
* directed
*/
uint16_t m_BroadcastLimit;
/**
* Used to get configuration-parameter.
*/
NGL::Settings *m_Config;
/**
* Actual time (in SendGap-ticks) spent for collection NachforderungeBroadcast,
* before sending broadcasts begins. This value changes depending on downlink-load.
*/
uint16_t m_ActClaimWindow;
/**
* The state of broadcast-manager.
*/
PrtCnvBroadcastMgr::E_State m_State;
uint16_t m_TickCounter;
/**
* The actual broadcast-index for sending nachforderungen
*/
PrtCnvDbThread *m_DbThread;
/**
* sorted by broadcast-index
*/
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_BroadcastMap;
std::vector<std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_broadcastTelegamsToSend;
/**
* Contains all telegrams which must only be stored once for nachforderungen
*/
std::map<gef_telegramm_id_et, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_LastTelegramMap;
/**
* Contains all wirkfeld-telegrams which must be stored for nachforderungen
* ordered by wirkfeldkennung.
*/
std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByKennung;
/**
* Contains all wirkfeld-telegrams which must be stored for nachforderungen
* ordered by expiration-time.
*/
std::multimap<time_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByTime;
/**
* Contains all funktionsraum-telegrams which must be stored for nachforderungen
* ordered by funktionsraumkennung.
*/
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_FunktionsraumTelegramMap;
/**
* Contains all technik-funktionsraum-telegrams which must be stored for nachforderungen
* ordered by funktionsraumkennung.
*/
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_TechnikFunktionsraumTelegramMap;
/**
* The actual broadcast-index for normal broadcast
*/
uint16_t m_BroadcastIndex;
/**
* True if send-traffic is on full-load => no nachforderungen will be sent
*/
bool m_IsFullLoad;
/**
* The highest broadcast-index of 3rd time sent broadcast-telegram (for optimize
* by time)
*/
uint16_t m_FinishedBroadcastIndex;
/**
* The broadcast-index of the 1st broadcast-telegram which has been sent 1 time
* only (for optimize by time)
*/
uint16_t m_FirstBroadcastIndexOfBc1;
/**
* adds the radio-telegram to the broadcast-map, or generates the sammeltelegramme
*
* @param a_radioTelegram
*/
void addToBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
/**
* returns the Nachforderungs-telegram with this broadcast-index from the
* broadcast-map with sammeltelegrams. If the telegram with a_broadcastIndex does
* not exist, a NOP-telegram will be returned, which must be consumed immediately
* and must never be deleted.
* The parameter a_broadcastIndex will be updated to the value of found telegram.
* ATTENTION: the returned a_broadcastIndex could be different from the value
* returned by getBroadcastIndex(), for example in NOP-telegrams
* getBroadcastIndex() returns the Anfang, but a_broadcastIndex will be the Ende.
*
* @param a_broadcastIndex
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNachforderungsTelegram(int curBcIndex, int startBcIndex, int &nextBcIndex);
/**
* searches the kennung within sammeltelegram.
* returns -1 when kennung not found
*
* @param a_sammelTelegram
* @param a_kennung
*/
int getSammeltelegramIndex(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram, const uint16_t a_kennung) const;
/**
* Moves a_radioTelegram to a_newBroadcastIndex in broadcast-map.
* If a_radioTelegram has an attached broadcast-only-telegram, the broadcastOnly-
* telegram will be detached and kept on the old broadcast-index position.
* If a_attachTelegram in not NULL, this telegram will be attached to
* a_radioTelegram.
*
* @param a_radioTelegram The radio-telegram to be moved
* @param a_newBroadcastIndex The new broadcast-index
* @param a_attachTelegram The telegram to be attached
*/
void moveTelegramInBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
const uint16_t a_newBroadcastIndex,
const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_attachTelegram = {});
/**
* Removes the telegram a_radioTelegram from the broadcast-map. If the
* a_radioTelegram has an attached telegram, the attached telegram will be
* detached and added to broadcast-map as broadcast-only telegram.
* If the telegram is an attached BC-only-telegram, it will be detached.
* The telegram itself will be deleted when a_doDeleteTelegram is true.
* ATTENTION: iterators to m_BroadcastMap could be invalid after calling this
* function
*
* @param a_radioTelegram
* @param a_doDeleteTelegram
*/
void removeFromBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void removeFromBroadcastMapFunc(const std::function<bool(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &)> &pred);
void removeDusMineDeactivationFromBroadcastMap(int dusMineId);
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccumulationTelegram(int curBcIndex,
int startBcIndex,
gef_telegramm_id_et telId,
const QMap<int, int> &bcIndex2Type,
int maxIdsPerTelegram,
int sizeOfSumField) const;
bool removeFromDeactivatedAesArea(int aesAreaId);
bool addToDeactivatedAesArea(int aesAreaId, int bcIndex);
// QHash<mineId, broadcastIndexDeactivated>
QHash<int, int> m_deactivatedAesArea2bcIndex;
// QMap<broadcastIndexDeactivated, mineId>, keep sorted!
QMap<int, int> m_deactivatedBcIndex2AesArea;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleDeactivatedAesAreas(int curBcIndex, int startBcIndex) const;
bool removeFromDeactivatedFuncArea(int aesAreaId);
bool addToDeactivatedFuncArea(int aesAreaId, int bcIndex);
// QHash<mineId, broadcastIndexDeactivated>
QHash<int, int> m_deactivatedFuncArea2bcIndex;
// QHash<broadcastIndexDeactivated, mineId>, keep sorted!
QMap<int, int> m_deactivatedBcIndex2FuncArea;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleDeactivatedFuncAreas(int curBcIndex, int startBcIndex) const;
bool removeFromDeactivatedDusMine(int dusMineId);
bool addToDeactivatedDusMine(int dusMineId, int bcIndex);
// QHash<mineId, broadcastIndexDeactivated>
QHash<int, int> m_deactivatedDusMine2bcIndex;
// QHash<broadcastIndexDeactivated, mineId>, keep sorted!
QMap<int, int> m_deactivatedBcIndex2DusMine;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleDeactivatedDusMines(int curBcIndex, int startBcIndex) const;
bool removeFromActivatedDusMine(int dusMineId);
void addToActivatedDusMine(int dusMineId);
QSet<int> m_activatedDusMines;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleActivatedDusMines(int curBcIndex);
/**
* Removes the kennung from the sammeltelegram.
* If the sammeltelegram is empty after remove of kennung, it will be taken out of
* broadcast-map (but not deleted) and a_sammelTelRemoved will be true. A attached
* braodcast-only-telegram will be deattached and inserted into broadcast-map.
* Returns true if kennung was successful removed, otherwise the kennung was not
* found within sammeltelegram
*
* @param a_sammelTelegram
* @param a_kennung
* @param a_anzahlPos
* @param a_anzahlSize
* @param a_sammelTelRemoved
*/
bool removeFromSammeltelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram,
const uint16_t a_kennung,
const uint16_t a_anzahlPos,
const uint8_t a_anzahlSize,
bool &a_sammelTelRemoved);
/**
* used for telegrams that must only exists once in BC-list
*
* @param a_newRadioTelegram
*/
void replaceLastTelegramAndAddAtEnd(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_newRadioTelegram);
/**
* Small helper to dump all wf-ids from a sammeltelegramm
*/
std::string dumpSammeldeaktivierung(const N_CoPrtCnv::CoPrtCnvRadioTelegram *sammelTelegram);
/**
* Gets the braodcast-telegrams from Db, which were sent 1st time and adds them to
* the maps. Expired telegrams will be removed.
*
* @param a_doRestore
*/
void getAllFinishedBroadcastsFromDb(const bool a_doRestore = false);
/**
* Takes expired wirkfeld-telegrams out of maps.
*/
void removeExpiredTelegrams();
/**
* Removes the wirkfeld-telegrams with this kennung from the by time and by
* kennung maps.
* Replace this telegrams with Nop in BC-list.
* Finally the telegram will be deleted.
*
* @param a_kennung
*/
void removeWirkfeldTelegrams(const uint16_t a_kennung);
/**
* adds the wirkfeld-telegram to the by time and by kennung maps
*
* @param a_radioTelegram
* @param a_wirkfeldKennung
* @param a_telId
* @param a_minenKennung
*/
void addWirkfeldTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
const uint16_t a_wirkfeldKennung,
const gef_telegramm_id_et a_telId = GEF_BESTAETIGUNG,
const uint16_t a_minenKennung = 0);
/**
* Deactivates the mine in the corresponding "WirkfeldstatusMinensperre"-telegram
* and moves the "WirkfeldstatusMinensperre"-telegram to the position of
* "DeactiviereEinzelmine"-telegram.
* Returns true if the "WirkfeldstatusMinensperre"-telegram was already sent 3
* times as normal broadcast.
*
* @param a_wirkfeldKennung
* @param a_minenKennung
* @param a_broadcastIndex
*/
bool deactivateEinzelmineFromMinensperre(const uint16_t a_wirkfeldKennung, const uint16_t a_minenKennung, const uint16_t a_broadcastIndex);
/**
* Returns a NOP-telegramm filled with the desired values.
*
* @param a_from
* @param a_to
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNopTelegram(const uint16_t a_from, const uint16_t a_to);
/**
* Removes the telegram a_radioTelegram from all maps (broadcast-, wirkfeld-,
* funktionsraum- and lastTelegram-map).
* If the telegram is a attached BC-only-telegram, it will be detached.
* The telegram itself will be deleted when a_doDeleteTelegram is true.
* ATTENTION: iterators to all maps could be invalid after calling this function
*
* @param a_radioTelegram
* @param a_doDeleteTelegram
*/
void removeFromAllMaps(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
/**
* Detaches an existing radio-telegram and adds it to the broadcast-map
*
* @param a_radioTelegram The telegram which could contain an attached telegram
*/
void detachTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
/**
* Removes the telegram with a_funktionsraumKennung from funktionsraum-map and
* from the broadcast-map.
* If the telegram is a attached BC-only-telegram, it will be detached.
* The telegram itself will be deleted.
* ATTENTION: iterators to m_FunktionsraumTelegramMap could be invalid after
* calling this function
*
* @param a_funktionsraumKennung
*/
void removeFromFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);
void removeFromTechnikFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);
/**
* Removes the telegram where wirkfeldTelegramMapByKennungIterator points to from
* wirkfeld-maps and from the broadcast-map.
* If the telegram is a attached BC-only-telegram, it will be detached.
* The telegram itself will be deleted.
* ATTENTION: iterators to m_WirkfeldTelegramMapByKennung and
* m_WirkfeldTelegramMapByTime could be invalid after calling this function
*
* @param a_wirkfeldTelegramMapByKennungIterator
*/
void removeFromWirkfeldAndBroadcastMaps(
const std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>>::iterator &a_wirkfeldTelegramMapByKennungIterator);
/**
* Handles the REAKTIVIERUNG_DUS_MINE-telegram for normal-broadcasts and
* nachforderungen.
*
* @param a_radioTelegram The GEF_REAKTIVIERUNG_DUS_MINE-telegram
*/
void reactivateDusMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
/**
* Handles the DEAKTIVIERUNG_EINZELMINE-telegram for normal-broadcasts and
* nachforderungen. This includes deactivation of mines from minen-sperre and DUS-
* mines.
*
* @param a_radioTelegram The GEF_REAKTIVIERUNG_DUS_MINE-telegram
*/
void deactivateSingleMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
/**
* Prepares values for start sending nachforderungen
*/
void prepareForSendNachforderungen();
/**
* returns the next nachforderung to send and prepares collecting window if no
* more nachforderungen are to be sent
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> evaluateNextNachforderungToSend();
Q_SIGNALS:
void areaEffectSimulationActivated(int wirkfeldKennung);
void areaEffectSimulationDeactivated(int wirkfeldKennung);
private:
NGL::INGLLogger &m_logger;
NGL::INGLLogger &m_loggerBcRequest;
};
PrtCnvBroadcastMgr();
bool handleRadioTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
int32_t create(NGL::Settings *settings);
int32_t init();
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextBroadcastTelegramToSend(const uint16_t a_beginSearchWithBroadcastIndex,
const time_t a_currentTime);
void setDbThread(PrtCnvDbThread *a_dbThread);
void cleanAndInit(const bool a_deleteTelegrams);
void handleOverrunOfBroadcastCounter(const bool a_doRestore = false);
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextNachforderungTelegramToSend();
void dump();
void restoreAfterCrash();
uint16_t getBroadcastIndex() const;
uint16_t getNextBroadcastIndex();
void addBroadcastOnlyTelegramToMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_broadcastOnlyTelegram);
void incTickAndSetTrafficLoad(const bool a_isHighLoad, const bool a_isFullLoad);
bool isEffectSimulationIdDeactivated(const uint16_t effectsimulationId) const;
void handleNachforderungBroadcastTelegram(int identity, int broadcastIndex, int resetCounter);
protected:
struct EquipNoBcIndex
{
int equipNo = 0;
int bcIndex = 0;
EquipNoBcIndex() = default;
EquipNoBcIndex(int e, int b) : equipNo(e), bcIndex(b) {}
};
std::vector<EquipNoBcIndex> m_claimerArray;
uint16_t m_ClaimWindow;
uint16_t m_HighLoadFactor;
uint16_t m_BroadcastLimit;
NGL::Settings *m_Config;
uint16_t m_ActClaimWindow;
PrtCnvBroadcastMgr::E_State m_State;
uint16_t m_TickCounter;
PrtCnvDbThread *m_DbThread;
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_BroadcastMap;
std::vector<std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_broadcastTelegamsToSend;
std::map<gef_telegramm_id_et, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_LastTelegramMap;
std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByKennung;
std::multimap<time_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByTime;
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_FunktionsraumTelegramMap;
std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_TechnikFunktionsraumTelegramMap;
uint16_t m_BroadcastIndex;
bool m_IsFullLoad;
uint16_t m_FinishedBroadcastIndex;
uint16_t m_FirstBroadcastIndexOfBc1;
void addToBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNachforderungsTelegram(int curBcIndex, int startBcIndex, int &nextBcIndex);
int getSammeltelegramIndex(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram,
const uint16_t a_kennung) const;
void moveTelegramInBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
const uint16_t a_newBroadcastIndex,
const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_attachTelegram = {});
void removeFromBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void removeFromBroadcastMapFunc(const std::function<bool(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &)> &pred);
void removeDusMineDeactivationFromBroadcastMap(int dusMineId);
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccumulationTelegram(int curBcIndex,
int startBcIndex,
gef_telegramm_id_et telId,
const QMap<int, int> &bcIndex2Type,
int maxIdsPerTelegram,
int sizeOfSumField) const;
bool removeFromDeactivatedAesArea(int aesAreaId);
bool addToDeactivatedAesArea(int aesAreaId, int bcIndex);
QHash<int, int> m_deactivatedAesArea2bcIndex;
QMap<int, int> m_deactivatedBcIndex2AesArea;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>createAccuTeleDeactivatedAesAreas(int curBcIndex, int startBcIndex) const;
bool removeFromDeactivatedFuncArea(int aesAreaId);
bool addToDeactivatedFuncArea(int aesAreaId, int bcIndex);
QHash<int, int> m_deactivatedFuncArea2bcIndex;
QMap<int, int> m_deactivatedBcIndex2FuncArea;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>createAccuTeleDeactivatedFuncAreas(int curBcIndex, int startBcIndex) const;
bool removeFromDeactivatedDusMine(int dusMineId);
bool addToDeactivatedDusMine(int dusMineId, int bcIndex);
QHash<int, int> m_deactivatedDusMine2bcIndex;
QMap<int, int> m_deactivatedBcIndex2DusMine;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleDeactivatedDusMines(int curBcIndex, int startBcIndex) const;
bool removeFromActivatedDusMine(int dusMineId);
void addToActivatedDusMine(int dusMineId);
QSet<int> m_activatedDusMines;
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleActivatedDusMines(int curBcIndex);
bool removeFromSammeltelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram,
const uint16_t a_kennung,
const uint16_t a_anzahlPos,
const uint8_t a_anzahlSize,
bool &a_sammelTelRemoved);
void replaceLastTelegramAndAddAtEnd(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_newRadioTelegram);
std::string dumpSammeldeaktivierung(const N_CoPrtCnv::CoPrtCnvRadioTelegram *sammelTelegram);
void getAllFinishedBroadcastsFromDb(const bool a_doRestore = false);
void removeExpiredTelegrams();
void removeWirkfeldTelegrams(const uint16_t a_kennung);
void addWirkfeldTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
const uint16_t a_wirkfeldKennung, const gef_telegramm_id_et a_telId = GEF_BESTAETIGUNG,
const uint16_t a_minenKennung = 0);
bool deactivateEinzelmineFromMinensperre(const uint16_t a_wirkfeldKennung, const uint16_t a_minenKennung, const uint16_t a_broadcastIndex);
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNopTelegram(const uint16_t a_from, const uint16_t a_to);
void removeFromAllMaps(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void detachTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void removeFromFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);
void removeFromTechnikFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);
void removeFromWirkfeldAndBroadcastMaps(const std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>>::iterator &a_wirkfeldTelegramMapByKennungIterator);
void reactivateDusMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void deactivateSingleMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
void prepareForSendNachforderungen();
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> evaluateNextNachforderungToSend();
Q_SIGNALS:
void areaEffectSimulationActivated(int wirkfeldKennung);
void areaEffectSimulationDeactivated(int wirkfeldKennung);
private:
NGL::INGLLogger &m_logger;
NGL::INGLLogger &m_loggerBcRequest;
};
}
File diff suppressed because it is too large. Load diff
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvCentralThread
// **************************************************************************
#pragma once
@@ -27,209 +27,284 @@ namespace PrtCnv
{
class PrtCnvRadioThread;
class PrtCnvThreadStarter;
/**
* This class handles the protocoll to central. This includes:
* - connection with files instead sockets (configurable)
* - send and receive telegrams
*
* @author
* @version 1.0
* @created 05-Jan-2006 13:34:28
*/
class PrtCnvCentralThread : public PrtCnv::PrtCnvThread
{
Q_OBJECT
private:
private:
public:
/**
* @author wia
* @version 1.0
* @updated 02-Jul-2009 14:32:58
*/
~PrtCnvCentralThread();
explicit PrtCnvCentralThread(PrtCnvThreadStarter* a_parent);
/**
* @param a_parent The pointer to the starter-thread
*/
explicit PrtCnvCentralThread(PrtCnvThreadStarter *a_parent);
/**
* Creates all subcomponents and connects signals to slots
*/
int32_t create(NGL::Settings *settings) override;
int32_t deinit() override;
/**
* Deallocates subcomponents.
*/
int32_t destroy() override;
/**
* Initializes the variables.
*/
int32_t init() override;
/**
* Starts the thread and connects to TCP-server
*/
int32_t start() override;
/**
* Stops the thread
*/
int32_t stop() override;
// for direct communication
void onDirectTextMessageReceived(const QByteArray &baJson);
signals:
// for direct communication
void directTextMessage(const QByteArray &baJson);
/**
* Signal to start sending a telegram to central
*/
void checkSendToCentral();
/**
* Signal to start sending a telegram to radio
*/
void checkSendToRadio();
/**
* Signal to stop radio
*/
void stopRadio();
/**
* Signal to start cleaning-process of radio-thread
*/
void cleanRadio();
/**
* Signal to restart work of radio-thread
*/
void startRadio();
protected:
/**
* For reading/writing json telegrams to socket
*/
QWebSocket *m_webSocket;
/**
* The send-counter (only for sockets)
*/
int32_t m_SendCounter;
public slots:
/**
* Checks whether a telegram must be sent and sends it.
*/
void checkSend();
/**
* Stores that radio-thread has stopped. Cleans the Db and reinitializes when
* central-thread has also stopped.
*/
void radioStopped();
/**
* Starts radio-thread and itself for proceeding work after cleaning the Db.
*/
void radioCleant();
/**
* Will be called from Db-thread when telegrams were stored permanent. This
* function will then send the ack to central (socket-based) or delete the
* telegramfiles (file-based)
*
* @param a_centralCounter
*/
void permanentStored(int32_t a_centralCounter);
// called from Radio thread to indicate current connection state
void onTetraConnectionState(bool bConnected);
// called from Radio thread to indicate the license state of an equipment
void onPlayerLicencedChanged(int equipNo, N_CoPrtCnv::E_LicensingKind kind);
protected slots:
// an effect siumlation was (de)activated
void onAreaEffectSimulationDeactivated(int wirkfeldKennung);
void onAreaEffectSimulationActivated(int wirkfeldKennung);
// radio thread completely initialized
void onRadioThreadInitDone();
/**
* called when websocket is connected
*/
void connected();
/**
* called when websocket is disconnected
*/
void disconnected();
/**
* used to send periodically an ack to central
*/
void timeoutTick();
/**
* see base-class
*/
void timeoutAliveAndConnection();
void onTextMessageReceived(const QString &msg);
void stateChanged(QAbstractSocket::SocketState newState);
protected:
/**
* Sends a ack-telegram to central.
*/
void sendAck();
/**
* Stores a telegram to be sent to radio in volatile radio-list and permanent in
* DB.
*
* @param a_telegram
*/
void handleTelegram(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
bool checkAndUpdateReceiveCounter(const int32_t a_counter);
void sendTelegram(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram,
PrtCnvStoredCentralTelegram *a_handle);
/**
* Sends a central-telegram to socket or file, depending on configuration. Before
* sending, the send-counter will be set. After sending the Db will be updated.
*
* @param a_telegram The central-telegram to be sent.
* @param a_handle The handle assigned to telegram to be sent, we got from Db.
*/
void sendTelegram(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram, PrtCnvStoredCentralTelegram *a_handle);
/**
* Processes the telegram AnforderungStatistikBroadcastNachforderugen. The
* function fills the answer telegram StatistikBroadNachforderungen with the
* actual statistic.
*
* @param a_umgMldTelegram
*/
void handleAnforderungStatistikBroadcastNachforderungen();
/**
* Removes telegrams from ToCentral-table, if the central acknowledges their
* reception
*
* @param a_ackTelegram
*/
void handleAck(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
/**
* Calls clean of radio-thread and Db-thread and initializes the variables for
* rework.
*/
void cleanAndReinit();
/**
* returns true if telegram should be converted, stored and sent to radio
*
* @param a_telegram
*/
bool handleSpecialTelegram(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
/**
* Sends a central-telegram to socket or file, depending on configuration. Before
* sending, the send-counter will be set.
*
* @param a_telegram The central-telegram to be sent.
*/
void sendTelegram(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
/**
* Connect as client to a TCP-server on ip-address configured as HostName and Port
* configured as Port
*/
void connectSocket();
/**
* Disconnects from TCP-server
*/
void disconnectSocket();
protected:
/**
* used for periodically send an ack to central
*/
PrtCnvRadioThread *m_RadioThread;
/**
* True if radio has stopped work
*/
bool m_RadioStopped;
/**
* True if central has stopped work
*/
bool m_CentralStopped;
/**
* Used for resending unacked telegrams
*/
int32_t m_LastSendCounter;
/**
* The (virtual) identify of the protocol-converter
*/
uint16_t m_VirtualTeilnehmerId;
/**
* The maximum equipment-ID for tetra - all telegrams with an higher ID will
* be silently ignored
*/
uint16_t m_maxEqID;
// timer to reconnect when no ack from central is coming anymore
QTimer *m_aliveTimer;
// timer to send ack to central
QTimer *m_sendAckTimer;
// timer to reconnect to central
QTimer *m_reconnectTimer;
/**
* True if the database has to be cleant up (used for fast empty of signal buffers)
*/
QAtomicInt m_DoCleanup;
PrtCnvDbThread *m_DbThread;
// log telegrams in file
PrtCnvTelegramLogThread *m_LogThread;
// get injected telegrams
PrtCnvInjectionThread *m_InjectionThread;
/**
* Counter of received telegrams (only for sockets)
*/
int32_t m_ReceiveCounter;
/**
* Acknowledged telegrams counter (only for sockets)
*/
int32_t m_ReceiveAckCounter;
/**
* The state-event-machine state
*/
PrtCnvSocketThread::E_State m_State;
// set with all already deactivated effect simulations to not send deactivate telegram twice
QSet<int> m_deactivatedAreaEffectSimulations;
// multimap with all mine areas and it's already triggered mines
QHash<int, QSet<int>> m_alreadyTriggeredMines;
// true when we don't use socket but direct connections (through onDirectTextMessageReceived)
bool m_bDirectConnection;
bool m_bRadioThreadInitDone;
File diff suppressed because it is too large. Load diff
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvDbThread
// **************************************************************************
#pragma once
@@ -37,292 +37,459 @@ namespace PrtCnv
class PrtCnvStoredCentralTelegram;
class PrtCnvStoredRadioTelegram;
class PrtCnvMember;
/**
* Handles all data which must be stored permanent:
* - central-telegrams
* - radio-telegrams
* - radio-members (TNE)
* - reset-counter
* - states
*
* @author wia
* @version 1.0
* @created 28-Jul-2009 16:08:53
*/
class PrtCnvDbThread : public PrtCnvThread
{
Q_OBJECT
public:
/**
* Constructor with thread-starter as argument
*
* @param a_parent
*/
PrtCnvDbThread(const QString &dbDriver,
const QString &dbHostName,
const QString &dbDatabaseName,
const QString &schemaName,
const QString &dbUserName,
const QString &dbPassword,
PrtCnvThreadStarter* a_parent);
PrtCnvThreadStarter *a_parent);
~PrtCnvDbThread();
/**
* starts this thread and its childs
*/
int32_t start() override;
/**
* stops this thread and its childs
*/
int32_t stop() override;
/**
* creates this thread and its childs
*/
int32_t create(NGL::Settings *settings) override;
/**
* initializes this thread and its childs
*/
int32_t init() override;
/**
* Indicates the Db, which telegrams were successful received by central. This
* will delete this telegrams from Db.
*
* @param a_counter
*/
void ackCentralTelegrams(int32_t a_counter);
N_CoPrtCnv::CoPrtCnvCentralTelegram *getNextCentralTelegram(PrtCnvStoredCentralTelegram *& a_handle);
/**
* returns the next telegram to send to central.
* returns NULL if no telegram found.
* ATTENTION: The caller is responsible to deallocate the returned
* centralTelegram!
*
* @param a_handle
*/
N_CoPrtCnv::CoPrtCnvCentralTelegram *getNextCentralTelegram(PrtCnvStoredCentralTelegram *&a_handle);
/**
* Marks the central-telegram as to be sent
*
* @param a_counter The counter the telegram has while sent
* @param a_handle The telegram-handle gotten from getNextCentralTelegram()
*/
void centralTelegramSent(const int32_t a_counter, PrtCnvStoredCentralTelegram *a_handle);
/**
* Updates the counter for unsuccessful sending the telegram. If a maximal value
* of this counter is reached, the central-telegram will be deleted.
* a_handle could be deleted after calling this function!
* This function could block some milliseconds, because it must wait until all
* changes are written to DB.
*
* @param a_handle The telegram-handle gotten from getNextCentralTelegram()
*/
void centralTelegramCouldNotBeSent(PrtCnvStoredCentralTelegram *a_handle);
/**
* Marks the radio-telegram as to be sent
*
* @param a_sendCounter
* @param a_handle
* @param a_broadcastIndex
*/
void radioTelegramSent(const uint32_t a_sendCounter, PrtCnvStoredRadioTelegram *a_handle, const uint32_t a_broadcastIndex);
/**
* returns the next telegram to send to radio, respecting the priority.
* returns NULL if no radio-telegram found.
*
* @param a_handle
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextRadioTelegram(PrtCnvStoredRadioTelegram *&a_handle);
/**
* returns the next broadcast-telegram from list.
* Deletes the telegram from this list.
* returns NULL if list empty.
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextBroadcastTelegram();
void storeCentralTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> &a_centralTelegram,
const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
/**
* stores the telegram to be sent to central in working-list and also in Db.
* Because storing data in XDR_Wrapper_it-format is complicated (has pointer to
* data), we store them in the radio-telegram-format).
* Attention: Be aware that centralTelegram and radioTelegram contain the same
* data.
* The DbThread takes control over centralTelegram and radioTelegram and deletes
* them when no longer needed.
*
* @param a_centralTelegram
* @param a_radioTelegram Must be the same telegram like the central-telegram
* (used for storing the telegram in Db)
*/
void storeCentralTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> &a_centralTelegram, const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
/**
* Stores the telegram to be sent to radio in working-list and also in Db.
* The DbThread takes control over a_telegram and deletes it when no longer needed.
*
*
* @param a_telegram
* @param a_readCounter
*/
void storeRadioTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram, const int32_t a_readCounter);
/**
* This function causes acking a central-telegram, which must not be stored
* permanent in Db, because it will be handled immediately (i.e.
* AnforderungStatistikBroadcastNachforderungen).
*
* @param a_centralCounter The read-counter of the central-telegram
*/
void centralCounterReadyForAck(const int32_t a_centralCounter);
/**
* Adds an sql-command in the sql-command-list. On next iteration of
* storePermanent() all command in list will be executed.
*
* @param a_sqlCommand
*/
void addSqlCommand(const QString &sql);
/**
* erases and initializes the database
*/
void cleanAndInit();
/**
* Checks whether central-telegrams have to be resent. If yes, all actions will be
* done, that getNextCentralTelegram() delivers the telegram(s) to be resent.
* Returns true if there must telegrams be resent.
*
* @param a_lastSendCounter The counter of the telegram we expect a ack-
* telegram has been received
*/
bool resendCentralTelegrams(const int32_t a_lastSendCounter);
/**
* Prepares the telegrams not yet acked from central for reconnection. This will
* be done by setting the write-counter to 0.
*/
void prepareCentralTelegramsForReconnection();
/**
* Blocks until all SQL-commands were written to DB.
*/
void waitUntilDbWritten();
/**
* returns NULL if no member found
*
* @param a_ISSI
*/
PrtCnvMember *getMemberByISSI(const uint32_t a_ISSI) const;
PrtCnvMember* getMemberByISSI(const uint32_t a_ISSI) const;
PrtCnvMember* getMemberById(const uint16_t a_id);
/**
* returns NULL if member not found
*
* @param a_id
*/
PrtCnvMember *getMemberById(const uint16_t a_id);
/**
* Licenses the member
*
* @param a_member
* @param a_doLicense
*/
bool licenseMember(PrtCnvMember *a_member, const bool a_doLicense = true);
/**
* Updates the current exercise for this member
*/
void updateExerciseIdForMember(PrtCnvMember *a_member, int newExerciseId);
/**
* adds a member in the 2 maps, sorted by id and ISSI
* returns the new member
*
* @param a_identity
* @param a_ISSI
*/
PrtCnvMember *addMember(const int a_identity, const int a_ISSI);
PrtCnvMember* addMember(const int a_identity, const int a_ISSI);
void removeMember(PrtCnvMember* a_member);
/**
* removes the member in the 2 maps, sorted by id and ISSI
*
* @param a_member
*/
void removeMember(PrtCnvMember *a_member);
/**
* Returns the actual reset-counter
*/
uint8_t getResetCounter() const;
/**
* Sets the actual reset-counter
*
* @param newVal
*/
void setResetCounter(uint8_t newVal);
/**
* The actual 'Betriebszustaende Gefechtsfeld' which will be sent to TNEs
* periodically
*/
uint8_t getBattleFieldOperatingState() const;
/**
* Sets or unsets pause, depending on a_doSet.
* (Bit 0 in UMGEBUNGS_MELDUNG(2))
* @param a_doSet
*/
void setPause(const bool a_doSet = true);
/**
* Set the inhibit time for position telegrams (1 .. 31 Seconds)
* (Bit 1-5 in UMGEBUNGS_MELDUNG(2))
* @param a_doSet
*/
void setPositionSendTime(unsigned int sendTime);
/**
* Set the current air load to be sent with the Umgebungsmeldung
* (Bit 6-7 in UMGEBUNGS_MELDUNG(2))
* @param airLoad The current air-load received from Tetra
*/
void setAirLoad(PrtCnvRadioThread::E_TrafficLoad airLoad);
/**
* Returns true if the resetCounter itself is different than the reset-counter of
* the environment-telegram
*/
bool isEnvironmentResetCounterOld() const;
/**
* Returns the actual Umgebungsmeldung
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getEnvironmentTelegram();
/**
* Sets the resetcounter of the environment-telegram to the actual reset-counter.
*/
void setResetCounterOnEnvironment();
/**
* Increments the counter for nachforderungen of the TNE with id a_identity.
*
* @param a_identity The identity of the TNE, which asked for nachforderung
*/
void incClaimCount(int a_identity);
/**
* Fills the map with nachforderungsstatistic.
* Returns the number of elements in map.
*
* @param a_statisticMap this map will be filled with pairs of
* ausstattungsnummer and amount of nachforderungen
*/
std::map<int32_t, int32_t> getClaimStatistics() const;
/**
* Sets the actual machine-state permanent, used to proceed cleaning db after a
* crash.
*
* @param a_newMachineState The new machine-state. 0 => working; 1 => cleaning
* DB
*/
void setMachineState(const int a_newMachineState);
/**
* Returns true if protocol-converter was crashed while cleanup DB.
*/
bool mustProceedCleanup() const;
protected:
void closeDb();
/**
* List of telegrams to be sent to central
*/
std::vector<PrtCnvStoredCentralTelegram *> m_CentralList;
std::vector<PrtCnvStoredCentralTelegram*> m_CentralList;
mutable QRecursiveMutex m_BattleFieldOpStateMutex;
mutable QRecursiveMutex m_MemberListByIdMutex;
mutable QRecursiveMutex m_CentralListMutex;
/**
* The permanent DB
*/
QSqlDatabase m_db;
/**
* The last counter received from central as ack. Used for deleting no longer used
* central-telegrams and for resending of central-telegrams.
*/
QAtomicInt m_CentralAckCounter;
/**
* Used for optimizing deletion of no longer needed central-telegrams.
*/
unsigned int m_OldCentralAckCounter;
/**
* List of telegrams to be sent to radio
*/
std::list<PrtCnvStoredRadioTelegram *> m_RadioList;
std::list<PrtCnvStoredRadioTelegram*> m_RadioList;
mutable QRecursiveMutex m_RadioListMutex;
std::vector<QString> m_SqlCommandList;
mutable QRecursiveMutex m_SqlCmdListMutex;
mutable QRecursiveMutex m_BroadcastMapMutex;
std::list<PrtCnvStoredRadioTelegram*> m_BroadcastList;
std::list<PrtCnvStoredRadioTelegram *> m_BroadcastList;
/**
* Used to wait until cleaning is finished and to suppress storing data within
* database while cleaning
*/
bool m_DoClean;
/**
* Used for waiting data written to DB
*/
bool m_DoWaitUntilSqlWritten;
std::unordered_map<int,PrtCnvMember*> m_MemberListById;
std::unordered_map<int,PrtCnvMember*> m_MemberListByISSI;
/**
* Holds all logged in members ordered by Id.
*/
std::unordered_map<int, PrtCnvMember *> m_MemberListById;
/**
* Holds all logged in members ordered by ISSI
*/
std::unordered_map<int, PrtCnvMember *> m_MemberListByISSI;
/**
* Used to prevent data storing within DB while restoring after crash
*/
bool m_DoStorePermanent;
/**
* the actual reset-counter
*/
uint8_t m_ResetCounter;
/**
* The actual 'Betriebszustaende Gefechtsfeld' which will be sent to TNEs
* periodically
*/
uint8_t m_BattleFieldOperatingState;
PrtCnvStoredRadioTelegram* m_EnvironmentTelegram;
/**
* The actual telegram "Umgebungsmeldung"
*/
PrtCnvStoredRadioTelegram *m_EnvironmentTelegram;
/**
* True if cleanup has to be proceed after crash.
*/
bool m_DoProceedCleanup;
/**
* Used to optimize send the signal permanentStored
*/
int32_t m_OldCentralCounter;
/**
* For ensure that not too much storePermanent-signals will be queued
*/
QBasicAtomicInt m_StorePermanentPending;
/**
* nbr of unsuccessful send-attempts, before telegram will be deleted without
* sending it
*/
uint32_t m_NbrOfAttempts;
/**
* creates or restores the permanent database
*/
bool createDatabase();
/**
* Sends a signal storePermanent if not already such a signal is pending
*/
void sendStorePermanentSignal();
/**
* Helper for storePermanent()
*/
void storeCentralTelegrams();
/**
* Helper for storePermanent()
*/
int32_t storeRadioTelegrams();
/**
* Helper for storePermanent()
*/
void handleSqlCommandList();
/**
* Delete all telegrams with the ids in telegramsToDelete
* from a given table
*/
void deleteTelegramsFromDbById(const QString &table);
/**
* Update the write counter for the telegrams in
* telegramsToUpdateCounter for the given table
*/
void updateTelegramsWriteCounter(const QString &table);
/**
* Update the broadcast counter for the telegrams in
* telegramsToUpdateCounter for the given table
*/
void updateTelegramsBroadcast(const QString &table);
/**
* Reinitialize the database
*/
void reinitDatabase();
QString toCentralTableName() const { return tableName(QStringLiteral("prtcnv_to_central")); }
@@ -332,35 +499,43 @@ namespace PrtCnv
QString versionTableName() const { return tableName(QStringLiteral("prtcnv_version")); }
QString tableName(const QString &table) const { return m_dbSchemaName.isEmpty() ? table : m_dbSchemaName + QLatin1Char('.') + table; }
protected slots:
/**
* Stores the radio-telegrams, central-telegrams in Db and executes the sql-
* command-list.
*/
void storePermanent();
/**
* cleans up this thread and its childs
*/
void clean();
public:
signals:
/**
* Signal to call storePermanent()
*/
void doStorePermanent();
/**
* Signal to inform central-thread about stored telegrams
*
* @param a_centralCounter
*/
void permanentStored(int32_t a_centralCounter);
/**
* a signal to erase the permanent database
*/
void doClean();
void playerLicencedChanged(int equipNo, N_CoPrtCnv::E_LicensingKind kind);
private:
// local caches to memory (re)allocation all the time
// note: std::vector.clear() does not release memory and therefore
// a reallocation in the next turn is not neccessary
std::vector<int64_t> m_telegramsToDelete;
std::vector<std::pair<int64_t, int32_t> > m_telegramsToUpdateCounter;
std::vector<std::pair<int64_t, int32_t> > m_telegramsToUpdateBC;
std::vector<std::pair<PrtCnvStoredCentralTelegram*, int64_t> > m_telegramsToInsert;
std::vector<std::pair<int64_t, int32_t>> m_telegramsToUpdateCounter;
std::vector<std::pair<int64_t, int32_t>> m_telegramsToUpdateBC;
std::vector<std::pair<PrtCnvStoredCentralTelegram *, int64_t>> m_telegramsToInsert;
QString m_dbDriver;
QString m_dbHostName;
QString m_dbDatabaseName;
@@ -1,17 +1,17 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
// manual class headers
#include "PrtCnvInjectionSocket.hpp"
#include <CoPrtCnv/CoPrtCnvInjectionHeader.hpp>
#include <CoPrtCnv/CoPrtCnvCentralTelegram.hpp>
@@ -22,64 +22,63 @@
namespace PrtCnv
{
PrtCnvInjectionSocket::PrtCnvInjectionSocket()
: m_Socket(nullptr)
, m_Server(nullptr)
, m_logger(getLogger("PrtCnvInjectionSocket"))
{}
PrtCnvInjectionSocket::~PrtCnvInjectionSocket()
{
delete m_Socket;
}
void PrtCnvInjectionSocket::disconnectClient()
{
INFO_LOG(m_logger) << "A client has disconnected from the injection-server";
emit disconnected(this);
}
void PrtCnvInjectionSocket::processInputData()
{
INFO_LOG(m_logger) << "Injection-server has data received";
N_CoPrtCnv::CoPrtCnvInjectionHeader injectionHeader;
qint64 bytesRead = m_Socket->peek((char*)&injectionHeader, sizeof(injectionHeader));
if (sizeof(injectionHeader) == bytesRead)
PrtCnvInjectionSocket::PrtCnvInjectionSocket()
: m_Socket(nullptr)
, m_Server(nullptr)
, m_logger(getLogger("PrtCnvInjectionSocket"))
{
if (injectionHeader.isIdCorrect())
}
PrtCnvInjectionSocket::~PrtCnvInjectionSocket()
{
delete m_Socket;
}
// ---------------------------------------------------------------
// Disconnects a TCP-client
// ---------------------------------------------------------------
void PrtCnvInjectionSocket::disconnectClient()
{
INFO_LOG(m_logger) << "A client has disconnected from the injection-server";
emit disconnected(this);
}
// ---------------------------------------------------------------
// Reads in TCP-data and handles them
// ---------------------------------------------------------------
void PrtCnvInjectionSocket::processInputData()
{
INFO_LOG(m_logger) << "Injection-server has data received";
N_CoPrtCnv::CoPrtCnvInjectionHeader injectionHeader;
qint64 bytesRead = m_Socket->peek((char *)&injectionHeader, sizeof(injectionHeader));
if (sizeof(injectionHeader) == bytesRead)
{
qint64 available = m_Socket->bytesAvailable();
if (available < qint64(injectionHeader.m_Size + sizeof(injectionHeader)))
{
INFO_LOG(m_logger) << "not enough bytes available - waiting for more data: "
<< "headersize=" << sizeof(injectionHeader) << " id1="
<< injectionHeader.m_Id1 << " id2=" << injectionHeader.m_Id2
<< " kind=" << (int)injectionHeader.m_Kind << " size="
<< injectionHeader.m_Size;
return;
}
m_Socket->read((char*)&injectionHeader, sizeof(injectionHeader));
if (injectionHeader.isIdCorrect())
{
QByteArray data(injectionHeader.m_Size, Qt::Uninitialized);
m_Socket->read(data.data(), injectionHeader.m_Size);
switch (injectionHeader.m_Kind)
// check whether all bytes are available
qint64 available = m_Socket->bytesAvailable();
if (available < qint64(injectionHeader.m_Size + sizeof(injectionHeader)))
{
case N_CoPrtCnv::CoPrtCnvInjectionHeader::eCentral:
case N_CoPrtCnv::CoPrtCnvInjectionHeader::eRadio:
INFO_LOG(m_logger) << "not enough bytes available - waiting for more data: "
<< "headersize=" << sizeof(injectionHeader) << " id1=" << injectionHeader.m_Id1 << " id2=" << injectionHeader.m_Id2
<< " kind=" << (int)injectionHeader.m_Kind << " size=" << injectionHeader.m_Size;
return; // try it later, when (maybe) enough bytes are available...
}
// enough bytes => read now all in
m_Socket->read((char *)&injectionHeader, sizeof(injectionHeader));
if (injectionHeader.isIdCorrect())
{
//INFO_LOG(m_logger) << "kind=" << (int)injectionHeader.m_Kind << " size=" << injectionHeader.m_Size;
// read the data
QByteArray data(injectionHeader.m_Size, Qt::Uninitialized);
m_Socket->read(data.data(), injectionHeader.m_Size);
switch (injectionHeader.m_Kind)
{
case N_CoPrtCnv::CoPrtCnvInjectionHeader::eCentral:
case N_CoPrtCnv::CoPrtCnvInjectionHeader::eRadio:
{
N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = new N_CoPrtCnv::CoPrtCnvCentralTelegram(data);
@@ -97,31 +96,31 @@ void PrtCnvInjectionSocket::processInputData()
}
break;
default:
ERROR_LOG(m_logger) << "Unknown kind (" << injectionHeader.m_Kind << ") of injection-telegram";
break;
default:
ERROR_LOG(m_logger) << "Unknown kind (" << injectionHeader.m_Kind << ") of injection-telegram";
break;
}
}
}
}
else
{
ERROR_LOG(m_logger) << "Corrupt injection-telegram received => reconnect";
m_Socket->disconnectFromHost();
else
{
ERROR_LOG(m_logger) << "Corrupt injection-telegram received => reconnect";
m_Socket->disconnectFromHost();
}
}
}
}
void PrtCnvInjectionSocket::setSocket(QTcpSocket* a_socket, PrtCnvInjectionThread* a_server)
{
m_Socket = a_socket;
m_Server = a_server;
connect(this, &PrtCnvInjectionSocket::disconnected, m_Server, &PrtCnvInjectionThread::disconnectClient, Qt::QueuedConnection);
if (m_Socket)
// ---------------------------------------------------------------
void PrtCnvInjectionSocket::setSocket(QTcpSocket *a_socket, PrtCnvInjectionThread *a_server)
{
connect(m_Socket, &QTcpSocket::readyRead, this, &PrtCnvInjectionSocket::processInputData, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::disconnected, this, &PrtCnvInjectionSocket::disconnectClient, Qt::QueuedConnection);
m_Socket = a_socket;
m_Server = a_server;
connect(this, &PrtCnvInjectionSocket::disconnected, m_Server, &PrtCnvInjectionThread::disconnectClient, Qt::QueuedConnection);
if (m_Socket)
{
connect(m_Socket, &QTcpSocket::readyRead, this, &PrtCnvInjectionSocket::processInputData, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::disconnected, this, &PrtCnvInjectionSocket::disconnectClient, Qt::QueuedConnection);
}
}
}
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
#pragma once
#include <QtCore/QObject>
@@ -21,19 +21,26 @@ class QTcpSocket;
namespace PrtCnv
{
class PrtCnvInjectionThread;
/**
* Used for receiving the socket signals
*
* @author alois.wismer
* @version 1.0
* @created 06-Aug-2010 16:41:44
*/
class PrtCnvInjectionSocket : public QObject
{
Q_OBJECT
public:
PrtCnvInjectionSocket();
~PrtCnvInjectionSocket();
void setSocket(QTcpSocket* a_socket, PrtCnvInjectionThread* a_server);
/**
*
* @param a_socket
* @param a_server
*/
void setSocket(QTcpSocket *a_socket, PrtCnvInjectionThread *a_server);
protected:
QTcpSocket *m_Socket;
@@ -42,22 +49,24 @@ namespace PrtCnv
NGL::INGLLogger &m_logger;
protected slots:
/**
* Disconnects a TCP-client
*/
void disconnectClient();
/**
* Reads in TCP-data and handles them
*/
void processInputData();
public:
signals:
void disconnected(PrtCnvInjectionSocket* a_injectSocket);
/**
*
* @param a_injectSocket
*/
void disconnected(PrtCnvInjectionSocket *a_injectSocket);
};
}
@@ -1,17 +1,17 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
// manual class headers
#include "PrtCnvInjectionThread.hpp"
#include "PrtCnvInjectionSocket.hpp"
@@ -23,160 +23,155 @@
namespace PrtCnv
{
PrtCnvInjectionThread::PrtCnvInjectionThread(PrtCnvThreadStarter* a_parent)
: PrtCnvThread(a_parent, "PrtCnvInjectionThread")
, m_Port(46666)
, m_Enabled(false)
, m_Server(nullptr)
, m_CentralListMutex(nullptr)
, m_RadioListMutex(nullptr)
{
m_Name = QStringLiteral("Injection");
}
PrtCnvInjectionThread::~PrtCnvInjectionThread()
{
delete m_CentralListMutex;
delete m_RadioListMutex;
}
int32_t PrtCnvInjectionThread::create(NGL::Settings *settings)
{
INFO_LOG(m_logger) << "create";
PrtCnvThread::create(settings);
m_CentralListMutex = new QMutex;
m_RadioListMutex = new QMutex;
m_Enabled = m_Config->getBoolean(getName(), QStringLiteral("Enable"), false);
if (m_Enabled)
// ---------------------------------------------------------------
PrtCnvInjectionThread::PrtCnvInjectionThread(PrtCnvThreadStarter *a_parent)
: PrtCnvThread(a_parent, "PrtCnvInjectionThread")
, m_Port(46666)
, m_Enabled(false)
, m_Server(nullptr)
, m_CentralListMutex(nullptr)
, m_RadioListMutex(nullptr)
{
m_Server = new QTcpServer(this);
if (m_Server)
connect(m_Server, &QTcpServer::newConnection, this, &PrtCnvInjectionThread::connectClient, Qt::QueuedConnection);
m_Name = QStringLiteral("Injection");
}
return 0;
}
int32_t PrtCnvInjectionThread::init()
{
INFO_LOG(m_logger) << "init";
PrtCnvThread::init();
m_Port = m_Config->getInteger(getName(), QStringLiteral("Port"), 46666);
return 0;
}
int32_t PrtCnvInjectionThread::start()
{
INFO_LOG(m_logger) << "Start";
PrtCnvThread::start();
if (m_Enabled)
PrtCnvInjectionThread::~PrtCnvInjectionThread()
{
m_Server->setMaxPendingConnections(1);
m_Server->listen(QHostAddress::Any, m_Port);
INFO_LOG(m_logger) << "Injection-Server is listening on port " << m_Port;
delete m_CentralListMutex;
delete m_RadioListMutex;
}
return 0;
}
// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::create(NGL::Settings *settings)
{
INFO_LOG(m_logger) << "create";
PrtCnvThread::create(settings);
m_CentralListMutex = new QMutex;
m_RadioListMutex = new QMutex;
m_Enabled = m_Config->getBoolean(getName(), QStringLiteral("Enable"), false);
// prepare a tcp-server for simulating central
if (m_Enabled)
{
m_Server = new QTcpServer(this);
if (m_Server)
connect(m_Server, &QTcpServer::newConnection, this, &PrtCnvInjectionThread::connectClient, Qt::QueuedConnection);
}
return 0;
}
// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::init()
{
INFO_LOG(m_logger) << "init";
PrtCnvThread::init();
m_Port = m_Config->getInteger(getName(), QStringLiteral("Port"), 46666);
return 0;
}
// ---------------------------------------------------------------
// Starts the thread and listen for TCP-clients
// ---------------------------------------------------------------
int32_t PrtCnvInjectionThread::start()
{
INFO_LOG(m_logger) << "Start";
PrtCnvThread::start();
// start the TCP-server
if (m_Enabled)
{
m_Server->setMaxPendingConnections(1);
m_Server->listen(QHostAddress::Any, m_Port);
INFO_LOG(m_logger) << "Injection-Server is listening on port " << m_Port;
}
return 0;
}
void PrtCnvInjectionThread::connectClient()
{
INFO_LOG(m_logger) << "A client has connected to the injection-server";
PrtCnvInjectionSocket* injectSocket = new PrtCnvInjectionSocket;
m_SocketList.insert(injectSocket);
INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
injectSocket->setSocket(m_Server->nextPendingConnection(), this);
}
// ---------------------------------------------------------------
// Connects a TCP-client
// ---------------------------------------------------------------
void PrtCnvInjectionThread::connectClient()
{
INFO_LOG(m_logger) << "A client has connected to the injection-server";
PrtCnvInjectionSocket *injectSocket = new PrtCnvInjectionSocket;
m_SocketList.insert(injectSocket);
INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
injectSocket->setSocket(m_Server->nextPendingConnection(), this);
}
// ---------------------------------------------------------------
// Disconnects a TCP-client
// ---------------------------------------------------------------
void PrtCnvInjectionThread::disconnectClient(PrtCnvInjectionSocket *a_injectionSocket)
{
auto it = m_SocketList.find(a_injectionSocket);
if (it != m_SocketList.end())
m_SocketList.erase(it);
INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
delete a_injectionSocket;
}
// ---------------------------------------------------------------
// Returns the next central-telegram to be injected. It will
// automatically be taken out of the list.
// The caller is responsible to delete the telegram, if no
// longer used.
// Returns NULL if no central-telegram available
// ---------------------------------------------------------------
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextCentralInjectionTelegram()
{
QMutexLocker l(m_CentralListMutex);
if (m_CentralTelegramList.empty())
return nullptr;
auto centralTelegram = m_CentralTelegramList.front();
m_CentralTelegramList.pop();
return centralTelegram;
}
void PrtCnvInjectionThread::disconnectClient(PrtCnvInjectionSocket *a_injectionSocket)
{
auto it = m_SocketList.find(a_injectionSocket);
if (it != m_SocketList.end())
m_SocketList.erase(it);
INFO_LOG(m_logger) << "Now are " << m_SocketList.size() << " injection-client(s) connected";
delete a_injectionSocket;
}
// ---------------------------------------------------------------
// Returns the next radio-telegram to be injected. It will
// automatically be taken out of the list.
// The caller is responsible to delete the telegram, if no
// longer used.
// Returns NULL if no radio-telegram available
// ---------------------------------------------------------------
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextRadioInjectionTelegram()
{
QMutexLocker l(m_RadioListMutex);
if (m_RadioTelegramList.empty())
return nullptr;
auto radioTelegram = m_RadioTelegramList.front();
m_RadioTelegramList.pop();
return radioTelegram;
}
// ---------------------------------------------------------------
void PrtCnvInjectionThread::addToCentralList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
QMutexLocker l(m_CentralListMutex);
m_CentralTelegramList.push(a_telegram);
}
// ---------------------------------------------------------------
void PrtCnvInjectionThread::addToRadioList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
QMutexLocker l(m_RadioListMutex);
m_RadioTelegramList.push(a_telegram);
}
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextCentralInjectionTelegram()
{
QMutexLocker l(m_CentralListMutex);
if (m_CentralTelegramList.empty())
return nullptr;
auto centralTelegram = m_CentralTelegramList.front();
m_CentralTelegramList.pop();
return centralTelegram;
}
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvInjectionThread::getNextRadioInjectionTelegram()
{
QMutexLocker l(m_RadioListMutex);
if (m_RadioTelegramList.empty())
return nullptr;
auto radioTelegram = m_RadioTelegramList.front();
m_RadioTelegramList.pop();
return radioTelegram;
}
void PrtCnvInjectionThread::addToCentralList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
QMutexLocker l(m_CentralListMutex);
m_CentralTelegramList.push(a_telegram);
}
void PrtCnvInjectionThread::addToRadioList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram)
{
QMutexLocker l(m_RadioListMutex);
m_RadioTelegramList.push(a_telegram);
}
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
#pragma once
#include "PrtCnvThread.hpp"
@@ -22,24 +22,33 @@ class QMutex;
namespace N_CoPrtCnv
{
class CoPrtCnvCentralTelegram;
class CoPrtCnvCentralTelegram;
}
namespace PrtCnv
{
class PrtCnvInjectionSocket;
/**
* This class represents a thread, which acts as TCP-Server. The LogView-
* application can connect to it and send radio- or central-telegrams. The
* telegrams will be stored within this class and can be taken by another thread.
* This mechanism will be used for inject telegrams to protocol-converter.
*
* @author alois.wismer
* @version 1.0
* @created 05-Aug-2010 11:17:06
*/
class PrtCnvInjectionThread : public PrtCnvThread
{
Q_OBJECT
public:
~PrtCnvInjectionThread();
explicit PrtCnvInjectionThread(PrtCnvThreadStarter* a_parent);
/**
*
* @param a_parent
*/
explicit PrtCnvInjectionThread(PrtCnvThreadStarter *a_parent);
int32_t create(NGL::Settings *settings) override;
@@ -47,31 +56,48 @@ namespace PrtCnv
int32_t init() override;
/**
* Starts the thread and listen for TCP-clients
*/
int32_t start() override;
/**
* Returns the next central-telegram to be injected. It will automatically be
* taken out of the list.
* The caller is responsible to delete the telegram, if no longer used.
* Returns NULL if no central-telegram available
*/
N_CoPrtCnv::CoPrtCnvCentralTelegram *getNextCentralInjectionTelegram();
/**
* Returns the next radio-telegram to be injected. It will automatically be taken
* out of the list.
* The caller is responsible to delete the telegram, if no longer used.
* Returns NULL if no radio-telegram available
*/
N_CoPrtCnv::CoPrtCnvCentralTelegram *getNextRadioInjectionTelegram();
/**
*
* @param a_telegram
*/
void addToCentralList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
/**
*
* @param a_telegram
*/
void addToRadioList(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_telegram);
protected:
protected: /**
* The port of the injection-server (configurable with key 'Port' in group
* [Injection])
*/
uint16_t m_Port;
/**
* true if injection-server is enabled (configurable with key 'Enable' in group
* [Injection])
*/
bool m_Enabled;
QTcpServer *m_Server;
@@ -84,18 +110,20 @@ namespace PrtCnv
QMutex *m_RadioListMutex;
std::set<PrtCnvInjectionSocket*> m_SocketList;
std::set<PrtCnvInjectionSocket *> m_SocketList;
public slots:
void connectClient();
void disconnectClient(PrtCnvInjectionSocket* a_injectionSocket);
/**
* Connects a TCP-client
*/
void connectClient();
/**
* Disconnects a TCP-client
*
* @param a_injectionSocket
*/
void disconnectClient(PrtCnvInjectionSocket *a_injectionSocket);
};
}
@@ -1,18 +1,24 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
/*!
*
* \page Tetra-Interface Tetra-Interface
*
* This component is needed to communicate between the Server software and the players in
* the field via Tetra. It's an extra component due to historical reasons only.
*
*/
#include "PrtCnvApplication.hpp"
#include <NGLLogger/INGLLogger.h>
@@ -25,49 +31,54 @@
#include <unistd.h>
#endif
// ---------------------------------------------------------------
// Become a daemon
// ---------------------------------------------------------------
static void daemonize()
{
#ifndef WIN32
pid_t pid, sid;
if ( getppid() == 1 )
/* already a daemon */
if (getppid() == 1)
return;
/* Fork off the parent process */
pid = fork();
if (pid < 0) {
if (pid < 0)
{
exit(EXIT_FAILURE);
}
if (pid > 0) {
/* If we got a good PID, then we can exit the parent process. */
if (pid > 0)
{
exit(EXIT_SUCCESS);
}
/* At this point we are executing as the child process */
/* Change the file mode mask */
umask(0);
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
if (sid < 0)
{
exit(EXIT_FAILURE);
}
if ((chdir("/")) < 0) {
/* Change the current working directory. This prevents the current
directory from being locked; hence not being able to remove it. */
if ((chdir("/")) < 0)
{
exit(EXIT_FAILURE);
}
freopen( "/dev/null", "r", stdin);
freopen( "/dev/null", "w", stdout);
freopen( "/dev/null", "w", stderr);
if (freopen("/dev/null", "r", stdin) == nullptr || freopen("/dev/null", "w", stdout) == nullptr || freopen("/dev/null", "w", stderr) == nullptr)
{
exit(EXIT_FAILURE);
}
#endif
}
@@ -75,25 +86,17 @@ class CmdLineParser : public LtsCommandLineParser::LtsCommandLineParser
{
public:
CmdLineParser()
: LtsCommandLineParser(ProvideCommandLineParameterOptions(ExerciseId|CustomConfigFile))
: LtsCommandLineParser(ProvideCommandLineParameterOptions(ExerciseId | CustomConfigFile))
{
addOption( { QStringList() << QStringLiteral("d") << QStringLiteral("daemonize"),
QStringLiteral("Start in background") } );
addOption( { QStringList() << QStringLiteral("c") << QStringLiteral("cleandb"),
QStringLiteral("Start over with clean database") } );
addOption({QStringList() << QStringLiteral("d") << QStringLiteral("daemonize"), QStringLiteral("Start in background")});
addOption({QStringList() << QStringLiteral("c") << QStringLiteral("cleandb"), QStringLiteral("Start over with clean database")});
}
bool daemonize() const
{
return isSet(QStringLiteral("d"));
}
bool cleanDb() const
{
return isSet(QStringLiteral("c"));
}
bool daemonize() const { return isSet(QStringLiteral("d")); }
bool cleanDb() const { return isSet(QStringLiteral("c")); }
};
int main(int argc, char** argv)
int main(int argc, char **argv)
{
QNetworkProxy::setApplicationProxy(QNetworkProxy());
NGLCoreApplication app(argc, argv);
@@ -1,98 +1,97 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
// manual class headers
#include "PrtCnvMember.hpp"
#include <CoPrtCnv/CoPrtCnvRadioTelegram.hpp>
namespace PrtCnv
{
PrtCnvMember::PrtCnvMember(int a_id, int a_issi)
: m_ISSI(a_issi)
, m_ClaimCount(0)
, m_loggedInExerciseId(0)
, m_Id(a_id)
, m_Licensed(false)
{}
PrtCnvMember::~PrtCnvMember()
{
clearFragmentedList();
}
void PrtCnvMember::addFragmentedTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram)
{
m_FragmentedTelegramList.insert(std::make_pair(a_radioTelegram.getFragmentCounter(),
new N_CoPrtCnv::CoPrtCnvRadioTelegram(a_radioTelegram)));
}
gef_telegramm_id_et PrtCnvMember::getFragmentedTelegramId() const
{
for (auto rit = m_FragmentedTelegramList.rbegin(); rit != m_FragmentedTelegramList.rend(); ++rit)
// ---------------------------------------------------------------
// Constructor with id and ISSI as parameter
// ---------------------------------------------------------------
PrtCnvMember::PrtCnvMember(int a_id, int a_issi)
: m_ISSI(a_issi)
, m_ClaimCount(0)
, m_loggedInExerciseId(0)
, m_Id(a_id)
, m_Licensed(false)
{
N_CoPrtCnv::CoPrtCnvRadioTelegram *firstFragment = rit->second;
if (N_CoPrtCnv::CoPrtCnvRadioTelegram::e_FirstFragment == firstFragment->getFragmentStatus())
return firstFragment->getTelID();
}
return GEF_BESTAETIGUNG;
}
PrtCnvMember::~PrtCnvMember()
{
clearFragmentedList();
}
// ---------------------------------------------------------------
// Adds a radio-telegram-fragment to this member.
// ---------------------------------------------------------------
void PrtCnvMember::addFragmentedTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram)
{
m_FragmentedTelegramList.insert(std::make_pair(a_radioTelegram.getFragmentCounter(), new N_CoPrtCnv::CoPrtCnvRadioTelegram(a_radioTelegram)));
}
// ---------------------------------------------------------------
// Returns the telegram-Id of the fragmented telegram assiged
// to this member.
// If not evaluable: 0 will be returned.
// ---------------------------------------------------------------
gef_telegramm_id_et PrtCnvMember::getFragmentedTelegramId() const
{
// the fragment with the highest counter is the first fragment
for (auto rit = m_FragmentedTelegramList.rbegin(); rit != m_FragmentedTelegramList.rend(); ++rit)
{
N_CoPrtCnv::CoPrtCnvRadioTelegram *firstFragment = rit->second;
if (N_CoPrtCnv::CoPrtCnvRadioTelegram::e_FirstFragment == firstFragment->getFragmentStatus())
return firstFragment->getTelID();
}
return GEF_BESTAETIGUNG; // no telegram found => return 0 (= GEF_BESTAETIGUNG)
}
void PrtCnvMember::clearFragmentedList()
{
for (auto it : m_FragmentedTelegramList)
delete it.second;
m_FragmentedTelegramList.clear();
}
// ---------------------------------------------------------------
// Erases the radio-telegram-fragments assiged to this member.
// The fragments itself will be deleted.
// ---------------------------------------------------------------
void PrtCnvMember::clearFragmentedList()
{
for (auto it : m_FragmentedTelegramList)
delete it.second;
m_FragmentedTelegramList.clear();
}
// ---------------------------------------------------------------
// Returns the radio-telegram-fragments assembled to a only
// big radio-telegram. The fragments will not be deleted.
// Returns NULL if it was impossible to assemble the telegram.
// ---------------------------------------------------------------
QByteArray PrtCnvMember::getUnfragmentedTelegramData() const
{
return N_CoPrtCnv::CoPrtCnvRadioTelegram::getUnfragmentedData(m_FragmentedTelegramList);
}
// ---------------------------------------------------------------
// Returns true if the fragment-list is empty
// ---------------------------------------------------------------
bool PrtCnvMember::isFragmentedListEmpty() const
{
return m_FragmentedTelegramList.empty();
}
QByteArray PrtCnvMember::getUnfragmentedTelegramData() const
{
return N_CoPrtCnv::CoPrtCnvRadioTelegram::getUnfragmentedData(m_FragmentedTelegramList);
}
bool PrtCnvMember::isFragmentedListEmpty() const
{
return m_FragmentedTelegramList.empty();
}
}
} // namespace PrtCnv
@@ -1,23 +1,23 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
#pragma once
#include <CoPrtCnv/tetra_telegram_ids.h>
#include <map>
#include <QtCore/QByteArray>
// manual class imports
namespace N_CoPrtCnv
@@ -27,14 +27,22 @@ namespace N_CoPrtCnv
namespace PrtCnv
{
/**
* Hold the data of a TNE (Client on radio-side) needed for login, licensing,
* nachforderungs-statistic and reading fragmented telegrams from TNE.
* @author wia
* @version 1.0
* @updated 16-Mrz-2010 11:20:11
*/
class PrtCnvMember final
{
public:
/**
* The status of the member
* @author wia
* @version 1.0
* @updated 16-Mrz-2010 11:20:11
*/
enum E_MemberStatus
{
e_Ok,
@@ -44,41 +52,56 @@ namespace PrtCnv
};
~PrtCnvMember();
/**
* Constructor with id and ISSI as parameter
*
* @param a_id
* @param a_issi
*/
PrtCnvMember(int a_id, int a_issi);
/**
* Adds a radio-telegram-fragment to this member.
*
* @param a_radioTelegram
*/
void addFragmentedTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
/**
* Returns the telegram-Id of the fragmented telegram assiged to this member.
* If not evaluable: 0 will be returned.
*/
gef_telegramm_id_et getFragmentedTelegramId() const;
/**
* Erases the radio-telegram-fragments assiged to this member. The fragments
* itself will be deleted.
*/
void clearFragmentedList();
/**
* Returns the radio-telegram-fragments assembled to a only big radio-telegram.
* The fragments will not be deleted.
* Returns NULL if it was impossible to assemble the telegram.
*/
QByteArray getUnfragmentedTelegramData() const;
/**
* Returns true if the fragment-list is empty
*/
bool isFragmentedListEmpty() const;
public:
// The ISSI of this TNE (0..0xFFFFFF)
int m_ISSI;
// Counts the Nachforderungen asked from this TNE
int m_ClaimCount;
// the exercise where the member is currently logged in
int m_loggedInExerciseId;
// The identification (also called Ausstattungs-Nummer) of this TNE (0..10000)
int m_Id;
// true if TNE is licensed
bool m_Licensed;
private:
std::multimap<uint16_t,N_CoPrtCnv::CoPrtCnvRadioTelegram*> m_FragmentedTelegramList;
// Map of radio-telegram-fragments ordered by fragment-number
std::multimap<uint16_t, N_CoPrtCnv::CoPrtCnvRadioTelegram *> m_FragmentedTelegramList;
};
}
File diff suppressed because it is too large. Load diff
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvRadioThread
// **************************************************************************
#pragma once
#include "PrtCnvSocketThread.hpp"
@@ -26,178 +26,236 @@
namespace PrtCnv
{
struct BiteError
{
int errorNumber = 0;
int canDeviceNumber = 0;
int subdeviceNumber = 0;
int uniqueId = 0;
};
struct BiteError
{
int errorNumber = 0;
int canDeviceNumber = 0;
int subdeviceNumber = 0;
int uniqueId = 0;
};
class PrtCnvCentralThread;
class PrtCnvMember;
class PrtCnvRadioTrafficThread;
class PrtCnvStoredRadioTelegram;
/**
* This class handles the protocol to radio. This includes:
* - handle login and licensing of TNEs
* - send and receive normal telegrams
* - send normal broadcasts and nachforderungen
* - optimize bandwith usage
*
* @author
* @version 1.0
* @created 05-Jan-2006 13:34:41
*/
class PrtCnvRadioThread : public PrtCnv::PrtCnvSocketThread
{
Q_OBJECT
public:
PrtCnvRadioThread(int exerciseId, PrtCnvThreadStarter* a_parent);
public:
PrtCnvRadioThread(int exerciseId, PrtCnvThreadStarter *a_parent);
/**
* Creates all subcomponents and connects signals to slots
*/
int32_t create(NGL::Settings *settings) override;
/**
* Deallocates subcomponents.
*/
int32_t destroy() override;
/**
* Initializes the variables.
*/
int32_t init() override;
/**
* Starts the thread and connects to TCP-server
*/
int32_t start() override;
/**
* Makes empty the message-queue faster, because the messages will be consumed
* without action.
*/
void prepareCleanUp();
/**
* Immediatelly send the environment telegramm to inform the players
* about the new state
*/
void sendEnvironmentTelegramTimerNow();
void exerciseEquipmentChanged(const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data);
protected:
void onCheckMemberForValidLogin(int identity, int issi);
void sendLoginAccept(int identity, int issi, int exerciseId, bool bWithMastering);
bool isIdentityInCurrentExercise(int identity) const;
int exerciseIdForIdentity(int identity) const;
void removeMasteringMember(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_loginTelegram, PrtCnvMember *member,
void removeMasteringMember(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_loginTelegram,
PrtCnvMember *member,
PrtCnvMember *issiMember,
int masterIdentity,
int masterIssi);
protected:
/**
* Pointer to central-thread
*/
PrtCnvCentralThread *m_CentralThread;
/**
* Pointer to radio traffic counter thread
*/
PrtCnvRadioTrafficThread *m_radioTrafficThread;
public:
public:
Q_SIGNALS:
/**
* Signal to start sending a telegram to central
*/
void checkSendToCentral();
/**
* Signal to start sending a telegram to radio
*/
void checkSendToRadio();
/**
* Signal to indicate thread has finished the cleaning-phase
*/
void cleant();
/**
* Signal to indicate thread has stopped work
*/
void stopped();
/**
* a new equipment exercise mapping was received, check if member (all when identiy = -1)
* is still in this exercise
*/
void checkMemberForValidLogin(int identity, int issi);
// emitted when the tetra connection state changes
void tetraConnectionState(bool connected);
// an effect siumlation was (de)activated
void areaEffectSimulationActivated(int wirkfeldKennung);
void areaEffectSimulationDeactivated(int wirkfeldKennung);
// initialization of the thread is finished
void initDone();
// a player was (un)licensed
void playerLicencedChanged(int equipNo, N_CoPrtCnv::E_LicensingKind kind);
void warehouseMessageFromPtrCnv(const QByteArray &jsonData);
protected:
/**
* Counts the sended telegrams
*/
uint32_t m_SendCounter;
/**
* The ISSI of the protocol-converter
*/
uint32_t m_HostISSI;
/**
* The lowest vaild value for the counter
*/
const uint32_t START_COUNTER;
/**
* One more than the highest vaild value for the counter
*/
const uint32_t END_COUNTER;
/**
* This timer will be used for periodically send the Umgebungsmeldung to TNEs
*/
QTimer *m_EnvironmentTelegramTimer;
/**
* The ISSI used for broadcast-telegrams
*/
uint32_t m_BroadcastISSI;
/**
* The directory and prefix for the login-log-file
*/
QString m_LoginPathWithPrefix;
/**
* Übungskennung (used for login-logfile name)
*/
int m_ExerciseId;
/**
* Bit-map for evaluating whether a playerid is valid
*/
std::set<uint16_t> m_AllowedIdentities;
/**
* true => TPU will be licensed whether selftest and configtest fails or not
*/
bool m_DoLicenseDespiteSelftestOrConfigFailure;
/**
* true => identify of TPU will be checked, whether allowed
*/
bool m_DoCheckIdentity;
PrtCnvBroadcastMgr m_BroadcastManager;
/**
* True => received telegrams will be dumped to common log-file
*/
bool m_DoDumpReceivedTelegrams;
/**
* True => sent telegrams will be dumped to common log-file
*/
bool m_DoDumpSentTelegrams;
/**
* True => radio-telegrams will be sent in SDS-TL-format
*/
bool m_DoUseSDSTL;
/**
* Identities that need an active position response after licensing
*/
std::set<uint16_t> m_DoNeedActPosResp;
/**
* The ISSI used for emergency call-telegrams
*/
uint32_t m_EmergencyCallISSI;
/**
* Sends a telegram to radio. It will be fragmented if needed. It will be checked,
* whether the receiver is logged in, licensed, the content is valid and the
* telegram is not expired and an error-message will be sent to central if needed.
* It will be tested, whether the maximal broadcast-counter is reached and if it
* is, the needed action will be done.
*
* @param a_telegram
* @param a_handle
* @param a_doCheckWhetherExpired
*/
void sendTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram,
PrtCnvStoredRadioTelegram *a_handle,
const bool a_doCheckWhetherExpired = true);
/**
* Sends the register-indication to TETRA
*/
void doRegister();
/**
* Send a register group message to TETRA
*/
void registerGroups();
/**
* Processes the register-response-telegram
*
* @param a_regsitrationStatus
*/
void handleRegisterRsp(const uint8_t a_regsitrationStatus);
public:
/**
* @author alois.wismer
* @version 1.0
* @updated 06-Apr-2010 16:01:59
*/
enum class E_TrafficLoad
{
Unknown = -1,
@@ -205,13 +263,16 @@ public:
HighLoad,
FullLoad
};
protected:
protected:
/**
* Holds the radio-telegram for sending Umgebungsmeldung periodically
*/
N_CoPrtCnv::CoPrtCnvRadioTelegram *m_EnvironmentTelegram;
/**
* load of traffic from Protocolconverter to TETRA
*/
E_TrafficLoad m_SendLoad;
uint32_t m_SendQueueFullLoad;
@@ -219,79 +280,125 @@ public:
uint32_t m_SendTelegramsNormalLoad;
uint32_t m_SendTelegramsHighLoad;
uint32_t m_SendTelegramsFullLoad;
/**
* The number of telegrams sent within the last second
*/
uint32_t m_SentTelegrams;
/**
* The number of bytes sent within last second
*/
uint32_t m_SentBytes;
/**
* how many times tick must be called until 1 second has elapsed
*/
uint32_t m_TickCounter;
/**
* how many times tick was called (used for knowing when 1 second has elapsed,
* which we use for sent-bytes and receive-bytes statistics)
*/
uint32_t m_TicksPerSecond;
/**
* How many values we use for computing average
*/
static const int AVERAGE_COUNT = 10;
/**
* The last few number of bytes sent, used for calculating the average
*/
uint32_t m_SentBytesAverage[AVERAGE_COUNT];
/**
* index for writing into aveage-array
*/
uint8_t m_AverageIndex;
/**
* The number of telegrams sent within the last second
*/
uint32_t m_ReceivedTelegrams;
/**
* The number of bytes sent within last second
*/
uint32_t m_ReceivedBytes;
/**
* The last few number of bytes sent, used for calculating the average
*/
uint32_t m_ReceivedBytesAverage[AVERAGE_COUNT];
/**
* The groups which should be listened to
*/
std::set<uint32_t> m_ListenGroups;
/**
* @brief use scrambling yes/no (Radio/UseScrambling)
*/
bool m_bUseScrambling;
/**
* The logger object for statistics
*/
NGL::INGLLogger &m_loggerStats;
// mapping which equipNos are in which exercise
std::unordered_map<int, std::unordered_set<int>> m_exerciseEquipmentAssignments;
std::unordered_map<int, TrainingAreaBase::TetraIcd::GroupIssiInformation> m_groupIssiInformation;
mutable QRecursiveMutex m_exerciseEquipmentAssignmentMutex;
private:
/**
* generates an answer to TNE from protocoll-converter for some special radio-
* telegrams (i.e. NachforderungBroadcast, BITE-Meldung)
* returns true when the telegram must be sent to central
*
* @param a_centralTelegram
* @param a_radioTelegram
*/
bool sendAnswer(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);
/**
* After calling this function, the caller must no longer use a_data, because this
* function 'consumes' a_data and will delete a_data, when no longer needed.
*
* @param a_data A pointer to the telegram-data, including frame-header.
* Control over a_data will be lost (see description of function itself)
*/
void handleReceivedTelegram(const QByteArray &data);
/**
* Processes the data-indication-telegram
*
* @param a_data
* @param bDoDeleteData is set to true when the caller can properly delete the data
*/
void handleDataIndReq(const QByteArray &data, bool bIsMaybeScrambled);
/**
* Processes the login-telegram
*
* @param a_loginTelegram
*/
void handleLoginTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_loginTelegram);
/**
* Processes a fragment of a telegram
*
* @param a_fragmentedTelegram
*/
void handleFragmentedTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_fragmentedTelegram);
/**
* Sends a telegram "FehlermeldungGefechtsfeld" to central
*
* @param a_identity
* @param a_errorCause
* @param a_telegramId
*/
void sendFehlermeldungGefechtsfeldToCentral(const uint16_t a_identity,
const TrainingAreaBase::TetraIcd::CtaDataError::Reason a_errorCause,
const gef_telegramm_id_et a_telegramId = GEF_BESTAETIGUNG);
/**
* Returns the ISSI of TNE with a_TNE_Id
*
* @param a_TNE_Id
*/
uint32_t getDestinationISSI(const uint16_t a_TNE_Id) const;
/**
* Processes the BITE/BITE extended-telegram
*
* @param a_BITE_CentralTelegram
*/
bool handleBITEEXT_Telegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_BITE_RadioTelegram);
bool handleBITE_Telegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_BITE_RadioTelegram,
TrainingAreaBase::TetraIcd::BiteReport::LoginType anmeldeart,
@@ -299,50 +406,91 @@ public:
uint32_t ergebnisAusstattung,
uint32_t aktuelleKonfiguration,
uint32_t konfigurationsvergleich,
const QList<PrtCnv::BiteError> &fehlerListe
);
const QList<PrtCnv::BiteError> &fehlerListe);
/**
* Sends a login-telegram to radio
*
* @param a_loginTelegramStatus
* @param a_identity
* @param a_ISSI
*/
void sendLoginResponse(const N_CoPrtCnv::CoPrtCnvRadioTelegram::E_LoginStatus a_loginTelegramStatus, const uint16_t a_identity, const uint32_t a_ISSI);
void sendLoginResponse(const N_CoPrtCnv::CoPrtCnvRadioTelegram::E_LoginStatus a_loginTelegramStatus,
const uint16_t a_identity, const uint32_t a_ISSI, const TrainingAreaBase::TetraIcd::GroupIssiInformation &group);
const uint16_t a_identity,
const uint32_t a_ISSI,
const TrainingAreaBase::TetraIcd::GroupIssiInformation &group);
void sendLizenzierungTneToRadio(const uint16_t a_identity, const uint32_t a_issi,
/**
* Sends a telegram "LizenzierungTNE" to radio
*
* @param a_identity AusstattungsId
* @param a_issi
* @param a_licensingKind
* @param a_errorCause
*/
void sendLizenzierungTneToRadio(const uint16_t a_identity,
const uint32_t a_issi,
const N_CoPrtCnv::E_LicensingKind a_licensingKind,
const N_CoPrtCnv::E_LicensingErrorCode a_errorCause);
/**
* Writes the login of a TNE to the login-logfile
*
* @param a_radioTelegram
* @param a_prosaText
*/
void writeLoginLog(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram, const QString &a_prosaText);
void writeLoginLog(const N_CoPrtCnv::CoPrtCnvRadioTelegram *a_radioTelegram, const QString &a_prosaText);
void writeLoginLog(uint32_t identity, uint32_t issi, const QString &a_prosaText);
/**
* Receives the file with allowed playerId, or the lowest and hightest allowed
* playerIds
*/
void initIdentityArray();
uint16_t readIdentity(const QByteArray& a_idAsText, const uint32_t a_line, const QString& a_fileName);
/**
* Reads one line of the playerId-file.
* Aborts when not successful
*
* @param a_idAsText
* @param a_line
* @param a_fileName
*/
uint16_t readIdentity(const QByteArray &a_idAsText, const uint32_t a_line, const QString &a_fileName);
/**
* Checks whether the playerId is allowd.
*
* @param a_identity
*/
bool isIdentityValid(uint16_t a_identity) const;
/**
* Allows this playerId.
*
* @param a_identity
*/
void setIdentityVaild(uint16_t a_identity);
/**
* Fragment a telegram and sends the fragments to radio.
*
* @param a_telegram
*/
void sendFragmentedTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram);
/**
* sends the telegram to radio-socket
* returns the broadcastIndex (0 if it was no broadcast)
*
* @param a_telegram
*/
uint16_t sendToSocket(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram);
/**
* Processes the report-indication-telegram
*
* @param a_data
*/
void handleReportIndReq(const QByteArray &data);
void prepareWareHouseMessage(qint32 equipNr,
bool doLicence,
@@ -353,59 +501,78 @@ public:
const QList<PrtCnv::BiteError> &fehlerListe);
protected Q_SLOTS:
/**
* @brief oslot to handle call to sendEnvironmentTelegramTimerNow in correct thread
*/
void onSendEnvironmentTelegramTimerNow();
/**
* see base-class
*/
void timeoutAliveAndConnection() override;
/**
* Processes the periodical stuff, like broadcasts and nachforderungen
*/
void timeoutTick() override;
/**
* Checks whether a normal telegram must be sent and sends it.
*/
void checkSend();
/**
* see base-class
*/
void readyRead() override;
/**
* see base-class
*/
void disconnected() override;
/**
* see base-class
*/
void connected() override;
/**
* Processes the periodical sending of Umgebungsmeldung
*/
void timeoutEnvironmentTelegram();
/**
* Clean the DB.
*/
void doClean();
/**
* Restart work after cleaning Db
*/
void doStart();
/**
* Stops work for cleaning DB
*/
void doStop();
// a broadcastTelegrams request was received from EXCON (e.g. through Wls)
void onBroadcastTelegramsRequestFromCentral(int equipmentNumber, int broadcastIndex, int resetCounter);
private:
/**
* Processes the status-telegram
*
* @param data
*/
void handleStatusIndReq(const QByteArray &data);
/**
* Processes the air-interface-report-telegram
*
* @param a_data
*/
void handleAirInterfaceLoadReq(const QByteArray &data);
/**
* Computes and logs the sent- and receive-statistics
*/
void computeAndLogTrafficStatistics();
/**
* returns true, if at the moment no more telegrams should be sent
*/
bool isSendLimitReached() const;
@@ -1,16 +1,16 @@
// **************************************************************************
//
// @RDE_HEADER@
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvRadioTrafficThread
// **************************************************************************
#include "PrtCnvRadioTrafficThread.hpp"
#include "PrtCnvDbThread.hpp"
@@ -23,186 +23,183 @@
namespace PrtCnv
{
PrtCnvRadioTrafficThread::PrtCnvRadioTrafficThread(PrtCnvThreadStarter* a_parent)
: PrtCnvThread(a_parent, "PrtCnvRadioTrafficThread")
, m_receiveLoad(PrtCnvRadioThread::E_TrafficLoad::Unknown)
, m_fullLoad(100)
, m_highLoad(50)
, m_hystLoad(5)
, m_calcTimeout(1000)
, m_cleanupTimeout(5000)
, m_mutex()
{}
void PrtCnvRadioTrafficThread::newTelegramArrived(unsigned int size)
{
time_t curTime = time(nullptr);
QMutexLocker l(&m_mutex);
DEBUG_LOG(m_logger) << "newTelegramArrived with size " << size << " at " << curTime;
m_data[curTime] += size;
m_telegrams[curTime]++;
}
int32_t PrtCnvRadioTrafficThread::start()
{
const QString trafficControlGroup(QStringLiteral("TrafficControl"));
int highLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueHighLoad"), 60);
int fullLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueFullLoad"), 80);
int hystLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueHysteresis"), 5);
int avgTime = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveAveragingTime"), 5);
float trafficPerReceiverKB = m_Config->getFloat(trafficControlGroup, QStringLiteral("ReceiveThroughput"), 3.6f);
int cntTransceiver = m_Config->getInteger(trafficControlGroup, QStringLiteral("TransceiverCount"), 6);
if (highLoad < 0 || highLoad > 100)
highLoad = 60;
if (fullLoad < highLoad || fullLoad > 100)
fullLoad = 80;
if (hystLoad < 0 || hystLoad > 10)
hystLoad = 5;
if (avgTime <= 0 || avgTime > 60)
avgTime = 5;
if (trafficPerReceiverKB < 1 || trafficPerReceiverKB > 1000)
trafficPerReceiverKB = 3.6f;
if (cntTransceiver < 1 || cntTransceiver > 100)
cntTransceiver = 6;
float maxTrafficBytes = trafficPerReceiverKB * cntTransceiver * 1024;
m_fullLoad = maxTrafficBytes * fullLoad / 100.f;
m_highLoad = maxTrafficBytes * highLoad / 100.f;
m_hystLoad = maxTrafficBytes * hystLoad / 100.f;
m_cleanupTimeout = avgTime * 1000;
DEBUG_LOG(m_logger) << "Read config ReceiveQueueHighLoad: " << highLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveQueueFullLoad: " << fullLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveQueueHysteresis: " << hystLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveAveragingTime: " << avgTime;
DEBUG_LOG(m_logger) << "Read config ReceiveThroughput: " << trafficPerReceiverKB;
DEBUG_LOG(m_logger) << "Read config TransceiverCount: " << cntTransceiver;
INFO_LOG(m_logger) << "Using to following limits: high - " << m_highLoad
<< " full - " << m_fullLoad
<< " hyst - " << m_hystLoad
<< " avg. time - " << m_cleanupTimeout / 1000;
QTimer::singleShot(m_calcTimeout, this, &PrtCnvRadioTrafficThread::onCalculateTrafficLoad);
QTimer::singleShot(m_cleanupTimeout, this, &PrtCnvRadioTrafficThread::onCleanupTimeout);
return 0;
}
void PrtCnvRadioTrafficThread::onCalculateTrafficLoad()
{
const time_t curTime = time(nullptr);
unsigned int payload = 0;
PrtCnvRadioTrafficThread::PrtCnvRadioTrafficThread(PrtCnvThreadStarter *a_parent)
: PrtCnvThread(a_parent, "PrtCnvRadioTrafficThread")
, m_receiveLoad(PrtCnvRadioThread::E_TrafficLoad::Unknown)
, m_fullLoad(100)
, m_highLoad(50)
, m_hystLoad(5)
, m_calcTimeout(1000)
, m_cleanupTimeout(5000)
, m_mutex()
{
}
void PrtCnvRadioTrafficThread::newTelegramArrived(unsigned int size)
{
time_t curTime = time(nullptr);
QMutexLocker l(&m_mutex);
for (int i = 1; i <= m_cleanupTimeout / 1000; ++i)
payload += m_data.value(curTime - i);
DEBUG_LOG(m_logger) << "newTelegramArrived with size " << size << " at " << curTime;
m_data[curTime] += size;
m_telegrams[curTime]++;
}
payload /= (m_cleanupTimeout / 1000);
INFO_LOG(m_logger) << "Average Payload in the last "
<< m_cleanupTimeout << " Milliseconds: "
<< payload << " Bytes/sec, last sec: "
<< m_data[curTime - 1] << " Bytes, #telegrams: " << m_telegrams[curTime - 1];
PrtCnvRadioThread::E_TrafficLoad newReceiveLoad;
if (payload >= m_fullLoad)
int32_t PrtCnvRadioTrafficThread::start()
{
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::FullLoad;
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::HighLoad)
{
if(payload < m_fullLoad + m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
}
// read data from m_Config
const QString trafficControlGroup(QStringLiteral("TrafficControl"));
int highLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueHighLoad"), 60);
int fullLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueFullLoad"), 80);
int hystLoad = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveQueueHysteresis"), 5);
int avgTime = m_Config->getInteger(trafficControlGroup, QStringLiteral("ReceiveAveragingTime"), 5);
float trafficPerReceiverKB = m_Config->getFloat(trafficControlGroup, QStringLiteral("ReceiveThroughput"), 3.6f);
int cntTransceiver = m_Config->getInteger(trafficControlGroup, QStringLiteral("TransceiverCount"), 6);
// sanity checks
if (highLoad < 0 || highLoad > 100)
highLoad = 60;
if (fullLoad < highLoad || fullLoad > 100)
fullLoad = 80;
if (hystLoad < 0 || hystLoad > 10)
hystLoad = 5;
if (avgTime <= 0 || avgTime > 60)
avgTime = 5;
if (trafficPerReceiverKB < 1 || trafficPerReceiverKB > 1000)
trafficPerReceiverKB = 3.6f;
if (cntTransceiver < 1 || cntTransceiver > 100)
cntTransceiver = 6;
float maxTrafficBytes = trafficPerReceiverKB * cntTransceiver * 1024;
m_fullLoad = maxTrafficBytes * fullLoad / 100.f;
m_highLoad = maxTrafficBytes * highLoad / 100.f;
m_hystLoad = maxTrafficBytes * hystLoad / 100.f;
m_cleanupTimeout = avgTime * 1000; // ms
DEBUG_LOG(m_logger) << "Read config ReceiveQueueHighLoad: " << highLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveQueueFullLoad: " << fullLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveQueueHysteresis: " << hystLoad;
DEBUG_LOG(m_logger) << "Read config ReceiveAveragingTime: " << avgTime;
DEBUG_LOG(m_logger) << "Read config ReceiveThroughput: " << trafficPerReceiverKB;
DEBUG_LOG(m_logger) << "Read config TransceiverCount: " << cntTransceiver;
INFO_LOG(m_logger) << "Using to following limits: high - " << m_highLoad << " full - " << m_fullLoad << " hyst - " << m_hystLoad << " avg. time - "
<< m_cleanupTimeout / 1000;
QTimer::singleShot(m_calcTimeout, this, &PrtCnvRadioTrafficThread::onCalculateTrafficLoad);
QTimer::singleShot(m_cleanupTimeout, this, &PrtCnvRadioTrafficThread::onCleanupTimeout);
return 0;
}
else if (payload >= m_highLoad)
{
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::NormalLoad)
{
if (payload < m_highLoad + m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::NormalLoad;
}
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::FullLoad)
{
if (payload >= m_fullLoad - m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::FullLoad;
}
}
else
{
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::NormalLoad;
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::HighLoad)
{
if(payload >= m_highLoad - m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
}
}
if (m_receiveLoad != newReceiveLoad)
{
m_receiveLoad = newReceiveLoad;
unsigned int wartezeit_posmldg = (static_cast<unsigned int>(m_receiveLoad) * 10) + 1;
INFO_LOG(m_logger) << "New traffic load: " << m_receiveLoad;
PrtCnvDbThread *dbThread = qobject_cast<PrtCnvDbThread*>(m_Parent->getOtherThread(PrtCnvApplication::e_Db));
if (dbThread)
{
dbThread->setAirLoad(m_receiveLoad);
dbThread->setPositionSendTime(wartezeit_posmldg);
void PrtCnvRadioTrafficThread::onCalculateTrafficLoad()
{
const time_t curTime = time(nullptr);
Q_ASSERT(QThread::currentThreadId() == m_currentThreadId);
unsigned int payload = 0;
{
QMutexLocker l(&m_mutex);
// fuer aktuelle Sekunde haben wir noch nicht alle Daten
for (int i = 1; i <= m_cleanupTimeout / 1000; ++i)
payload += m_data.value(curTime - i);
}
// Durchschnitt ...
payload /= (m_cleanupTimeout / 1000);
INFO_LOG(m_logger) << "Average Payload in the last " << m_cleanupTimeout << " Milliseconds: " << payload << " Bytes/sec, last sec: " << m_data[curTime - 1]
<< " Bytes, #telegrams: " << m_telegrams[curTime - 1];
PrtCnvRadioThread::E_TrafficLoad newReceiveLoad;
if (payload >= m_fullLoad)
{
// full load
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::FullLoad;
// Hysterese nach oben
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::HighLoad)
{
// wenn cnt in Bereich m_fullLoad ... m_fullLoad + m_hystLoad
// -> noch warten
if (payload < m_fullLoad + m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
}
}
else if (payload >= m_highLoad)
{
// high load
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
// Hysterese nach oben
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::NormalLoad)
{
// wenn cnt in Bereich m_highLoad ... m_highLoad + m_hystLoad
// -> noch warten
if (payload < m_highLoad + m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::NormalLoad;
}
// Hysterese nach unten
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::FullLoad)
{
// wenn cnt in Bereich m_fullLoad ... m_fullLoad - m_hystLoad
// -> noch warten
if (payload >= m_fullLoad - m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::FullLoad;
}
}
else
ERROR_LOG(m_logger) << "Could not get PrtCnvDbThread!";
}
QTimer::singleShot(m_calcTimeout, this, &PrtCnvRadioTrafficThread::onCalculateTrafficLoad);
}
void PrtCnvRadioTrafficThread::onCleanupTimeout()
{
const time_t curTime = time(nullptr);
{
QMutexLocker l(&m_mutex);
QMap<time_t, unsigned int>::iterator it = m_data.begin();
while (it != m_data.end())
{
const time_t key = it.key();
if (key < curTime - m_cleanupTimeout - 10)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::NormalLoad;
// Hysterese nach unten
if (m_receiveLoad == PrtCnvRadioThread::E_TrafficLoad::HighLoad)
{
m_data.erase(it++);
m_telegrams.remove(key);
continue;
// wenn cnt in Bereich m_highLoad ... m_highLoad - m_hystLoad
// -> noch warten
if (payload >= m_highLoad - m_hystLoad)
newReceiveLoad = PrtCnvRadioThread::E_TrafficLoad::HighLoad;
}
break;
}
if (m_receiveLoad != newReceiveLoad)
{
m_receiveLoad = newReceiveLoad;
// Achtung: Nicht mehr als 31 Sekunden erlaubt
unsigned int wartezeit_posmldg = (static_cast<unsigned int>(m_receiveLoad) * 10) + 1;
INFO_LOG(m_logger) << "New traffic load: " << m_receiveLoad;
PrtCnvDbThread *dbThread = qobject_cast<PrtCnvDbThread *>(m_Parent->getOtherThread(PrtCnvApplication::e_Db));
if (dbThread)
{
dbThread->setAirLoad(m_receiveLoad);
dbThread->setPositionSendTime(wartezeit_posmldg);
Q_ASSERT(QThread::currentThreadId() == m_currentThreadId);
}
else
ERROR_LOG(m_logger) << "Could not get PrtCnvDbThread!";
}
QTimer::singleShot(m_calcTimeout, this, &PrtCnvRadioTrafficThread::onCalculateTrafficLoad);
}
QTimer::singleShot(m_cleanupTimeout, this, &PrtCnvRadioTrafficThread::onCleanupTimeout);
}
void PrtCnvRadioTrafficThread::onCleanupTimeout()
{
const time_t curTime = time(nullptr);
{
QMutexLocker l(&m_mutex);
QMap<time_t, unsigned int>::iterator it = m_data.begin();
while (it != m_data.end())
{
const time_t key = it.key();
// 10 als Puffer (siehe auch onCalculateTrafficLoad())
if (key < curTime - m_cleanupTimeout - 10)
{
m_data.erase(it++);
m_telegrams.remove(key);
continue;
}
break; // arbitrarily ordered
}
}
}
QTimer::singleShot(m_cleanupTimeout, this, &PrtCnvRadioTrafficThread::onCleanupTimeout);
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// @RDE_HEADER@
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvRadioTrafficThread
// **************************************************************************
#pragma once
#include "PrtCnvThread.hpp"
@@ -21,63 +21,75 @@
namespace PrtCnv
{
/**
* This class handles the traffic counting for the
* incoming radio data
*/
class PrtCnvRadioTrafficThread final : public PrtCnvThread
{
Q_OBJECT
public:
explicit PrtCnvRadioTrafficThread(PrtCnvThreadStarter *a_parent);
/**
* A new telegram arrived.
*/
void newTelegramArrived(unsigned int size);
/**
* Start the thread handling
*/
int32_t start() override;
protected Q_SLOTS:
/**
* Timeout to recalculate traffic load
*/
void onCalculateTrafficLoad();
/**
* Timeout to throw away old data
*/
void onCleanupTimeout();
protected:
/**
* The current traffic load
*/
PrtCnvRadioThread::E_TrafficLoad m_receiveLoad;
/**
* Full load
*/
unsigned int m_fullLoad;
/**
* High load
*/
unsigned int m_highLoad;
/**
* Hysterese
*/
unsigned int m_hystLoad;
/**
* Timeout for recalculation
*/
int m_calcTimeout;
/**
* Timeout until data is thrown away
*/
int m_cleanupTimeout;
class PrtCnvRadioTrafficThread final : public PrtCnvThread
{
Q_OBJECT
public:
explicit PrtCnvRadioTrafficThread(PrtCnvThreadStarter* a_parent);
QRecursiveMutex m_mutex;
void newTelegramArrived(unsigned int size);
int32_t start() override;
protected Q_SLOTS:
void onCalculateTrafficLoad();
void onCleanupTimeout();
protected:
PrtCnvRadioThread::E_TrafficLoad m_receiveLoad;
unsigned int m_fullLoad;
unsigned int m_highLoad;
unsigned int m_hystLoad;
int m_calcTimeout;
int m_cleanupTimeout;
QRecursiveMutex m_mutex;
QMap<time_t, unsigned int> m_data;
QMap<time_t, unsigned int> m_telegrams;
};
}
/**
* map<time, nTelegrams>
*/
QMap<time_t, unsigned int> m_data;
QMap<time_t, unsigned int> m_telegrams;
};
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvSocketThread
// **************************************************************************
#include "PrtCnvSocketThread.hpp"
#include <utility>
@@ -25,359 +25,359 @@
namespace PrtCnv
{
PrtCnvSocketThread::PrtCnvSocketThread(PrtCnv::PrtCnvThreadStarter* a_parent, const char *loggerName)
: PrtCnvThread(a_parent, loggerName)
, m_ConnectionTimer(nullptr)
, m_Socket(nullptr)
, m_TickTimer(nullptr)
, m_ReceiveCounter(0)
, m_ReceiveAckCounter(0)
, m_State(PrtCnvSocketThread::e_INITIAL)
, m_DbThread(nullptr)
, m_ConnectTimeout(2000)
, m_DisconnectTimeout(10000)
, m_AliveTimeout(3000)
, m_TickTimeout(900)
, m_DoCleanup(false)
, m_LogThread(nullptr)
, m_InjectionThread(nullptr)
, m_currentHostAdressIndex(0)
{}
PrtCnvSocketThread::~PrtCnvSocketThread()
{
cleanup();
}
int32_t PrtCnvSocketThread::create(NGL::Settings *settings)
{
PrtCnvThread::create(settings);
createNewSocket();
m_ConnectionTimer = new QTimer(this);
connect(m_ConnectionTimer, &QTimer::timeout, this, &PrtCnvSocketThread::timeoutAliveAndConnection);
m_TickTimer = new QTimer(this);
connect(m_TickTimer, &QTimer::timeout, this, &PrtCnvSocketThread::timeoutTick);
m_DbThread = qobject_cast<PrtCnvDbThread*>(m_Parent->getOtherThread(PrtCnvApplication::e_Db));
m_LogThread = qobject_cast<PrtCnvTelegramLogThread*>(m_Parent->getOtherThread(PrtCnvApplication::e_Log));
m_InjectionThread = qobject_cast<PrtCnvInjectionThread*>(m_Parent->getOtherThread(PrtCnvApplication::e_Injection));
return 0;
}
void PrtCnvSocketThread::createNewSocket()
{
INFO_LOG(m_logger) << "createNewSocket m_oldSocket=" << m_Socket;
Q_ASSERT(QThread::currentThreadId() == m_currentThreadId);
if (m_Socket)
// ---------------------------------------------------------------
// Constructor with pointer to thread-starter as parameter
// ---------------------------------------------------------------
PrtCnvSocketThread::PrtCnvSocketThread(PrtCnv::PrtCnvThreadStarter *a_parent, const char *loggerName)
: PrtCnvThread(a_parent, loggerName)
, m_ConnectionTimer(nullptr)
, m_Socket(nullptr)
, m_TickTimer(nullptr)
, m_ReceiveCounter(0)
, m_ReceiveAckCounter(0)
, m_State(PrtCnvSocketThread::e_INITIAL)
, m_DbThread(nullptr)
, m_ConnectTimeout(2000)
, m_DisconnectTimeout(10000)
, m_AliveTimeout(3000)
, m_TickTimeout(900)
, m_DoCleanup(false)
, m_LogThread(nullptr)
, m_InjectionThread(nullptr)
, m_currentHostAdressIndex(0)
{
m_Socket->disconnectFromHost();
m_Socket->disconnect();
if (m_Socket->state() != QAbstractSocket::UnconnectedState)
m_Socket->waitForDisconnected();
m_Socket->deleteLater();
}
m_Socket = new QTcpSocket(this);
qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
connect(m_Socket, &QTcpSocket::connected, this, &PrtCnvSocketThread::connected, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::disconnected, this, &PrtCnvSocketThread::disconnected, Qt::QueuedConnection);
connect(m_Socket, &QAbstractSocket::errorOccurred, this, &PrtCnvSocketThread::error, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::hostFound, this, &PrtCnvSocketThread::hostFound, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::stateChanged, this, &PrtCnvSocketThread::stateChanged);
connect(m_Socket, &QTcpSocket::readyRead, this, &PrtCnvSocketThread::readyRead, Qt::QueuedConnection);
}
int32_t PrtCnvSocketThread::destroy()
{
PrtCnvThread::destroy();
cleanup();
return 0;
}
void PrtCnvSocketThread::cleanup()
{
delete m_Socket; m_Socket = nullptr;
delete m_ConnectionTimer; m_ConnectionTimer = nullptr;
delete m_TickTimer; m_TickTimer = nullptr;
}
int32_t PrtCnvSocketThread::init()
{
INFO_LOG(m_logger) << "PrtCnvSocketThread::init()";
PrtCnvThread::init();
m_State = e_INITIAL;
m_ConnectTimeout = m_Config->getInteger(getName(), QStringLiteral("ConnectTimeout"), 2000);
m_DisconnectTimeout = m_Config->getInteger(getName(), QStringLiteral("DisconnectTimeout"), 10000);
m_AliveTimeout = m_Config->getInteger(getName(), QStringLiteral("AliveTimeout"), 3000);
return 0;
}
void PrtCnvSocketThread::connectSocket()
{
int sockState = m_Socket ? m_Socket->state() : -1;
INFO_LOG(m_logger) << "connectSocket m_Socket=" << m_Socket << " state=" << m_State << " socketState=" << sockState;
if (e_WORKING != m_State && e_REGISTERING != m_State)
PrtCnvSocketThread::~PrtCnvSocketThread()
{
if (m_Socket)
{
m_Socket->disconnectFromHost();
if (m_Socket->state() != QAbstractSocket::UnconnectedState)
m_Socket->waitForDisconnected();
}
cleanup();
}
// ---------------------------------------------------------------
// Creates all subcomponents and connects signals to slots
// ---------------------------------------------------------------
int32_t PrtCnvSocketThread::create(NGL::Settings *settings)
{
PrtCnvThread::create(settings);
createNewSocket();
if(m_hostAdresses.isEmpty())
readHostAdresses();
const QString hostname = m_hostAdresses.at(m_currentHostAdressIndex).first;
const uint16_t port = m_hostAdresses.at(m_currentHostAdressIndex).second;
m_currentHostAdressIndex = ((m_currentHostAdressIndex + 1) % m_hostAdresses.size());
INFO_LOG(m_logger) << "Connecting to " << hostname << ":" << port << " m_Socket=" << m_Socket;
m_Socket->connectToHost(hostname, port);
m_State = e_CONNECTING;
startConnectionTimer();
m_ConnectionTimer = new QTimer(this);
connect(m_ConnectionTimer, &QTimer::timeout, this, &PrtCnvSocketThread::timeoutAliveAndConnection);
m_TickTimer = new QTimer(this);
connect(m_TickTimer, &QTimer::timeout, this, &PrtCnvSocketThread::timeoutTick);
m_DbThread = qobject_cast<PrtCnvDbThread *>(m_Parent->getOtherThread(PrtCnvApplication::e_Db));
m_LogThread = qobject_cast<PrtCnvTelegramLogThread *>(m_Parent->getOtherThread(PrtCnvApplication::e_Log));
m_InjectionThread = qobject_cast<PrtCnvInjectionThread *>(m_Parent->getOtherThread(PrtCnvApplication::e_Injection));
return 0;
}
else
// ---------------------------------------------------------------
// Creates a new socket to avoid getting old stuff from the
// former socket when reconnecting
// ---------------------------------------------------------------
void PrtCnvSocketThread::createNewSocket()
{
WARNING_LOG(m_logger) << getName() << ": connectSocket called, but m_State is " << m_State;
}
}
INFO_LOG(m_logger) << "createNewSocket m_oldSocket=" << m_Socket;
Q_ASSERT(QThread::currentThreadId() == m_currentThreadId);
void PrtCnvSocketThread::disconnectSocket()
{
m_Socket->disconnectFromHost();
startDisconnectionTimer();
m_State = e_DISCONNECTING;
}
void PrtCnvSocketThread::connected()
{
INFO_LOG(m_logger) << "connected (implement connected() in inherited class, if you want use this signal...)";
}
void PrtCnvSocketThread::disconnected()
{
INFO_LOG(m_logger) << "got signal 'disconnected' (implement disconnected() in inherited class, if you want use this signal...)";
}
void PrtCnvSocketThread::readyRead()
{
INFO_LOG(m_logger) << "got signal 'newData' (implement newData() in inherited class, if you want use this signal...)";
}
void PrtCnvSocketThread::timeoutAliveAndConnection()
{
INFO_LOG(m_logger) << "got signal 'reconnectTimeout' (implement reconnectTimeout() in inherited class, if you want use this signal...)";
}
void PrtCnvSocketThread::error(QAbstractSocket::SocketError a_socketError)
{
switch (a_socketError)
{
case QAbstractSocket::ConnectionRefusedError:
ERROR_LOG(m_logger) << getName() << ": ConnectionRefusedError m_State=" << m_State;
break;
case QAbstractSocket::RemoteHostClosedError:
ERROR_LOG(m_logger) << getName() << ": RemoteHostClosedError";
break;
case QAbstractSocket::HostNotFoundError:
break;
default:
ERROR_LOG(m_logger) << getName() << ": got signal 'error(QAbstractSocket::SocketError=" << a_socketError << ")'";
}
}
void PrtCnvSocketThread::hostFound()
{
}
void PrtCnvSocketThread::stateChanged(QAbstractSocket::SocketState a_socketState)
{
Q_UNUSED(a_socketState);
}
void PrtCnvSocketThread::storeRadioTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram,
const uint32_t a_readCounter)
{
m_DbThread->storeRadioTelegram(a_telegram, a_readCounter);
}
void PrtCnvSocketThread::startAliveTimer()
{
m_ConnectionTimer->setInterval(m_AliveTimeout);
m_ConnectionTimer->start();
}
void PrtCnvSocketThread::startConnectionTimer()
{
m_ConnectionTimer->setInterval(m_ConnectTimeout);
m_ConnectionTimer->start();
}
void PrtCnvSocketThread::startDisconnectionTimer()
{
m_ConnectionTimer->setInterval(m_DisconnectTimeout);
m_ConnectionTimer->start();
}
void PrtCnvSocketThread::startTickTimer()
{
m_TickTimer->setInterval(m_TickTimeout);
m_TickTimer->start();
}
bool PrtCnvSocketThread::checkAndUpdateReceiveCounter(const uint32_t a_counter, const uint32_t a_maxCounter, const uint32_t a_startCounter)
{
TRACE_LOG(m_logger) << "checkAndUpdateReceiveCounter: " << a_counter << ", " << m_ReceiveCounter;
if (a_maxCounter == ++m_ReceiveCounter)
{
m_ReceiveCounter = a_startCounter;
}
if (m_ReceiveCounter != a_counter)
{
if (m_Socket)
{
if (m_ReceiveCounter > a_counter)
{
ERROR_LOG(m_logger) << "It seems, the telegram with counter " << a_counter << " was resent from "
<< getName() << "! Expected: " << m_ReceiveCounter;
}
else
{
ERROR_LOG(m_logger) << "It seems, we lost one or several telegrams from " << getName()
<< ": receive-counter of received telegram: " << a_counter << "; Expected: " << m_ReceiveCounter;
}
m_Socket->disconnectFromHost(); // Falls noch connected
m_Socket->disconnect(); // Alle Signals/Slots aufräumen
if (m_Socket->state() != QAbstractSocket::UnconnectedState)
m_Socket->waitForDisconnected();
m_Socket->deleteLater(); // und weg damit
}
m_Socket = new QTcpSocket(this);
qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
connect(m_Socket, &QTcpSocket::connected, this, &PrtCnvSocketThread::connected, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::disconnected, this, &PrtCnvSocketThread::disconnected, Qt::QueuedConnection);
connect(m_Socket, &QAbstractSocket::errorOccurred, this, &PrtCnvSocketThread::error, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::hostFound, this, &PrtCnvSocketThread::hostFound, Qt::QueuedConnection);
connect(m_Socket, &QTcpSocket::stateChanged, this, &PrtCnvSocketThread::stateChanged);
connect(m_Socket, &QTcpSocket::readyRead, this, &PrtCnvSocketThread::readyRead, Qt::QueuedConnection);
}
// ---------------------------------------------------------------
// Deallocates subcomponents.
// ---------------------------------------------------------------
int32_t PrtCnvSocketThread::destroy()
{
PrtCnvThread::destroy();
cleanup();
return 0;
}
void PrtCnvSocketThread::cleanup()
{
delete m_Socket;
m_Socket = nullptr;
delete m_ConnectionTimer;
m_ConnectionTimer = nullptr;
delete m_TickTimer;
m_TickTimer = nullptr;
}
// ---------------------------------------------------------------
// Initializes the variables.
// ---------------------------------------------------------------
int32_t PrtCnvSocketThread::init()
{
INFO_LOG(m_logger) << "PrtCnvSocketThread::init()";
PrtCnvThread::init();
m_State = e_INITIAL;
m_ConnectTimeout = m_Config->getInteger(getName(), QStringLiteral("ConnectTimeout"), 2000);
m_DisconnectTimeout = m_Config->getInteger(getName(), QStringLiteral("DisconnectTimeout"), 10000);
m_AliveTimeout = m_Config->getInteger(getName(), QStringLiteral("AliveTimeout"), 3000);
return 0;
}
// ---------------------------------------------------------------
// Connect as client to a TCP-server on ip-address configured
// as HostName and Port configured as Port
// ---------------------------------------------------------------
void PrtCnvSocketThread::connectSocket()
{
int sockState = m_Socket ? m_Socket->state() : -1;
INFO_LOG(m_logger) << "connectSocket m_Socket=" << m_Socket << " state=" << m_State << " socketState=" << sockState;
if (e_WORKING != m_State && e_REGISTERING != m_State)
{
if (m_Socket)
{
m_Socket->disconnectFromHost(); // Falls noch connected
if (m_Socket->state() != QAbstractSocket::UnconnectedState)
m_Socket->waitForDisconnected();
}
createNewSocket();
if (m_hostAdresses.isEmpty())
readHostAdresses();
const QString hostname = m_hostAdresses.at(m_currentHostAdressIndex).first;
const uint16_t port = m_hostAdresses.at(m_currentHostAdressIndex).second;
m_currentHostAdressIndex = ((m_currentHostAdressIndex + 1) % m_hostAdresses.size());
INFO_LOG(m_logger) << "Connecting to " << hostname << ":" << port << " m_Socket=" << m_Socket;
m_Socket->connectToHost(hostname, port);
m_State = e_CONNECTING;
startConnectionTimer();
}
else
{
WARNING_LOG(m_logger) << getName() << ": connectSocket called, but m_State is " << m_State;
}
}
// ---------------------------------------------------------------
// Disconnects from TCP-server
// ---------------------------------------------------------------
void PrtCnvSocketThread::disconnectSocket()
{
m_Socket->disconnectFromHost();
startDisconnectionTimer();
m_State = e_DISCONNECTING;
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when we have connected to
// TCP-server
// ---------------------------------------------------------------
void PrtCnvSocketThread::connected()
{
INFO_LOG(m_logger) << "connected (implement connected() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when we have disconnected
// to TCP-server
// ---------------------------------------------------------------
void PrtCnvSocketThread::disconnected()
{
INFO_LOG(m_logger) << "got signal 'disconnected' (implement disconnected() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when we have have read
// data over socket
// ---------------------------------------------------------------
void PrtCnvSocketThread::readyRead()
{
INFO_LOG(m_logger) << "got signal 'newData' (implement newData() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// this slot is used for connection, disconnection and alive
// timeouts
// ---------------------------------------------------------------
void PrtCnvSocketThread::timeoutAliveAndConnection()
{
INFO_LOG(m_logger) << "got signal 'reconnectTimeout' (implement reconnectTimeout() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when we have a socket-error
// ---------------------------------------------------------------
void PrtCnvSocketThread::error(QAbstractSocket::SocketError a_socketError)
{
switch (a_socketError)
{
case QAbstractSocket::ConnectionRefusedError:
ERROR_LOG(m_logger) << getName() << ": ConnectionRefusedError m_State=" << m_State;
break;
case QAbstractSocket::RemoteHostClosedError:
ERROR_LOG(m_logger) << getName() << ": RemoteHostClosedError";
break;
case QAbstractSocket::HostNotFoundError:
//ERROR_LOG(m_logger) << getName() << ": HostNotFoundError";
break;
default:
ERROR_LOG(m_logger) << getName() << ": got signal 'error(QAbstractSocket::SocketError=" << a_socketError << ")'";
}
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when the host was found
// ---------------------------------------------------------------
void PrtCnvSocketThread::hostFound()
{
// INFO_LOG(m_logger) << "got signal 'hostFound' (implement hostFound() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// Will be called from Qt-Framework when socket-state has
// changed
// ---------------------------------------------------------------
void PrtCnvSocketThread::stateChanged(QAbstractSocket::SocketState a_socketState)
{
Q_UNUSED(a_socketState);
// INFO_LOG(m_logger) << "got signal 'stateChanged(" << ao_socketState << ")' (implement stateChanged() in inherited class, if you want use this signal...)";
}
// ---------------------------------------------------------------
// calls storeRadioTelegram of DbThread, see there
// ---------------------------------------------------------------
void PrtCnvSocketThread::storeRadioTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram, const uint32_t a_readCounter)
{
m_DbThread->storeRadioTelegram(a_telegram, a_readCounter);
}
// ---------------------------------------------------------------
// used to check whether the other side is still alive
// ---------------------------------------------------------------
void PrtCnvSocketThread::startAliveTimer()
{
m_ConnectionTimer->setInterval(m_AliveTimeout);
m_ConnectionTimer->start();
}
// ---------------------------------------------------------------
// used to retry connection
// ---------------------------------------------------------------
void PrtCnvSocketThread::startConnectionTimer()
{
m_ConnectionTimer->setInterval(m_ConnectTimeout);
m_ConnectionTimer->start();
}
// ---------------------------------------------------------------
// used to abort connection, when normal disconnection is not
// successful
// ---------------------------------------------------------------
void PrtCnvSocketThread::startDisconnectionTimer()
{
m_ConnectionTimer->setInterval(m_DisconnectTimeout);
m_ConnectionTimer->start();
}
// ---------------------------------------------------------------
// used for periodically ticks (i.e. for acks or sending
// nachforderungen)
// ---------------------------------------------------------------
void PrtCnvSocketThread::startTickTimer()
{
// INFO_LOG(m_logger) << "start timer";
m_TickTimer->setInterval(m_TickTimeout);
m_TickTimer->start();
}
// ---------------------------------------------------------------
// The counter will be set to a_startCounter if a_maxCounter
// is reached
// returns true if receive-counter is ok
// returns false if a telegram is repeated or lost
// ---------------------------------------------------------------
bool PrtCnvSocketThread::checkAndUpdateReceiveCounter(const uint32_t a_counter, const uint32_t a_maxCounter, const uint32_t a_startCounter)
{
TRACE_LOG(m_logger) << "checkAndUpdateReceiveCounter: " << a_counter << ", " << m_ReceiveCounter;
// check for wrap
if (a_maxCounter == ++m_ReceiveCounter)
{
m_ReceiveCounter = a_startCounter;
}
// has the counter the expected value?
if (m_ReceiveCounter != a_counter)
{
//if (m_ReceiveCounter != 1)
{
if (m_ReceiveCounter > a_counter)
{
ERROR_LOG(m_logger) << "It seems, the telegram with counter " << a_counter << " was resent from " << getName() << "! Expected: " << m_ReceiveCounter;
}
else
{
ERROR_LOG(m_logger) << "It seems, we lost one or several telegrams from " << getName() << ": receive-counter of received telegram: " << a_counter
<< "; Expected: " << m_ReceiveCounter;
}
}
#if 0
m_ReceiveCounter--;
return false;
return false; // failure
#else
m_ReceiveCounter = a_counter;
return true;
m_ReceiveCounter = a_counter;
return true;
#endif
}
return true; // all ok
}
return true;
}
void PrtCnvSocketThread::readHostAdresses()
{
QString host = m_Config->getString(getName(), QStringLiteral("HostName"), QStringLiteral("127.0.0.1"));
uint16_t port = m_Config->getInteger(getName(), QStringLiteral("Port"), 4934);
m_hostAdresses.push_back(qMakePair(host, port));
for (int i = 1; i < 10; ++i) {
const QString hostName = QLatin1String("HostName") + QString::number(i);
const QString portName = QLatin1String("Port") + QString::number(i);
host = m_Config->getString(getName(), hostName, QString());
port = m_Config->getInteger(getName(), portName, 0);
if (host.isEmpty() || port == 0)
continue;
void PrtCnvSocketThread::readHostAdresses()
{
QString host = m_Config->getString(getName(), QStringLiteral("HostName"), QStringLiteral("127.0.0.1"));
uint16_t port = m_Config->getInteger(getName(), QStringLiteral("Port"), 4934);
m_hostAdresses.push_back(qMakePair(host, port));
for (int i = 1; i < 10; ++i)
{
const QString hostName = QLatin1String("HostName") + QString::number(i);
const QString portName = QLatin1String("Port") + QString::number(i);
host = m_Config->getString(getName(), hostName, QString());
port = m_Config->getInteger(getName(), portName, 0);
if (host.isEmpty() || port == 0)
continue;
m_hostAdresses.push_back(qMakePair(host, port));
}
for (const auto &p : std::as_const(m_hostAdresses))
{
INFO_LOG(m_logger) << "Read Host Adress " << p.first << ":" << p.second << " from settings";
}
}
for (const auto &p : std::as_const(m_hostAdresses)) {
INFO_LOG(m_logger) << "Read Host Adress " << p.first
<< ":" << p.second
<< " from settings";
}
}
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvSocketThread
// **************************************************************************
#pragma once
@@ -33,15 +33,29 @@ namespace PrtCnv
class PrtCnvDbThread;
class PrtCnvTelegramLogThread;
class PrtCnvInjectionThread;
/**
* The father-class of radio- and central-thread. It implements common-parts like
* - socket-connection and -disconnection
* - telegram-counter
* - timers
* - telegram-log
* - thread-state
*
* @author wia
* @version 1.0
* @created 26-Jun-2009 07:39:05
*/
class PrtCnvSocketThread : public PrtCnvThread
{
Q_OBJECT
public:
/**
* The different states for the state-event-machine
*
* @author wia
* @version 1.0
* @created 02-Jul-2009 14:16:49
*/
enum E_State
{
e_INITIAL,
@@ -51,139 +65,195 @@ namespace PrtCnv
e_DISCONNECTING,
e_REINIT
};
PrtCnvSocketThread(PrtCnvThreadStarter* a_parent, const char *loggerName);
/**
* Constructor with pointer to thread-starter as parameter
*
* @param a_parent
*/
PrtCnvSocketThread(PrtCnvThreadStarter *a_parent, const char *loggerName);
~PrtCnvSocketThread();
/**
* Creates all subcomponents and connects signals to slots
*/
int32_t create(NGL::Settings *settings) override;
/**
* Creates a new socket to avoid getting old stuff from the
* former socket when reconnecting
*/
void createNewSocket();
/**
* Initializes the variables.
*/
int32_t init() override;
/**
* Deallocates subcomponents.
*/
int32_t destroy() override;
void cleanup();
protected:
/**
* this timer is used for controlling connection and disconnection
*/
QTimer *m_ConnectionTimer;
/**
* The TCP-socket
*/
QTcpSocket *m_Socket;
/**
* Return the hostname to connect to
*/
void readHostAdresses();
protected slots:
/**
* Will be called from Qt-Framework when we have connected to TCP-server
*/
virtual void connected();
/**
* Will be called from Qt-Framework when we have have read data over socket
*/
virtual void readyRead();
/**
* this slot is used for connection, disconnection and alive timeouts
*/
virtual void timeoutAliveAndConnection();
/**
* @brief Processes the periodical stuff, like broadcasts, acks
*/
virtual void timeoutTick() {}
/**
* Will be called from Qt-Framework when we have a socket-error
*
* @param a_socketError
*/
virtual void error(QAbstractSocket::SocketError a_socketError);
/**
* Will be called from Qt-Framework when the host was found
*/
virtual void hostFound();
/**
* Will be called from Qt-Framework when socket-state has changed
*
* @param a_socketState
*/
virtual void stateChanged(QAbstractSocket::SocketState a_socketState);
protected:
/**
* used for periodically send an ack to central
*/
QTimer *m_TickTimer;
/**
* Counter of received telegrams (only for sockets)
*/
uint32_t m_ReceiveCounter;
/**
* Acknowledged telegrams counter (only for sockets)
*/
uint32_t m_ReceiveAckCounter;
/**
* The state-event-machine state
*/
PrtCnvSocketThread::E_State m_State;
/**
* Pointer to DbThread
*/
PrtCnvDbThread *m_DbThread;
/**
* The time to wait until connection has happenend [ms]. After this time
* connection will be retryed.
*/
int32_t m_ConnectTimeout;
/**
* The time to wait until disconnection has happenend [ms]. After this time has
* elapsed it will be aborted.
*/
int32_t m_DisconnectTimeout;
/**
* The period to wait until timeout of connection is detected [ms]
*/
int32_t m_AliveTimeout;
/**
* The period of m_TickTimer [ms]
*/
int32_t m_TickTimeout;
/**
* True if the database has to be cleant up (used for fast empty of signal buffers)
*/
QAtomicInt m_DoCleanup;
/**
* for independent logging of telegrams
*/
PrtCnvTelegramLogThread *m_LogThread;
PrtCnvInjectionThread *m_InjectionThread;
QVector<QPair<QString, uint16_t> > m_hostAdresses;
/**
* A vector with hostname - port pairs to connect to
*/
QVector<QPair<QString, uint16_t>> m_hostAdresses;
/**
* The current index to connect to in m_hostAdresses
*/
int m_currentHostAdressIndex;
/**
* Will be called from Qt-Framework when we have disconnected to TCP-server
*/
virtual void disconnected();
/**
* used to check whether the other side is still alive
*/
void startAliveTimer();
/**
* used to retry connection
*/
void startConnectionTimer();
/**
* used to abort connection, when normal disconnection is not successful
*/
void startDisconnectionTimer();
/**
* Connect as client to a TCP-server on ip-address configured as HostName and Port
* configured as Port
*/
void connectSocket();
/**
* Disconnects from TCP-server
*/
void disconnectSocket();
/**
* used for periodically ticks (i.e. for acks or sending nachforderungen)
*/
void startTickTimer();
/**
* The counter will be set to a_startCounter if a_maxCounter is reached
* returns true if receive-counter is ok
* returns false if a telegram is repeated or lost
*
* @param a_counter
* @param a_maxCounter
* @param a_startCounter
*/
bool checkAndUpdateReceiveCounter(const uint32_t a_counter, const uint32_t a_maxCounter, const uint32_t a_startCounter);
/**
* calls storeRadioTelegram of DbThread, see there
*
* @param a_telegram
* @param a_readCounter
*/
void storeRadioTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram, const uint32_t a_readCounter);
};
@@ -1,5 +1,10 @@
/**
* Helper to store/fetch a central telegram into/from database
* $Id$
* $HeadURL$
* $Author$
* Created by Christian Ehrlicher, SLSE, 2016-04-22
*/
#pragma once
@@ -8,32 +13,40 @@
namespace PrtCnv
{
class PrtCnvStoredCentralTelegram : public PrtCnv::PrtCnvStoredTelegram
{
public:
PrtCnvStoredCentralTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> &a_centralTelegram,
const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram)
: PrtCnvStoredTelegram(a_radioTelegram)
, m_CentralTelegram(a_centralTelegram)
{}
class PrtCnvStoredCentralTelegram : public PrtCnv::PrtCnvStoredTelegram
{
public:
PrtCnvStoredCentralTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> &a_centralTelegram,
const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram)
: PrtCnvStoredTelegram(a_radioTelegram)
, m_CentralTelegram(a_centralTelegram)
{
}
int writeCounter() const { return m_WriteCounter; }
int writeCounter() const { return m_WriteCounter; }
std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> m_CentralTelegram;
uint32_t m_Attempts = 0;
int m_WriteCounter = 0;
bool m_DoResend = false;
bool m_DoDelete = false;
};
/**
* Assigned central-telegram.
*/
std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> m_CentralTelegram;
/**
* The number of unsuccessful attempts to send the telegram to central
*/
uint32_t m_Attempts = 0;
/**
* The counter while sending this telegram to central
*/
int m_WriteCounter = 0;
/**
* True if the telegram must be resent.
*/
bool m_DoResend = false;
/**
* True if the telegram must be deleted.
* Use this boolean only if you want delete a telegram as an exception (i.e.
* corrupt telegram, which cannot be sent)
*/
bool m_DoDelete = false;
};
}
@@ -1,5 +1,10 @@
/**
* Helper to store/fetch a radio telegram into/from database
* $Id$
* $HeadURL$
* $Author$
* Created by Christian Ehrlicher, SLSE, 2016-04-22
*/
#pragma once
@@ -7,26 +12,32 @@
namespace PrtCnv
{
class PrtCnvStoredRadioTelegram : public PrtCnv::PrtCnvStoredTelegram
{
public:
using PrtCnv::PrtCnvStoredTelegram::PrtCnvStoredTelegram;
class PrtCnvStoredRadioTelegram : public PrtCnv::PrtCnvStoredTelegram
{
public:
using PrtCnv::PrtCnvStoredTelegram::PrtCnvStoredTelegram;
int32_t m_ReadCounter = 0;
uint16_t m_BroadcastIndex = 0;
uint8_t m_WriteCounter = 0;
bool m_DoDelete = false;
bool m_IsSent = false;
};
/**
* The counter while reading this telegram from central
*/
int32_t m_ReadCounter = 0;
/**
* The broadcast index if it is a broadcast-telegram and it was sent first time,
* otherwise 0.
*/
uint16_t m_BroadcastIndex = 0;
/**
* The frame-counter while sending this telegram to radio.
*/
uint8_t m_WriteCounter = 0;
/**
* True if telegram must be deleted.
*/
bool m_DoDelete = false;
/**
* True if telegram was sent.
*/
bool m_IsSent = false;
};
}
@@ -1,5 +1,10 @@
/**
* Helper to store/fetch a telegram into/from database
* $Id$
* $HeadURL$
* $Author$
* Created by Christian Ehrlicher, SLSE, 2016-04-22
*/
#pragma once
@@ -8,16 +13,17 @@
namespace PrtCnv
{
class PrtCnvStoredTelegram
{
public:
explicit PrtCnvStoredTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram)
: m_RadioTelegram(a_telegram)
{}
class PrtCnvStoredTelegram
{
public:
explicit PrtCnvStoredTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram)
: m_RadioTelegram(a_telegram)
{
}
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> m_RadioTelegram;
int64_t m_Id = 0;
bool m_WriteCounterChanged = false;
};
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> m_RadioTelegram;
int64_t m_Id = 0;
bool m_WriteCounterChanged = false;
};
}
@@ -1,17 +1,17 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
// manual class headers
#include "PrtCnvTelegramLogThread.hpp"
#include <CoPrtCnv/CoPrtCnvCentralTelegram.hpp>
#include <CoPrtCnv/CoPrtCnvLogHeader.hpp>
@@ -27,8 +27,9 @@
static int gettimeofday(struct timeval *__p, void *__t)
{
union {
unsigned long long ns100;
union
{
unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */
FILETIME ft;
} now;
@@ -48,135 +49,126 @@ static int gettimeofday(struct timeval *__p, void *__t)
namespace PrtCnv
{
// ---------------------------------------------------------------
PrtCnvTelegramLogThread::PrtCnvTelegramLogThread(PrtCnvThreadStarter *a_parent)
: PrtCnvThread(a_parent, "PrtCnvTelegramLogThread")
, m_DoLogCentralTelegram(true)
, m_DoLogWlsTelegram(true)
, m_DoLogRadioTelegram(true)
{
m_Name = QStringLiteral("TelegramLog");
}
PrtCnvTelegramLogThread::PrtCnvTelegramLogThread(PrtCnvThreadStarter* a_parent)
: PrtCnvThread(a_parent, "PrtCnvTelegramLogThread")
, m_DoLogCentralTelegram(true)
, m_DoLogWlsTelegram(true)
, m_DoLogRadioTelegram(true)
{
m_Name = QStringLiteral("TelegramLog");
}
// ---------------------------------------------------------------
int32_t PrtCnvTelegramLogThread::create(NGL::Settings *settings)
{
PrtCnvThread::create(settings);
connect(this, &PrtCnvTelegramLogThread::telegramLogReceived, this, &PrtCnvTelegramLogThread::writeTelegramLog, Qt::QueuedConnection);
return 0;
}
int32_t PrtCnvTelegramLogThread::create(NGL::Settings *settings)
{
PrtCnvThread::create(settings);
// ---------------------------------------------------------------
int32_t PrtCnvTelegramLogThread::init()
{
PrtCnvThread::init();
m_DoLogCentralTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogCentralTelegrams"), true);
m_DoLogWlsTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogWlsTelegrams"), true);
m_DoLogRadioTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogRadioTelegrams"), true);
QString path = m_Config->getString(QStringLiteral("Common"), QStringLiteral("LogTelegramPath"), QStringLiteral("."));
if (!QDir::isAbsolutePath(path))
path = QCoreApplication::applicationDirPath() + QStringLiteral("/../") + path;
connect(this, &PrtCnvTelegramLogThread::telegramLogReceived,
this, &PrtCnvTelegramLogThread::writeTelegramLog,
Qt::QueuedConnection);
m_LogTelegramPathWithPrefix = path + QLatin1Char('/') + m_Config->getString(QStringLiteral("Common"), QStringLiteral("LogTelegramPrefix"), QStringLiteral("PrtCnv_"));
if (!m_LogTelegramPathWithPrefix.endsWith(QLatin1Char('_')))
m_LogTelegramPathWithPrefix += QLatin1Char('_');
return 0;
}
// create the telegram-log-path when it not yet exists
QFileInfo fileInfo(m_LogTelegramPathWithPrefix);
QDir dir;
dir.mkpath(fileInfo.absolutePath());
INFO_LOG(m_logger);
return 0;
}
static inline int setSend(int protocol, bool bIsSend)
{
return (protocol | (bIsSend ? N_CoPrtCnv::CoPrtCnvLogHeader::e_DestSend : N_CoPrtCnv::CoPrtCnvLogHeader::e_DestReceive));
}
// ---------------------------------------------------------------
// Writes a received or sent central-telegram into log-file
// ---------------------------------------------------------------
void PrtCnvTelegramLogThread::writeCentralTelegramLog(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_centralTelegram, bool a_isSend, int a_priority)
{
if (!m_DoLogCentralTelegram)
return;
emit telegramLogReceived(a_centralTelegram->data(), setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolCentral, a_isSend), a_priority);
}
// ---------------------------------------------------------------
// Writes a received or sent wls-telegram into log-file
// ---------------------------------------------------------------
void PrtCnvTelegramLogThread::writeWlsTelegramLog(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele, bool a_isSend, int a_priority)
{
if (!m_DoLogWlsTelegram)
return;
int32_t PrtCnvTelegramLogThread::init()
{
PrtCnvThread::init();
m_DoLogCentralTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogCentralTelegrams"), true);
m_DoLogWlsTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogWlsTelegrams"), true);
m_DoLogRadioTelegram = m_Config->getBoolean(QStringLiteral("Common"), QStringLiteral("LogRadioTelegrams"), true);
QString path = m_Config->getString(QStringLiteral("Common"), QStringLiteral("LogTelegramPath"), QStringLiteral("."));
if (!QDir::isAbsolutePath(path))
path = QCoreApplication::applicationDirPath() + QStringLiteral("/../") + path;
m_LogTelegramPathWithPrefix = path + QLatin1Char('/') + m_Config->getString(QStringLiteral("Common"), QStringLiteral("LogTelegramPrefix"), QStringLiteral("PrtCnv_"));
if (!m_LogTelegramPathWithPrefix.endsWith(QLatin1Char('_')))
m_LogTelegramPathWithPrefix += QLatin1Char('_');
QFileInfo fileInfo(m_LogTelegramPathWithPrefix);
QDir dir;
dir.mkpath(fileInfo.absolutePath());
INFO_LOG(m_logger);
return 0;
}
static inline int setSend(int protocol, bool bIsSend)
{
return (protocol | (bIsSend ? N_CoPrtCnv::CoPrtCnvLogHeader::e_DestSend : N_CoPrtCnv::CoPrtCnvLogHeader::e_DestReceive));
}
N_CoPrtCnv::CoPrtCnvCentralTelegram central(*tele);
emit telegramLogReceived(central.data(), setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolWls, a_isSend), a_priority);
}
// ---------------------------------------------------------------
// Writes a received or sent radio-telegram into log-file
// ---------------------------------------------------------------
void PrtCnvTelegramLogThread::writeRadioTelegramLog(const QByteArray &tele, bool a_isSend, int a_priority)
{
if (!m_DoLogRadioTelegram)
return;
emit telegramLogReceived(tele, setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolTetra, a_isSend), a_priority);
}
void PrtCnvTelegramLogThread::writeCentralTelegramLog(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_centralTelegram, bool a_isSend, int a_priority)
{
if (!m_DoLogCentralTelegram)
return;
// ---------------------------------------------------------------
// Writes the telegram to the file
// ---------------------------------------------------------------
void PrtCnvTelegramLogThread::writeTelegramLog(const QByteArray &a_data, int a_protocolType, int a_priority)
{
// get time with microseconds
timeval tv;
gettimeofday(&tv, nullptr);
uint64_t exactTime = tv.tv_sec;
exactTime = exactTime << 32;
exactTime += tv.tv_usec;
emit telegramLogReceived(a_centralTelegram->data(),
setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolCentral, a_isSend),
a_priority);
}
// generate the filename of the telegram-file: "PrefixYYMMDD_HH.krlog"
QString fileName = QStringLiteral("%1%2.krlog").arg(m_LogTelegramPathWithPrefix, QDateTime::fromSecsSinceEpoch(tv.tv_sec).toString(QStringLiteral("yyMMdd_hh")));
// open the log-file
QFile telegramFile(fileName);
(void)telegramFile.open(QIODevice::WriteOnly | QIODevice::Append);
// write header
N_CoPrtCnv::CoPrtCnvLogHeader lh;
lh.m_Length = a_data.size() + sizeof(N_CoPrtCnv::CoPrtCnvLogHeader);
lh.m_Version = 3;
lh.m_Priority = a_priority;
lh.m_Protocol = a_protocolType;
lh.m_Time = exactTime;
lh.m_Reserved = 0;
telegramFile.write(reinterpret_cast<const char *>(&lh), sizeof(N_CoPrtCnv::CoPrtCnvLogHeader));
// write telegram-data
telegramFile.write(a_data);
telegramFile.close();
}
void PrtCnvTelegramLogThread::writeWlsTelegramLog(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele, bool a_isSend, int a_priority)
{
if (!m_DoLogWlsTelegram)
return;
N_CoPrtCnv::CoPrtCnvCentralTelegram central(*tele);
emit telegramLogReceived(central.data(),
setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolWls, a_isSend),
a_priority);
}
void PrtCnvTelegramLogThread::writeRadioTelegramLog(const QByteArray &tele, bool a_isSend, int a_priority)
{
if (!m_DoLogRadioTelegram)
return;
emit telegramLogReceived(tele,
setSend(N_CoPrtCnv::CoPrtCnvLogHeader::e_DestProtocolTetra, a_isSend),
a_priority);
}
void PrtCnvTelegramLogThread::writeTelegramLog(const QByteArray &a_data, int a_protocolType, int a_priority)
{
timeval tv;
gettimeofday(&tv, nullptr);
uint64_t exactTime = tv.tv_sec;
exactTime = exactTime << 32;
exactTime += tv.tv_usec;
QString fileName = QStringLiteral("%1%2.krlog")
.arg(m_LogTelegramPathWithPrefix, QDateTime::fromSecsSinceEpoch(tv.tv_sec).toString(QStringLiteral("yyMMdd_hh")));
QFile telegramFile(fileName);
(void)telegramFile.open(QIODevice::WriteOnly | QIODevice::Append);
N_CoPrtCnv::CoPrtCnvLogHeader lh;
lh.m_Length = a_data.size() + sizeof(N_CoPrtCnv::CoPrtCnvLogHeader);
lh.m_Version = 3;
lh.m_Priority = a_priority;
lh.m_Protocol = a_protocolType;
lh.m_Time = exactTime;
lh.m_Reserved = 0;
telegramFile.write(reinterpret_cast<const char*>(&lh), sizeof(N_CoPrtCnv::CoPrtCnvLogHeader));
telegramFile.write(a_data);
telegramFile.close();
}
}
} // namespace PrtCnv
@@ -1,86 +1,116 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// **************************************************************************
#pragma once
#include "PrtCnvThread.hpp"
namespace N_CoPrtCnv
{
class CoPrtCnvCentralTelegram;
class CoPrtCnvCentralTelegram;
}
namespace TrainingAreaBase
{
namespace TetraIcd
{
struct TrainingAreaTelegram;
}
namespace TetraIcd
{
struct TrainingAreaTelegram;
}
}
namespace PrtCnv
{
/**
* This thread is used to log telegrams in a log-file. This action is separated
* from central/radio-thead because of 2 reasons:
*
* 1. An unwanted synchronisation of radio- and central thread will be avoided
* 2. Storing to a file is very slow and would thwart the radio and central-thread
* @author alois.wismer
* @version 1.0
* @updated 03-Mai-2010 17:57:34
*/
class PrtCnvTelegramLogThread final : public PrtCnvThread
{
Q_OBJECT
public:
explicit PrtCnvTelegramLogThread(PrtCnvThreadStarter* a_parent);
/**
*
* @param a_parent
*/
explicit PrtCnvTelegramLogThread(PrtCnvThreadStarter *a_parent);
int32_t create(NGL::Settings *settings) override;
int32_t init() override;
public slots:
/**
* Writes a received or sent central-telegram into log-file
*/
void writeCentralTelegramLog(N_CoPrtCnv::CoPrtCnvCentralTelegram *a_centralTelegram, bool a_isSend, int a_priority);
/**
* Writes a received or sent central-telegram into log-file
*/
void writeWlsTelegramLog(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele, bool a_isSend, int a_priority);
/**
* Writes a received or sent radio-telegram into log-file
*/
void writeRadioTelegramLog(const QByteArray &tele, bool a_isSend, int a_priority);
private:
signals:
/**
* This signal will be emitted when this thread receives a new telegram to log
*
* @param a_data
* @param a_protocolType
* @param a_isSend
* @param a_priority
*/
void telegramLogReceived(const QByteArray &a_data, int a_protocolType, int a_priority);
private slots:
/**
* Writes the telegram to the file
*
* @param a_data
* @param a_protocolType
* @param a_isSend
* @param a_priority
*/
void writeTelegramLog(const QByteArray &a_data, int a_protocolType, int a_priority);
protected:
/**
* The directory where we want to log the telegrams (configureable over parameter
* file)
*/
QString m_LogTelegramPathWithPrefix;
/**
* True if we want to log central-telegrams (configureable over parameter file)
*/
bool m_DoLogCentralTelegram;
/**
* True if we want to log wls-telegrams (configureable over parameter file)
*/
bool m_DoLogWlsTelegram;
/**
* True if we want to log TETRA-telegrams (configureable over parameter file)
*/
bool m_DoLogRadioTelegram;
};
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvThread
// **************************************************************************
#include "PrtCnvThread.hpp"
#include <QtCore/QThread>
@@ -18,57 +18,57 @@ namespace PrtCnv
{
bool PrtCnvThread::m_DoCleanDb = false;
bool PrtCnvThread::m_DoCleanDb = false;
// ---------------------------------------------------------------
// Constructor with thread-starter as parameter
// ---------------------------------------------------------------
PrtCnvThread::PrtCnvThread(PrtCnv::PrtCnvThreadStarter *a_parent, const char *loggerName)
: m_Parent(a_parent)
, m_currentThreadId(nullptr)
, m_logger(getLogger(loggerName))
{
}
int32_t PrtCnvThread::create(NGL::Settings *settings)
{
m_currentThreadId = QThread::currentThreadId();
m_Config = settings;
INFO_LOG(m_logger) << "create " << m_Name << " - current thread id is " << m_currentThreadId;
return 0;
}
int32_t PrtCnvThread::init()
{
INFO_LOG(m_logger) << "init " << m_Name;
return 0;
}
PrtCnvThread::PrtCnvThread(PrtCnv::PrtCnvThreadStarter* a_parent, const char *loggerName)
: m_Parent(a_parent)
, m_currentThreadId(nullptr)
, m_logger(getLogger(loggerName))
{}
int32_t PrtCnvThread::create(NGL::Settings *settings)
{
m_currentThreadId = QThread::currentThreadId();
m_Config = settings;
INFO_LOG(m_logger) << "create " << m_Name
<< " - current thread id is " << m_currentThreadId;
return 0;
}
int32_t PrtCnvThread::start()
{
INFO_LOG(m_logger) << "start " << m_Name;
return 0;
}
int32_t PrtCnvThread::init()
{
INFO_LOG(m_logger) << "init " << m_Name;
return 0;
}
int32_t PrtCnvThread::stop()
{
return 0;
}
int32_t PrtCnvThread::start()
{
INFO_LOG(m_logger) << "start " << m_Name;
return 0;
}
int32_t PrtCnvThread::deinit()
{
return 0;
}
int32_t PrtCnvThread::stop()
{
return 0;
}
int32_t PrtCnvThread::destroy()
{
return 0;
}
int32_t PrtCnvThread::deinit()
{
return 0;
}
int32_t PrtCnvThread::destroy()
{
return 0;
}
}
} // namespace PrtCnv
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvThread
// **************************************************************************
#pragma once
#include "IAppComponent.hpp"
@@ -21,30 +21,48 @@
namespace PrtCnv
{
class PrtCnvThreadStarter;
class PrtCnvThread : public QObject, public N_AppComponent::IAppComponent
/**
* The father-class of all threads in protocol-converter. It implements access to
* config-system and knows whether we have a restart after crash or a normal start
* (from scratch).
* @author wia
* @version 1.0
* @updated 21-Jan-2010 08:38:23
*/
class PrtCnvThread
: public QObject
, public N_AppComponent::IAppComponent
{
Q_OBJECT
protected:
NGL::Settings* m_Config;
protected:
/**
* Used to get configuration-parameter
*/
NGL::Settings *m_Config;
/**
* Pointer to ThreadStarter
*/
PrtCnvThreadStarter *m_Parent;
/**
* @brief The Id of the current thread (for debug purposes)
*/
Qt::HANDLE m_currentThreadId;
NGL::INGLLogger &m_logger;
public:
/**
* Indicates what happens with the DB while startup. True => it will be cleant;
* False => it will be restored (after crash). This variable will be True at
* startup when you use the parameter --cleandb when starting PrtCnv.
*/
static bool m_DoCleanDb;
PrtCnvThread(PrtCnvThreadStarter* a_parent, const char *loggerName);
/**
* Constructor with thread-starter as parameter
*
* @param a_parent
*/
PrtCnvThread(PrtCnvThreadStarter *a_parent, const char *loggerName);
int32_t create(NGL::Settings *settings) override;
@@ -53,7 +71,7 @@ protected:
int32_t init() override;
int32_t start() override;
int32_t start() override;
int32_t stop() override;
@@ -63,7 +81,6 @@ protected:
int32_t destroy() override;
};
}
@@ -1,16 +1,16 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvThreadStarter
// **************************************************************************
#include "PrtCnvThreadStarter.hpp"
#include "PrtCnvCentralThread.hpp"
#include "PrtCnvRadioThread.hpp"
@@ -23,103 +23,101 @@
namespace PrtCnv
{
PrtCnvThreadStarter::PrtCnvThreadStarter(const PrtCnv::PrtCnvApplication::E_ThreadId a_id,
const QString &configFileName,
PrtCnv::PrtCnvApplication* a_mainApp)
: m_Thread(nullptr)
, m_Application(a_mainApp)
, m_Id(a_id)
, m_settings(new NGL::Settings(configFileName))
, m_logger(getLogger("PrtCnvThreadStarter"))
{
DEBUG_LOG(m_logger) << "Using Config file '" << configFileName << "'";
}
PrtCnvThreadStarter::~PrtCnvThreadStarter()
{
delete m_settings;
}
void PrtCnvThreadStarter::run()
{
INFO_LOG(m_logger) << "Entering event loop for thread " << this << ", id: " << m_Id;
switch (m_Id)
// ---------------------------------------------------------------
// Constructor with id and ptr to main-app as parameters.
// ---------------------------------------------------------------
PrtCnvThreadStarter::PrtCnvThreadStarter(const PrtCnv::PrtCnvApplication::E_ThreadId a_id, const QString &configFileName, PrtCnv::PrtCnvApplication *a_mainApp)
: m_Thread(nullptr)
, m_Application(a_mainApp)
, m_Id(a_id)
, m_settings(new NGL::Settings(configFileName))
, m_logger(getLogger("PrtCnvThreadStarter"))
{
case PrtCnvApplication::e_Central:
m_Thread = new PrtCnvCentralThread(this);
break;
case PrtCnvApplication::e_Radio:
m_Thread = new PrtCnvRadioThread(m_Application->exerciseId(), this);
break;
case PrtCnvApplication::e_Db:
m_Thread = new PrtCnvDbThread(m_Application->databaseDriver(),
m_Application->databaseHostName(),
m_Application->databaseName(),
m_Application->databaseSchemaName(),
m_Application->databaseUserName(),
m_Application->databasePassword(),
this);
break;
case PrtCnvApplication::e_Log:
m_Thread = new PrtCnvTelegramLogThread(this);
break;
case PrtCnvApplication::e_Injection:
m_Thread = new PrtCnvInjectionThread(this);
break;
case PrtCnvApplication::e_RadioTraffic:
m_Thread = new PrtCnvRadioTrafficThread(this);
break;
case PrtCnvApplication::e_ThreadIdMax:
break;
DEBUG_LOG(m_logger) << "Using Config file '" << configFileName << "'";
}
if (!m_Thread)
PrtCnvThreadStarter::~PrtCnvThreadStarter()
{
ERROR_LOG(m_logger) << "Unknown threadId: " << m_Id;
return;
delete m_settings;
}
while (!m_Application)
sleep(1);
m_Application->waitForCreate(m_Id);
m_Thread->create(m_settings);
m_Application->waitForInit(m_Id);
m_Thread->init();
m_Application->waitForStart(m_Id);
m_Thread->start();
m_Application->waitForExec(m_Id);
// ---------------------------------------------------------------
// The run()-function, which will be called by Qt-Framework,
// when starting the thread.
// ---------------------------------------------------------------
void PrtCnvThreadStarter::run()
{
INFO_LOG(m_logger) << "Entering event loop for thread " << this << ", id: " << m_Id;
// allocate the thread
switch (m_Id)
{
case PrtCnvApplication::e_Central:
m_Thread = new PrtCnvCentralThread(this);
break;
exec();
case PrtCnvApplication::e_Radio:
m_Thread = new PrtCnvRadioThread(m_Application->exerciseId(), this);
break;
INFO_LOG(m_logger) << "Leaving event loop for thread " << this << ", id: " << m_Id;
delete m_Thread;
m_Thread = nullptr;
}
case PrtCnvApplication::e_Db:
m_Thread = new PrtCnvDbThread(m_Application->databaseDriver(),
m_Application->databaseHostName(),
m_Application->databaseName(),
m_Application->databaseSchemaName(),
m_Application->databaseUserName(),
m_Application->databasePassword(),
this);
break;
case PrtCnvApplication::e_Log:
m_Thread = new PrtCnvTelegramLogThread(this);
break;
case PrtCnvApplication::e_Injection:
m_Thread = new PrtCnvInjectionThread(this);
break;
case PrtCnvApplication::e_RadioTraffic:
m_Thread = new PrtCnvRadioTrafficThread(this);
break;
case PrtCnvApplication::e_ThreadIdMax:
break;
}
if (!m_Thread)
{
ERROR_LOG(m_logger) << "Unknown threadId: " << m_Id;
return;
}
while (!m_Application)
sleep(1);
m_Application->waitForCreate(m_Id);
m_Thread->create(m_settings);
m_Application->waitForInit(m_Id);
m_Thread->init();
m_Application->waitForStart(m_Id);
m_Thread->start();
m_Application->waitForExec(m_Id);
exec();
INFO_LOG(m_logger) << "Leaving event loop for thread " << this << ", id: " << m_Id;
delete m_Thread;
m_Thread = nullptr;
}
// ---------------------------------------------------------------
// Returns the desired thread.
// ---------------------------------------------------------------
PrtCnvThread *PrtCnvThreadStarter::getOtherThread(PrtCnvApplication::E_ThreadId a_threadId) const
{
return m_Application->getThreadStarter(a_threadId)->m_Thread;
}
PrtCnvThread *PrtCnvThreadStarter::getOtherThread(PrtCnvApplication::E_ThreadId a_threadId) const
{
return m_Application->getThreadStarter(a_threadId)->m_Thread;
}
}
} // namespace PrtCnv
@@ -1,65 +1,84 @@
// **************************************************************************
//
// (C) Copyright 2009 Swiss SIMTEC AG
//
// **************************************************************************
//
// $HeadURL$
// $LastChangedBy$
// $LastChangedDate$
// $LastChangedRevision$
//
// Implementation of the Class PrtCnvThreadStarter
// **************************************************************************
#pragma once
#include "PrtCnvApplication.hpp"
#include <QtCore/QThread>
namespace NGL {
namespace NGL
{
class Settings;
}
namespace PrtCnv
{
class PrtCnvThread;
/**
* This class is responsible for starting threads. It also impelements an access
* to other threads.
* @author wia
* @version 1.0
* @updated 21-Jan-2010 08:33:58
*/
class PrtCnvThreadStarter : public QThread
{
Q_OBJECT
protected:
protected:
/**
* Pointer to the started thread
*/
PrtCnvThread *m_Thread;
/**
* Pointer to main-application
*/
PrtCnvApplication *m_Application;
/**
* The id of the thread
*/
PrtCnvApplication::E_ThreadId m_Id;
/**
* The settings object
*/
NGL::Settings *m_settings;
NGL::INGLLogger &m_logger;
public:
PrtCnvThreadStarter(const PrtCnvApplication::E_ThreadId a_id,
const QString &settingsFile,
PrtCnvApplication *a_mainApp);
public:
/**
* Constructor with id and ptr to main-app as parameters.
*
* @param a_id
* @param a_mainApp The pointer to the main-app
*/
PrtCnvThreadStarter(const PrtCnvApplication::E_ThreadId a_id, const QString &settingsFile, PrtCnvApplication *a_mainApp);
~PrtCnvThreadStarter();
PrtCnvThread *getThread() const { return m_Thread; }
PrtCnvApplication *getMainApp() const { return m_Application; }
/**
* Returns the desired thread.
*
* @param a_threadId The id of the desired thread.
*/
PrtCnvThread *getOtherThread(PrtCnvApplication::E_ThreadId a_threadId) const;
protected:
protected:
/**
* The run()-function, which will be called by Qt-Framework, when starting the
* thread.
*/
void run() override;
};
@@ -1,5 +1,10 @@
/*
* @RDE_HEADER@
* Main for Tetra Simulation
* $Id$
* $HeadURL$
* $Author$
*/
#include <QtCore/QCoreApplication>
#include <QtCore/QPointF>
@@ -26,97 +31,77 @@ int main(int argc, char **argv)
LtsCommandLineParser::LtsCommandLineParser options(LtsCommandLineParser::LtsCommandLineParser::CustomConfigFile);
options.addOption({ QStringList() << QLatin1String("p") << QLatin1String("player")
, QLatin1String("number of players to be simulated.")
, QLatin1String("Default value")
, QLatin1String("5")
});
options.addOption({QStringList() << QLatin1String("p") << QLatin1String("player"),
QLatin1String("number of players to be simulated."),
QLatin1String("Default value"),
QLatin1String("5")});
options.addOption({ QStringList() << QLatin1String("n") << QLatin1String("northing")
, QLatin1String("initial position UTM north.")
, QLatin1String("Default value")
, QLatin1String("77777")
});
options.addOption({QStringList() << QLatin1String("n") << QLatin1String("northing"),
QLatin1String("initial position UTM north."),
QLatin1String("Default value"),
QLatin1String("77777")});
options.addOption({ QStringList() << QLatin1String("e") << QLatin1String("easting")
, QLatin1String("initial position UTM east.")
, QLatin1String("Default value")
, QLatin1String("99999")
});
options.addOption({QStringList() << QLatin1String("e") << QLatin1String("easting"),
QLatin1String("initial position UTM east."),
QLatin1String("Default value"),
QLatin1String("99999")});
options.addOption({ QStringList() << QLatin1String("f") << QLatin1String("first-id")
, QLatin1String("first equipment ID to use.")
, QLatin1String("Default value")
, QLatin1String("1101")
});
options.addOption({QStringList() << QLatin1String("f") << QLatin1String("first-id"),
QLatin1String("first equipment ID to use."),
QLatin1String("Default value"),
QLatin1String("1101")});
options.addOption({ QStringList() << QLatin1String("r") << QLatin1String("pprow")
, QLatin1String("players per row.")
, QLatin1String("Default value")
, QLatin1String("25")
});
options.addOption(
{QStringList() << QLatin1String("r") << QLatin1String("pprow"), QLatin1String("players per row."), QLatin1String("Default value"), QLatin1String("25")});
options.addOption({ QStringList() << QLatin1String("s") << QLatin1String("pspacing")
, QLatin1String("utm based spacing between the players.")
, QLatin1String("Default value")
, QLatin1String("100")
});
options.addOption({QStringList() << QLatin1String("s") << QLatin1String("pspacing"),
QLatin1String("utm based spacing between the players."),
QLatin1String("Default value"),
QLatin1String("100")});
options.addOption({ QStringList() << QLatin1String("z") << QLatin1String("issi")
, QLatin1String("DestinationIssi / HostISSI")
, QLatin1String("Default value")
, QLatin1String("2")
});
options.addOption(
{QStringList() << QLatin1String("z") << QLatin1String("issi"), QLatin1String("DestinationIssi / HostISSI"), QLatin1String("Default value"), QLatin1String("2")});
options.addOption({ QStringList() << QLatin1String("m") << QLatin1String("movements")
, QLatin1String("how many movements per milliseconds to make.")
, QLatin1String("Default value")
, QLatin1String("2000")
});
options.addOption({QStringList() << QLatin1String("m") << QLatin1String("movements"),
QLatin1String("how many movements per milliseconds to make."),
QLatin1String("Default value"),
QLatin1String("2000")});
options.addOption({ QStringList() << QLatin1String("d") << QLatin1String("death")
, QLatin1String("minimum times, after the movements timer is triggered, a dead player can revive.")
, QLatin1String("Default value")
, QLatin1String("100")
});
options.addOption({QStringList() << QLatin1String("d") << QLatin1String("death"),
QLatin1String("minimum times, after the movements timer is triggered, a dead player can revive."),
QLatin1String("Default value"),
QLatin1String("100")});
options.addOption({ QStringList() << QLatin1String("o") << QLatin1String("death-offset")
, QLatin1String("maximum times, after the movements timer is triggered, a dead player can revive.")
, QLatin1String("(0 -> identical to min)")
, QLatin1String("0")
});
options.addOption({QStringList() << QLatin1String("o") << QLatin1String("death-offset"),
QLatin1String("maximum times, after the movements timer is triggered, a dead player can revive."),
QLatin1String("(0 -> identical to min)"),
QLatin1String("0")});
options.addOption({ QStringList() << QLatin1String("t") << QLatin1String("pattern")
, QLatin1String("pattern the player has to walk [enter pattern by hand or pattern alias-name from settings file]\r\nfor more info, enter '--pattern-help'.")
, QLatin1String("Default value")
, QLatin1String("3,30,20#3,30,-20#3,-30,-20#3,-30,20")
});
options.addOption(
{QStringList() << QLatin1String("t") << QLatin1String("pattern"),
QLatin1String("pattern the player has to walk [enter pattern by hand or pattern alias-name from settings file]\r\nfor more info, enter '--pattern-help'."),
QLatin1String("Default value"),
QLatin1String("3,30,20#3,30,-20#3,-30,-20#3,-30,20")});
options.addOption({ QStringList() << QLatin1String("demand-old-broadcast-telegrams")
, QLatin1String("player demand old broadcast telegrams starting at BCI <default value>")
, QLatin1String("Default value")
, QLatin1String("0")
});
options.addOption({QStringList() << QLatin1String("demand-old-broadcast-telegrams"),
QLatin1String("player demand old broadcast telegrams starting at BCI <default value>"),
QLatin1String("Default value"),
QLatin1String("0")});
options.addOption({ QStringList() << QLatin1String("deactivate-single-mines")
, QLatin1String("the first player deactivates single mines with ids from minimum-mine-id to maximum-mine-id")
});
options.addOption({QStringList() << QLatin1String("deactivate-single-mines"),
QLatin1String("the first player deactivates single mines with ids from minimum-mine-id to maximum-mine-id")});
options.addOption({ QStringList() << QLatin1String("minimum-mine-id")
, QLatin1String("sets the value for minimum-mine-id used within deactivate-single-mines command")
, QLatin1String("Default value")
, QLatin1String("minimum-mine-id 2048")
});
options.addOption({QStringList() << QLatin1String("minimum-mine-id"),
QLatin1String("sets the value for minimum-mine-id used within deactivate-single-mines command"),
QLatin1String("Default value"),
QLatin1String("minimum-mine-id 2048")});
options.addOption({ QStringList() << QLatin1String("maximum-mine-id")
, QLatin1String("sets the value for maximum-mine-Id used within deactivate-single-mines command")
, QLatin1String("Default value")
, QLatin1String("maximum-mine-id 2100")
});
options.addOption({QStringList() << QLatin1String("maximum-mine-id"),
QLatin1String("sets the value for maximum-mine-Id used within deactivate-single-mines command"),
QLatin1String("Default value"),
QLatin1String("maximum-mine-id 2100")});
options.addOption({ QStringList() << QLatin1String("pattern-help")
, QLatin1String("help for the pattern interpreter.")
});
options.addOption({QStringList() << QLatin1String("pattern-help"), QLatin1String("help for the pattern interpreter.")});
if (!options.init())
@@ -127,7 +112,7 @@ int main(int argc, char **argv)
QSettings serverSettings(app.applicationDirPath() + QLatin1String("/") + options.iniFile(), QSettings::IniFormat);
TTSArgs ttsArgs;
// args.destIssi = serverSettings.value(QLatin1String("Radio/HostISSI"), 2).toInt();
ttsArgs.destIssi = options.isSet(QLatin1String("issi")) ? options.value(QLatin1String("issi")).toInt() : 2;
ttsArgs.cntPlayer = options.isSet(QLatin1String("player")) ? options.value(QLatin1String("player")).toInt() : 0;
int northPos_arg = options.isSet(QLatin1String("northing")) ? options.value(QLatin1String("northing")).toInt() : 77777;
@@ -161,8 +146,7 @@ int main(int argc, char **argv)
WARNING_LOG(logger) << " ... DestinationIssi/HostIssi: " << ttsArgs.destIssi;
WARNING_LOG(logger) << " ... on Position n/e: " << ttsArgs.position.y() << "/" << ttsArgs.position.x();
WARNING_LOG(logger) << " ... first equipmentID is: " << ttsArgs.eqIdStart;
WARNING_LOG(logger) << " ... player is reborn randomly after minimum " << ttsArgs.minimumDeathTicks
<< " ticks and maximum " << ttsArgs.maximumDeathTicks << " ticks";
WARNING_LOG(logger) << " ... player is reborn randomly after minimum " << ttsArgs.minimumDeathTicks << " ticks and maximum " << ttsArgs.maximumDeathTicks << " ticks";
WARNING_LOG(logger) << " ... pattern = " << ttsArgs.pattern;
WARNING_LOG(logger) << " ... max. " << ttsArgs.pprow << " players per row";
WARNING_LOG(logger) << " ... spacing of '" << ttsArgs.pspacing << " UTM east' between players";
@@ -172,8 +156,7 @@ int main(int argc, char **argv)
if (!s->listen(QHostAddress::Any, serverSettings.value(QLatin1String("Radio/Port"), 4200).toInt()))
{
ERROR_LOG(logger) << "Error listening on localhost:" << serverSettings.value(QLatin1String("Radio/Port"), 52010).toInt() << ": "
<< s->errorString();
ERROR_LOG(logger) << "Error listening on localhost:" << serverSettings.value(QLatin1String("Radio/Port"), 52010).toInt() << ": " << s->errorString();
delete s;
return -1;
}
@@ -1,5 +1,10 @@
/*
* @RDE_HEADER@
* Listen Server for Tetra Simulation
* $Id$
* $HeadURL$
* $Author$
*/
#include "server.h"
#include <NGLLogger/NGLLoggerBootstrap.h>
@@ -9,9 +14,9 @@
TTServer::TTServer(const TTSArgs &ttsArgs) : m_ttsArgs(ttsArgs)
.getNGLLogger("TTServer")),
m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger()) {
connect(this, &TTServer::newConnection,
this, &TTServer::onNewConnection);
m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
{
connect(this, &TTServer::newConnection, this, &TTServer::onNewConnection);
}
void TTServer::onNewConnection()
@@ -19,16 +24,13 @@ void TTServer::onNewConnection()
QTcpSocket *sock = nextPendingConnection();
if (!sock)
return;
NOTICE_LOG(m_logger) << "New incoming connection from "
<< sock->peerName() << ":"
<< sock->peerPort();
NOTICE_LOG(m_logger) << "New incoming connection from " << sock->peerName() << ":" << sock->peerPort();
TTWorker *ttw = new TTWorker(sock, m_ttsArgs);
if (!ttw->init())
exit(5);
connect(sock, &QTcpSocket::disconnected,
this, &TTServer::onDisconnect);
connect(sock, &QTcpSocket::disconnected, this, &TTServer::onDisconnect);
}
void TTServer::onDisconnect()
@@ -1,5 +1,10 @@
/*
* @RDE_HEADER@
* Listen Server for Tetra Simulation
* $Id$
* $HeadURL$
* $Author$
*/
#pragma once
@@ -19,9 +24,9 @@ struct runningPattern
struct TTSArgs
{
QPointF position;
QString pattern;
QSettings *settings = nullptr;
QPointF position;
QString pattern;
QSettings *settings = nullptr;
int destIssi = 0;
unsigned int cntPlayer = 0;
unsigned int eqIdStart = 0;
@@ -32,9 +37,9 @@ struct TTSArgs
unsigned int movs_per_msec = ~0U;
unsigned int minimumMineId = 0;
unsigned int maximumMineId = 0;
bool demandOldBraodcastTelegrams = false;
int demandOldBraodcastTelegramsCounter = 0;
bool deactivationSingleMines = false;
bool demandOldBraodcastTelegrams = false;
int demandOldBraodcastTelegramsCounter = 0;
bool deactivationSingleMines = false;
};
class TTServer : public QTcpServer
@@ -48,7 +53,6 @@ protected Q_SLOTS:
void onDisconnect();
protected:
NGL::INGLLogger &m_logger;
NGL::INGLLogger &m_logger;
TTSArgs m_ttsArgs;
};
@@ -1,5 +1,10 @@
/*
* @RDE_HEADER@
* Worker for Tetra Simulation
* $Id$
* $HeadURL$
* $Author$
*/
#include "worker.h"
#include <utility>
@@ -23,19 +28,15 @@ TTWorker::TTWorker(QTcpSocket *socket, const TTSArgs &ttsArgs)
, m_generalPosition(ttsArgs.position)
.getNGLLogger("TTWorker"))
{
qsrand(time(nullptr));
qsrand(time(nullptr)); // randomize for later use in class "Player"
}
bool TTWorker::init()
{
connect(m_socket, &QTcpSocket::disconnected,
this, &TTWorker::deleteLater);
connect(m_socket, &QAbstractSocket::errorOccurred,
this, &TTWorker::onSocketError);
connect(m_socket, &QTcpSocket::readyRead,
this, &TTWorker::onReadyRead);
connect(m_timer, &QTimer::timeout,
this, &TTWorker::onSendPlayerPositions);
connect(m_socket, &QTcpSocket::disconnected, this, &TTWorker::deleteLater);
connect(m_socket, &QAbstractSocket::errorOccurred, this, &TTWorker::onSocketError);
connect(m_socket, &QTcpSocket::readyRead, this, &TTWorker::onReadyRead);
connect(m_timer, &QTimer::timeout, this, &TTWorker::onSendPlayerPositions);
if (m_ttsArgs.movs_per_msec < 200)
{
@@ -47,16 +48,16 @@ bool TTWorker::init()
void TTWorker::startExecution()
{
//mTimer->start(mTtsargs.movs_per_msec);
m_timer->start(m_ttsArgs.movs_per_msec);
NOTICE_LOG(m_logger) << "Start Exe login all Player";
// create all players & add them to the players-list, send logins
for (unsigned int i = 0; i < m_ttsArgs.cntPlayer; i++)
{
int eqId = m_ttsArgs.eqIdStart + i;
int issi = m_ttsArgs.eqIdStart + i + 2000;
int issi = m_ttsArgs.eqIdStart + i + 2000; // = Ausstattungsnummer + 2000
QPointF posUTM((m_generalPosition.x() + (i / m_ttsArgs.pprow) * m_ttsArgs.pspacing),
(m_generalPosition.y() + (i % m_ttsArgs.pprow) * m_ttsArgs.pspacing));
(m_generalPosition.y() + (i % m_ttsArgs.pprow) * m_ttsArgs.pspacing)); // initial position for a player
Player *p = new Player(eqId, issi, m_ttsArgs.minimumDeathTicks, m_ttsArgs.maximumDeathTicks, posUTM);
m_playerList.append(p);
@@ -69,9 +70,9 @@ void TTWorker::startExecution()
if (m_ttsArgs.demandOldBraodcastTelegrams)
QTimer::singleShot(1000, this, &TTWorker::onSendNachforderungBroadcastTelegramm);
}
// QTimer::singleShot(25000, this , &TTWorker::onSendNlosSimulatorDirection);
// QTimer::singleShot(120000, this , &TTWorker::onSendNlosFireResult);
}
QVector<runningPattern> TTWorker::interpretPattern(QString pattern) const
{
@@ -81,56 +82,62 @@ QVector<runningPattern> TTWorker::interpretPattern(QString pattern) const
exit(8);
}
if (pattern.at(0) == QLatin1Char('%'))
if (pattern.at(0) == QLatin1Char('%')) // this pattern is a predefined pattern from the settings file
{
pattern.remove(0, 1);
pattern.remove(0, 1); // delete '%'-character as it disturbes the interpreter
QString patternAlias = pattern;
pattern = m_ttsArgs.settings->value(QLatin1String("pattern/") + patternAlias).toString();
if (pattern.isEmpty())
if (pattern.isEmpty()) // there is no pattern with this alias!
{
ERROR_LOG(m_logger) << "INVALID PATTERN - alias '" << patternAlias << "' is not available in settings file! Program halted.";
exit(9);
}
}
// now the pattern (if it was only an alias) is refered, continue..:
if (pattern.at(pattern.count() - 1) == QLatin1Char('#'))
if (pattern.at(pattern.count() - 1) == QLatin1Char('#')) // delete the character ';' if there is one at the end of string - because of strtok/split
pattern.remove(pattern.count() - 1, 1);
QVector<runningPattern> newPatternList;
runningPattern rp;
QStringList strings = pattern.split(QLatin1Char('#'));
QStringList stringy;
int i;
QVector<runningPattern> newPatternList; // list we give back to replace the patternList in this class
runningPattern rp; // pattern we use (and reuse) to add a new runningPattern instance to the patternList
QStringList strings = pattern.split(QLatin1Char('#')); // list of pattern (f.g. "1,2,3", "1,2,3");
QStringList stringy; // list of pattern-ingredients ;) (f.g. "1", "2", "3")
int i; // counter, global because of error message at the end of this function (see variable "strings")
for (i = 0; i < strings.count(); i++)
{
stringy = strings.at(i).split(QLatin1Char(','));
stringy = strings.at(i).split(QLatin1Char(',')); // split one pattern to the "ingredients"
if (stringy.count() != 3)
if (stringy.count() != 3) // pattern consists of 3 numbers, if there are more or less, then the pattern is wrong
break;
bool ok = true;
rp.steps = stringy.at(0).toInt(&ok); if (!ok) break;
rp.ethering = stringy.at(1).toInt(&ok); if (!ok) break;
rp.northering = stringy.at(2).toInt(&ok); if (!ok) break;
rp.steps = stringy.at(0).toInt(&ok);
if (!ok)
break; // is not a number, so throw an error and exit this application
rp.ethering = stringy.at(1).toInt(&ok);
if (!ok)
break; // ^
rp.northering = stringy.at(2).toInt(&ok);
if (!ok)
break; // ^
newPatternList.append(rp);
newPatternList.append(rp); // add a new instance to the list (i hope this will create an instance and does not use a reference !!1)
if (i == strings.count() - 1)
return newPatternList;
if (i == strings.count() - 1) // are we at the end of the strings.count ? if yes, then return the list - important to NOT throw a error message
return newPatternList; // IMPORTANT! Or an wrong error message will be thrown
}
ERROR_LOG(m_logger) << "INVALID PATTERN: '" << strings.at(i) << "'. Cannot start without correct pattern!";
exit(5);
exit(5); // we can't work - exit!
return QVector<runningPattern>();
return QVector<runningPattern>(); // for security & compiler issues..
}
void TTWorker::sendLogin(uint32_t eqId, uint32_t issi)
@@ -153,19 +160,17 @@ void TTWorker::onReadyRead()
if (N_CoPrtCnv::CoPrtCnvRadioTelegram::MAGIC_NUMBER != header.m_MagicNumber)
{
ERROR_LOG(m_logger) << "Disconnect because radio-Telegram does not begin with magic-number A5: I got "
<< header.m_MagicNumber;
ERROR_LOG(m_logger) << "Disconnect because radio-Telegram does not begin with magic-number A5: I got " << header.m_MagicNumber;
m_socket->disconnectFromHost();
return;
}
if (!N_CoPrtCnv::CoPrtCnvRadioTelegram::isTelegramLengthOk(header.m_Length))
{
WARNING_LOG(m_logger) << "Radio-Telegram length to big: " << header.m_Length
<< " - but I proceed with this telegram.";
WARNING_LOG(m_logger) << "Radio-Telegram length to big: " << header.m_Length << " - but I proceed with this telegram.";
}
// prepare data-bucket for entire telegram
uint16_t dataSize = header.m_Length + sizeof(header);
if (m_socket->bytesAvailable() < dataSize)
{
@@ -173,7 +178,7 @@ void TTWorker::onReadyRead()
return;
}
QByteArray buf(dataSize, Qt::Uninitialized);
// read the telegram with header
bytesRead = 0;
while (bytesRead < dataSize)
{
@@ -189,23 +194,22 @@ void TTWorker::onReadyRead()
void TTWorker::handleReceivedTelegram(const QByteArray &data)
{
INFO_LOG(m_logger) << data.size();
// evaluate PDU-Type
switch (data.at(4))
{
case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_RegisterInd:
handleRegisterInd();
startExecution();
break;
// response to register indication
case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_RegisterInd:
handleRegisterInd();
startExecution();
break;
case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_DataIndReq:
handleDataIndReq(data);
break;
default:
INFO_LOG(m_logger) << "Radio-Telegram with PDU-Type=" << (int)data[4]
<< " not implemented!";
break;
case N_CoPrtCnv::CoPrtCnvRadioTelegram::e_DataIndReq:
handleDataIndReq(data); // tele->getDestISSI() == ISSI an des angesprochenen Teilnehmers
// data is deleted inside handleDataIndReq()
break;
default:
INFO_LOG(m_logger) << "Radio-Telegram with PDU-Type=" << (int)data[4] << " not implemented!";
break;
}
}
@@ -214,7 +218,7 @@ void TTWorker::sendTelegram(N_CoPrtCnv::CoPrtCnvRadioTelegram *radioTelegram, ui
radioTelegram->setZaehler(m_counter++);
radioTelegram->setDestISSI(m_ttsArgs.destIssi);
radioTelegram->setSrcISSI(issi);
//INFO_LOG(mLogger) << "BITE message sent for Player (" << eqId << ") with ISSI: " << issi;
m_socket->write(radioTelegram->data());
m_socket->flush();
delete radioTelegram;
@@ -226,15 +230,14 @@ void TTWorker::onSendNachforderungBroadcastTelegramm()
if (p->isLogin)
{
N_CoPrtCnv::CoPrtCnvRadioTelegram tel(GEF_NACHFORDERUNG_BROADCAST_TELEGRAMME,
10, p->eqId);
N_CoPrtCnv::CoPrtCnvRadioTelegram tel(GEF_NACHFORDERUNG_BROADCAST_TELEGRAMME, 10, p->eqId);
tel.setZaehler(0);
tel.setBroadcastIndex(0);
tel.setDestISSI(m_ttsArgs.destIssi);
tel.setSrcISSI(p->issi);
tel.setPayload4Byte(0);
tel.setPayload1Byte(0);
tel.setPayload2Byte(m_ttsArgs.demandOldBraodcastTelegramsCounter);
tel.setPayload4Byte(0); // gps_zeit
tel.setPayload1Byte(0); // ruecksetzzaehler
tel.setPayload2Byte(m_ttsArgs.demandOldBraodcastTelegramsCounter); // broadcast index
m_socket->write(tel.data());
}
else
@@ -267,56 +270,60 @@ void TTWorker::onSendDeaktivierungEinzelminen()
QTimer::singleShot(1000, this, &TTWorker::onSendDeaktivierungEinzelminen);
}
/*!
\brief Send sample NlosFireResult Telegram every three minutes (FOR TESTING NLOS)
\author Niklas Schmidt
*/
// void TTWorker::onSendNlosFireResult()
// {
// if (m_playerList.isEmpty())
// {
// ERROR_LOG(m_logger) << "No player for onSendNlosFireResult...";
// return;
// }
// Player *p = m_playerList.at(0);
// TrainingAreaBase::TetraIcd::NlosDirectionOrShootingResult fireResult;
// fireResult.header.equipmentNumber = p->eqId;
// fireResult.header.timeStamp = time(nullptr) * 1000;
// fireResult.messageId = 0xE401;
// fireResult.version = 4;
// fireResult.shootingRes = TrainingAreaBase::TetraIcd::NlosDirectionOrShootingResult::ShootingResult::Hit;
// fireResult.targetEquipmentNumber = 1205;
// INFO_LOG(m_logger) << "Send NlosFireResult";
// sendTelegram(fireResult, p->issi);
// QTimer::singleShot(120000, this, &TTWorker::onSendNlosFireResult);
// }
/*!
\brief Send sample NlosSimulatorDirection Telegram(FOR TESTING NLOS)
\author Niklas Schmidt
*/
// void TTWorker::onSendNlosSimulatorDirection()
// {
// if (m_playerList.isEmpty())
// {
// ERROR_LOG(m_logger) << "No player for onSendNlosFireResult...";
// return;
// }
// Player *p = m_playerList.at(0);
// TrainingAreaBase::TetraIcd::NlosDirectionOrShootingResult simulatorDirection;
// simulatorDirection.header.equipmentNumber = 7150;
// simulatorDirection.header.timeStamp = time(nullptr) * 1000;
// simulatorDirection.messageId = 0xE400;
// std::random_device rd; //Will be used to obtain a seed for the random number engine
// std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
// std::uniform_int_distribution<long long> distrib(1, 34999);
// simulatorDirection.version = 4;
// simulatorDirection.directionInDegree = 0/*distrib(gen)*/;
// simulatorDirection.attachmentInDegree = 0;
// INFO_LOG(m_logger) << "Send NlosSimulatorDirection";
// sendTelegram(simulatorDirection, p->issi);
// QTimer::singleShot(100000, this, &TTWorker::onSendNlosSimulatorDirection);
// }
void TTWorker::sendTaktischerStatus(uint32_t eqId, uint32_t issi, TrainingAreaBase::TetraIcd::VulnerabilityState vbg)
{
@@ -345,7 +352,7 @@ void TTWorker::sendTaktischerStatus(uint32_t eqId, uint32_t issi, TrainingAreaBa
void TTWorker::sendSanitationReport(uint32_t eqId, uint32_t issi)
{
m_toogle = false;
return;
return; //NOTE: Will never be executed
TrainingAreaBase::TetraIcd::SanitaryMaterialStockReport tele;
tele.header.equipmentNumber = eqId;
tele.header.timeStamp = time(nullptr) * 1000;
@@ -357,23 +364,22 @@ void TTWorker::sendSanitationReport(uint32_t eqId, uint32_t issi)
mat.emplace_back(i);
tele.sanitaryMaterialStock = mat;
sendTelegram(tele, issi);
}
// void TTWorker::sendSanitation(uint32_t eqId, uint32_t issi)
// {
// m_toogle = true;
// return; //NOTE: Will never be executed
// TrainingAreaBase::TetraIcd::Sanitation tele;
// tele.header.equipmentNumber = eqId;
// tele.header.timeStamp = time(nullptr) * 1000;
// tele.proceduresTaken = 1117;
// tele.uniqeId = 2777777;
// tele.originatorEquipmentNumber = 1001;
// tele.qualification = TrainingAreaBase::TetraIcd::Qualification::FAA;
// tele.sanitationResult = TrainingAreaBase::TetraIcd::SanitationResult::Needed;
// sendTelegram(tele, issi);
// }
void TTWorker::sendBITE(uint32_t eqId, uint32_t issi)
{
@@ -383,21 +389,21 @@ void TTWorker::sendBITE(uint32_t eqId, uint32_t issi)
tele.loginType = TrainingAreaBase::TetraIcd::BiteReport::LoginType::Relogin;
tele.configError = false;
sendTelegram(tele, issi);
sendTaktischerStatus(eqId, issi, TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady);
sendTaktischerStatus(eqId, issi, TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady); // rebirth for old Players, who are still dead
}
void TTWorker::handleDataIndReq(const QByteArray &data)
{
QScopedPointer<N_CoPrtCnv::CoPrtCnvRadioTelegram> radioTelegram(new N_CoPrtCnv::CoPrtCnvRadioTelegram(data));
int telID = radioTelegram->getTelID();
int telID = radioTelegram->getTelID(); // get the Telegram ID, to switch through it
switch (telID)
{
#if 0
TODO
case GEF_AUSLOESUNG_DUS_TREFFER:
case GEF_AUSLOESUNG_DUS_TREFFER: // player hit! send a taktischer status that we are dead
{
/* TODO: only receive damage, do not die instantly - rt_data unused */
DEBUG_LOG(mLogger) << "handleAusloeserDUSTreffer: eqId=" << radioTelegram->getIdentity() <<
" issi=" << radioTelegram->getDestISSI();
@@ -410,144 +416,145 @@ void TTWorker::handleDataIndReq(const QByteArray &data)
const ausloesung_dus_treffer_rt &rt_data = static_cast<XDR_AUSLOESUNG_DUS_TREFFER_Wrapper *>(wrapper)->get_rt();
if (rt_data.bek_wirkung > 90)
sendTaktischerStatus(radioTelegram->getIdentity(), radioTelegram->getDestISSI(), TOTALAUSFALL);
sendTaktischerStatus(radioTelegram->getIdentity(), radioTelegram->getDestISSI(), TOTALAUSFALL); // kill Player
else
sendTaktischerStatus(radioTelegram->getIdentity(), radioTelegram->getDestISSI(), ANNAEHENDER_TREFFER);
delete wrapper;
return;
}
#endif
case GEF_TAKTISCHER_STATUS:
{
N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
TrainingAreaBase::TetraIcd::StateChange sc = TrainingAreaBase::TetraIcd::StateChange::fromJson(tele->jsonData());
delete tele;
DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState) << " and this bits here: " << sc.vulnerabilityBits;
sc.header.timeStamp = time(nullptr) * 1000;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++)
case GEF_TAKTISCHER_STATUS: // just resend this one to answer the station's question
{
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
TrainingAreaBase::TetraIcd::StateChange sc = TrainingAreaBase::TetraIcd::StateChange::fromJson(tele->jsonData());
delete tele;
DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState)
<< " and this bits here: " << sc.vulnerabilityBits;
sc.header.timeStamp = time(nullptr) * 1000;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++) // get issi from player's eqId
{
issi = m_playerList.at(i)->issi;
break;
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
{
issi = m_playerList.at(i)->issi;
break;
}
}
ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState)
<< " and this bits here: " << sc.vulnerabilityBits;
sendTelegram(sc, issi); // resend
return;
}
ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << static_cast<int>(sc.vulnerabilityState) << " and this bits here: " << sc.vulnerabilityBits;
sendTelegram(sc, issi);
return;
}
case GEF_SANITAETSDIENST_INSTANDSETZUNG_PVSAN:
{
N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
TrainingAreaBase::TetraIcd::Sanitation sc = TrainingAreaBase::TetraIcd::Sanitation::fromJson(tele->jsonData());
delete tele;
DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got procedure: " << sc.proceduresTaken;
sc.header.timeStamp = time(nullptr) * 1000;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++)
case GEF_SANITAETSDIENST_INSTANDSETZUNG_PVSAN:
{
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
{
issi = m_playerList.at(i)->issi;
break;
}
}
N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
TrainingAreaBase::TetraIcd::Sanitation sc = TrainingAreaBase::TetraIcd::Sanitation::fromJson(tele->jsonData());
delete tele;
ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << sc.proceduresTaken;
sendTelegram(sc, issi);
return;
}
case GEF_TREFFER_AUSLOESUNG:
case GEF_INIT:
{
TrainingAreaBase::TetraIcd::StateChange tele;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++)
DEBUG_LOG(m_logger) << " Try to Resetnd State " << sc.header.equipmentNumber << " we got procedure: " << sc.proceduresTaken;
sc.header.timeStamp = time(nullptr) * 1000;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++) // get issi from player's eqId
{
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
{
issi = m_playerList.at(i)->issi;
break;
}
}
ERROR_LOG(m_logger) << " Try to Resetnd S2tate " << sc.header.equipmentNumber << " we got state: " << sc.proceduresTaken;
sendTelegram(sc, issi); // resend
return;
}
case GEF_TREFFER_AUSLOESUNG: // we have got a new status (f.g. wounded lying) and send back our new status
case GEF_INIT: // ?? .. or just act like this is a treffer ausloesung ....... ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
{
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
TrainingAreaBase::TetraIcd::StateChange tele;
uint32_t issi = 0;
for (int i = 0; i < m_playerList.count(); i++) // get issi from player's eqId
{
issi = m_playerList.at(i)->issi;
break;
if (radioTelegram->getIdentity() == m_playerList.at(i)->eqId)
{
issi = m_playerList.at(i)->issi;
break;
}
}
TrainingAreaBase::TetraIcd::VulnerabilityState state = (telID == GEF_TREFFER_AUSLOESUNG)
? static_cast<TrainingAreaBase::TetraIcd::VulnerabilityState>(radioTelegram->getPayloadDataUInt8(7))
: TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady; //get vbg from radio
tele.originatorType = TrainingAreaBase::TetraIcd::OriginatorType::Initialisation; //set origin
tele.header.equipmentNumber = radioTelegram->getIdentity(); //set header
tele.header.timeStamp = time(nullptr) * 1000;
uint32_t vulcomplete = radioTelegram->getPayloadDataUInt32(8, 2);
uint32_t vitality = vulcomplete &= 0xF000;
vitality >>= 12;
tele.tasVulnerabilityKindId = vulcomplete &= 0x0FFF;
//including vitality
tele.tasVulnerabilityKindId <<= 16;
tele.tasVulnerabilityKindId |= 0xB1;
tele.tasVitality = (vitality - 1) * 10;
if (tele.tasVitality < 0)
tele.tasVitality = 100;
if (state == TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady && vitality > 0)
tele.vulnerabilityState = TrainingAreaBase::TetraIcd::VulnerabilityState::MediumDamage;
else
tele.vulnerabilityState = state;
sendTelegram(tele, issi); // send new status
return;
}
TrainingAreaBase::TetraIcd::VulnerabilityState state = (telID == GEF_TREFFER_AUSLOESUNG)
? static_cast<TrainingAreaBase::TetraIcd::VulnerabilityState>(radioTelegram->getPayloadDataUInt8(7))
: TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady;
// case GEF_NLOS_DATENVERKEHR_TDS_GEF:
// {
// ERROR_LOG(m_logger) << "NlosTargetData empfangen";
// N_CoPrtCnv::CoPrtCnvCentralTelegram *tele = N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(radioTelegram.data());
// TrainingAreaBase::TetraIcd::NlosTargetData sc = TrainingAreaBase::TetraIcd::NlosTargetData::fromJson(tele->jsonData());
// delete tele;
// QJsonDocument doc(sc.toJson());
// ERROR_LOG(m_logger) << "Receive NlosTargetData Size: " << radioTelegram.data()->getSize() << "\n Structure: " << doc.toJson(QJsonDocument::Indented);
// return;
tele.originatorType = TrainingAreaBase::TetraIcd::OriginatorType::Initialisation;
tele.header.equipmentNumber = radioTelegram->getIdentity();
tele.header.timeStamp = time(nullptr) * 1000;
uint32_t vulcomplete = radioTelegram->getPayloadDataUInt32(8, 2);
uint32_t vitality = vulcomplete &= 0xF000;
vitality >>= 12;
tele.tasVulnerabilityKindId = vulcomplete &= 0x0FFF;
tele.tasVulnerabilityKindId <<= 16;
tele.tasVulnerabilityKindId |= 0xB1;
tele.tasVitality = (vitality - 1) * 10;
if (tele.tasVitality < 0)
tele.tasVitality = 100;
if (state == TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady && vitality > 0)
tele.vulnerabilityState = TrainingAreaBase::TetraIcd::VulnerabilityState::MediumDamage;
else
tele.vulnerabilityState = state;
sendTelegram(tele, issi);
return;
}
// }
}
// miscellaneous messages..
if (radioTelegram->isLoginTelegram())
{
// fixme: login accepted ?
DEBUG_LOG(m_logger) << "player cont: " << m_playerList.count();
for (int i = 0; i < m_playerList.count(); i++)
for (int i = 0; i < m_playerList.count(); i++) // set player isLogin true
{
Player *p = m_playerList.at(i);
if (radioTelegram->getDestISSI() == p->issi)
if (radioTelegram->getDestISSI() == p->issi) // is this the player we look for?
{
if (p->isLogin)
return;
DEBUG_LOG(m_logger) << "Player #" << i << " with eqId=" << p->eqId << " and issi=" << p->issi << " is now logged in.";
p->isLogin = true;
sendBITE(p->eqId, p->issi);
sendBITE(p->eqId, p->issi); // send BITE message to log us in, though
return;
}
}
// player not found
ERROR_LOG(m_logger) << "Invalid player was logged in. issi: '" << radioTelegram->getDestISSI() << "'";
return;
}
// none of our swicthes & conditions wanted this received message! we have got a unused or invalid message.. throw it away and give, at least, a DEBUG message
DEBUG_LOG(m_logger) << "Received unused or invalid telegram with Telegram-ID: " << telID;
}
static void fillHeader(char *data, int len)
{
N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *hdr
= (N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *)data;
N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *hdr = (N_CoPrtCnv::CoPrtCnvRadioTelegram::PrtCnvRadioGwHeader *)data;
hdr->m_MagicNumber = N_CoPrtCnv::CoPrtCnvRadioTelegram::MAGIC_NUMBER;
hdr->m_Counter = 0;
hdr->m_Length = len;
@@ -565,38 +572,38 @@ void TTWorker::handleRegisterInd()
m_socket->write(buf);
//mTimer->start(1000);
}
void TTWorker::movePlayer(Player *p)
void TTWorker::movePlayer(Player *p) // move the player like the pattern says
{
// use all variables from the Player POINTER (do not use new instances)
if (p->patternInList > m_patternList.count() - 1)
p->patternInList = 0;
if (p->patternInList > m_patternList.count() - 1) // if patternInList is HIGHER than the list-count is, then jump back to position 0 to start again
p->patternInList = 0; // set to list-start
else
{
if (p->stepInPattern > m_patternList.at(p->patternInList).steps)
if (p->stepInPattern >
m_patternList.at(p->patternInList)
.steps) // if we have less steps than the stepInPattern says, then we have obsolved all wnted steps, so we can jump to the new pattern in the List
{
p->stepInPattern = 1;
if (p->patternInList == m_patternList.count() - 1)
p->stepInPattern = 1; // reset steps for the new pattern
if (p->patternInList == m_patternList.count() - 1) // if there is NOT a next pattern, then reset pattern counter to 0
p->patternInList = 0;
else
p->patternInList++;
p->patternInList++; // jump to next pattern IF there is a next pattern
}
}
p->posUTM.setX(p->posUTM.x() +
m_patternList.at(p->patternInList).northering);
p->posUTM.setY(p->posUTM.y() +
m_patternList.at(p->patternInList).ethering);
p->posUTM.setX(p->posUTM.x() + m_patternList.at(p->patternInList).northering); // increase northering as the pattern says
p->posUTM.setY(p->posUTM.y() + m_patternList.at(p->patternInList).ethering); // ^^^^^^^^ ethering ^^^^^^^^^^^^^^^^^^^
p->stepInPattern++;
p->stepInPattern++; // increase the step counter before we leave, so the player can be moved the next time!!
}
void TTWorker::onSendPlayerPositions()
{
// return;
qint64 bytesSent = 0;
int playerCount = 0;
TrainingAreaBase::TetraIcd::PositionReport tele;
@@ -604,23 +611,28 @@ void TTWorker::onSendPlayerPositions()
{
Player *p = m_playerList.at(i);
if (!p->isLogin)
if (!p->isLogin) // do not send position data if one player is not logged in
{
INFO_LOG(m_logger) << "Player with eqId=" << p->eqId << " and issi=" << p->issi << " is not logged in.";
break;
}
playerCount++;
if (p->vbg != TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady && p->isEndOfTicks())
sendTaktischerStatus(p->eqId, p->issi, TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady);
// respawn :
if (p->vbg != TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady &&
p->isEndOfTicks()) // only count to zero (isEndOfTicks = are the ticks running out ?) for respawn, if Player is NOT alive!
sendTaktischerStatus(
p->eqId,
p->issi,
TrainingAreaBase::TetraIcd::VulnerabilityState::
CombatReady); // only give rebirth, do not kill //(unsigned short)!p->isAlive); // kill Player if he is alive, give rebirth to Player if he is dead
tele.header.equipmentNumber = p->eqId;
if (m_toogle)
sendSanitationReport(p->eqId, p->issi);
movePlayer(p);
// else
// sendSanitation(p->eqId, p->issi);
movePlayer(p); // move players
tele.relPosition.offsetY = p->posUTM.y();
tele.relPosition.offsetX = p->posUTM.x();
@@ -1,5 +1,10 @@
/*
* @RDE_HEADER@
* Worker for Tetra Simulation
* $Id$
* $HeadURL$
* $Author$
*/
#pragma once
@@ -22,54 +27,51 @@ class QTimer;
class Player
{
private:
NGL::INGLLogger &m_logger;
void randomizeDeathTicks()
{
deathTicks = ((qrand() % (maximumDeathTicks - minimumDeathTicks + 1)) + minimumDeathTicks);
}
NGL::INGLLogger &m_logger;
void randomizeDeathTicks() { deathTicks = ((qrand() % (maximumDeathTicks - minimumDeathTicks + 1)) + minimumDeathTicks); }
public:
// PU simulation vars:
uint32_t eqId;
uint32_t issi;
QPointF posUTM;
QPointF posUTM;
// PU login-state vars:
bool isLogin;
bool isValidBITE;
TrainingAreaBase::TetraIcd::VulnerabilityState vbg;
int patternInList;
int stepInPattern;
// pattern vars:
int patternInList; // >-| which pattern to take from the pattern list
int stepInPattern; // <-| which step we have in the current pattern (see "patternInList" above)
// x seconds, for a Player to respawn [maximum / mininum]
uint32_t deathTicks;
uint32_t minimumDeathTicks;
uint32_t maximumDeathTicks;
Player(int eqId_, int issi_, uint32_t minimumDeathTicks_, uint32_t maximumDeathTicks_, const QPointF &posUTM_)
: eqId(eqId_)
, issi(issi_)
, posUTM(posUTM_)
, isLogin(false)
, isValidBITE(false)
, vbg(TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady)
, patternInList(0)
, stepInPattern(1)
, deathTicks(0)
, minimumDeathTicks(minimumDeathTicks_)
, maximumDeathTicks(maximumDeathTicks_)
: eqId(eqId_)
, issi(issi_)
, posUTM(posUTM_)
, isLogin(false)
, isValidBITE(false)
, vbg(TrainingAreaBase::TetraIcd::VulnerabilityState::CombatReady)
, patternInList(0)
, stepInPattern(1)
, deathTicks(0)
, minimumDeathTicks(minimumDeathTicks_)
, maximumDeathTicks(maximumDeathTicks_)
{
randomizeDeathTicks();
}
bool isEndOfTicks()
bool isEndOfTicks() // gives TRUE if deathTicks is lower than 1 and randomizes deathTicks again, so this function can be reused everytime
{
deathTicks--;
if (deathTicks < 1)
{
randomizeDeathTicks();
randomizeDeathTicks(); // randomize again
return true;
}
return false;
@@ -87,8 +89,8 @@ public:
private Q_SLOTS:
void onReadyRead();
void onSendPlayerPositions();
void onSendPlayerPositions(); // -> nur senden, wenn isLogin & isValidBite für tln ok
// wenn LoginOk von PrtCnv -> onSendBite(eqId)
void onSocketError();
void onSendNachforderungBroadcastTelegramm();
void onSendDeaktivierungEinzelminen();
@@ -102,8 +104,7 @@ protected:
void handleDataIndReq(const QByteArray &data);
void sendTelegram(N_CoPrtCnv::CoPrtCnvRadioTelegram *radioTelegram, uint32_t issi);
template <typename T>
void sendTelegram(const T &tele, uint32_t issi)
template <typename T> void sendTelegram(const T &tele, uint32_t issi)
{
N_CoPrtCnv::CoPrtCnvCentralTelegram ct(tele);
sendTelegram(N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToRadio(&ct), issi);
@@ -112,7 +113,7 @@ protected:
void sendBITE(uint32_t eqId, uint32_t issi);
void sendTaktischerStatus(uint32_t eqId, uint32_t issi, TrainingAreaBase::TetraIcd::VulnerabilityState vbg);
void sendSanitationReport(uint32_t eqId, uint32_t issi);
//void sendSanitation(uint32_t eqId, uint32_t issi);
private:
QTcpSocket *m_socket;
QTimer *m_timer;
@@ -1,5 +1,10 @@
/**
* @RDE_HEADER@
* Building Config - logging facility
* $Id$
* $HeadURL$
* $Author$
*/
#include "logger.h"
@@ -8,23 +13,24 @@
namespace PrtCnv
{
LOGGER_T getLogger(const char *name)
{
static const char ns[] = "PRT.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
try {
return NGL::NGLLoggerBootstrap::getNGLRootLogger().
getNGLLogger( loggerName );
} catch ( const std::exception &ex )
LOGGER_T getLogger(const char *name)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
}
static const char ns[] = "PRT.";
std::string loggerName;
const size_t len = strlen(name);
loggerName.reserve(sizeof(ns) + len);
loggerName.append(ns, sizeof(ns) - 1);
loggerName.append(name, len);
}
try
{
return NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger(loggerName);
}
catch (const std::exception &ex)
{
fprintf(stderr, "Error retrieving logger: %s", ex.what());
abort();
}
}
} // namespace PrtCnv
@@ -1,5 +1,10 @@
/**
* @RDE_HEADER@
* Logging for AereaEffectSimulation
* $Id$
* $HeadURL$
* $Author$
*/
#pragma once
@@ -8,11 +13,11 @@
namespace PrtCnv
{
typedef NGL::INGLLogger& LOGGER_T;
typedef NGL::INGLLogger &LOGGER_T;
LOGGER_T getLogger(const char *name);
inline LOGGER_T getLogger(const QString &loggerName)
{
return getLogger(loggerName.toUtf8().constData());
}
}
LOGGER_T getLogger(const char *name);
inline LOGGER_T getLogger(const QString &loggerName)
{
return getLogger(loggerName.toUtf8().constData());
}
} // namespace PrtCnv