Initial commit

Lts/Services/NmeaManagement/CMakeLists.txt

@@ -0,0 +1,153 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+INCLUDE(MacroRTIDDSGen)
+INCLUDE(MacroCodeGenIdl)
+
+SET(xml_FILE nme_service.xml)
+
+#
+# --- Library svcNmeCommon --------------------------------------------------------------------------------
+#
+SET(SRCS_common
+  nme_export.h
+  logger.cpp
+  logger.h
+)
+
+# Generate nme_enums.idl / nme.idl
+CODEGEN_IDL_SVC(SRCS_common ${xml_FILE})
+
+# Generate *.cpp/*.hpp from idl
+RTIDDSGEN(SRCS_common nme_enums.idl)
+RTIDDSGEN(SRCS_common nme.idl)
+
+# Generate nme_dt[s,c]_types.h, nme_ft[s,c]_types.h
+CODEGEN_TOPIC_TYPEDEFS(SRCS_common ${xml_FILE})
+# Generate nme_[d|f]tc.h
+CODEGEN_CLIENT_TOPICS_IFC(SRCS_common ${xml_FILE})
+
+NGL_ADD_LIBRARY(AAR SV WS svcNmeCommon SHARED  ${SRCS_common})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcNmeCommon
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(svcNmeCommon
+  PRIVATE
+    RTI::nddscpp2
+  PUBLIC
+    Qt5::Core
+    ddscore
+    NGLLogger
+)
+NGL_INSTALL_TARGET(svcNmeCommon)
+
+#
+# --- Library svcNmeClient --------------------------------------------------------------------------------
+#
+SET(SRCS_client
+  nme_export.h
+)
+# generate nme_[d|f]tc.h, nme_[d|f]tc_impl.[cpp|h]
+CODEGEN_CLIENT_TOPICS_IMPL(SRCS_client ${xml_FILE})
+
+NGL_ADD_LIBRARY(AAR SV WS svcNmeClient SHARED ${SRCS_client})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcNmeClient
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+
+NGL_TARGET_LINK_LIBRARIES(svcNmeClient
+  PRIVATE
+    RTI::nddscpp2
+    ddsconnector
+  PUBLIC
+    svcNmeCommon
+    ddsftc
+)
+NGL_INSTALL_TARGET(svcNmeClient)
+
+#
+# --- Library svcNmeServer --------------------------------------------------------------------------------
+#
+SET(SRCS_server
+  nme_export.h
+)
+# generate nme_[d|f]ts.h, nme_[d|f]ts_impl.[cpp|h]
+CODEGEN_SERVER_TOPICS(SRCS_server ${xml_FILE})
+# Generate nme_db_impl.cpp/.h, nme_db.h
+CODEGEN_DATABASE(SRCS_server ${xml_FILE})
+
+NGL_ADD_LIBRARY(AAR SV svcNmeServer SHARED ${SRCS_server})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcNmeServer
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+
+NGL_TARGET_LINK_LIBRARIES(svcNmeServer
+  PRIVATE
+    RTI::nddscpp2
+    ddsconnector
+    ddsfts
+    ngldb
+  PUBLIC
+    svcNmeCommon
+)
+NGL_INSTALL_TARGET(svcNmeServer)
+
+#
+# --- Topic Type Plugin --------------------------------------------------------------
+#
+CREATE_TOPIC_TYPE_PLUGIN(${xml_FILE})
+
+#
+# --- Executable svcNmeaManagement (sNME) -------------------------------------------------
+#
+SET(SRCS_exe
+  main.cpp
+  main_handler.cpp
+  main_handler.h
+  dds_handler.cpp
+  dds_handler.h
+  settings.cpp
+  settings.h
+  nmea_handler.cpp
+  nmea_handler.h
+  socket_handler.cpp
+  socket_handler.h
+  ${xml_FILE}
+)
+
+# Generate nme.sql, nme.xml
+CODEGEN_SQL(SRCS_exe ${xml_FILE})
+
+NGL_ADD_SVC_ICON(SRCS_exe)
+NGL_ADD_EXECUTABLE(AAR SV svcNmeaManagement ${SRCS_exe})
+NGL_TARGET_LINK_LIBRARIES(svcNmeaManagement
+  Qt5::Core
+  Qt5::Network
+  svcNmeCommon
+  svcNmeServer
+  ddsconnector
+  nglsettings
+  ProjectConfig
+  LtsCommandLineParser
+  NGLLogger
+  nglcoreapplication
+  svcCoreClient
+  ngltools
+)
+NGL_INSTALL_TARGET(svcNmeaManagement)
+NGL_INSTALL( SV FILES log4cxx_nme.props DESTINATION bin)
+NGL_ADD_TARGET_LINK(svcNmeaManagement sNME)
+
+# Uncomment if necessary
+#ADD_SUBDIRECTORY(UnitTests)
+#ADD_SUBDIRECTORY(ModuleTests)
+

Lts/Services/NmeaManagement/dds_handler.cpp

@@ -0,0 +1,87 @@
+/**
+  * DdsHandler for DDS
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include "dds_handler.h"
+
+#include "nme_dts.h"
+#include "nme_fts.h"
+
+#include <DDS/DTS/generic_dts_impl.h>
+#include <DDS/Core/pacemaker.h>
+
+namespace NmeaManagement
+{
+
+DdsHandler::DdsHandler(int domainId)
+  : m_ddsConnector(std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Any))
+  , m_logger(getLogger("DdsHandler"))
+{
+  DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
+}
+
+DdsHandler::~DdsHandler()
+{}
+
+bool DdsHandler::init(const QStringList &qosFileList)
+{
+  if (!m_ddsConnector->init(qosFileList))
+  {
+    ERROR_LOG(m_logger) << "Error initializing dds connections - aborting";
+    return false;
+  }
+
+  // default initialize Publisher and Subscriber
+  m_ddsConnector->initPublisherSubscriber();
+  m_ddsConnector->enableBatchedWriter(false);
+
+  // Pacemaker
+  m_pacemaker = std::make_shared<Core::Pacemaker>(m_ddsConnector);
+
+  m_ddsDts = NmeaManagement::Interface::Dts::create(m_ddsConnector);
+  m_ddsFts = NmeaManagement::Interface::Fts::create(m_ddsConnector);
+
+  if (!m_ddsDts->enableBatteryAlarm())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize NmeaManagement enableBatteryAlarm data topic server";
+    return false;
+  }
+
+  if (!m_ddsDts->enableServiceControl())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize NmeaManagement enableServiceControl data topic server";
+    return false;
+  }
+
+  if (!m_ddsDts->enableBatteryState())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize NmeaManagement enableBatteryState data topic server";
+    return false;
+  }
+
+  if (!m_ddsDts->enablePositionExcon())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize NmeaManagement enablePositionExcon data topic server";
+    return false;
+  }
+  INFO_LOG(m_logger) << "Dts initialised";
+
+
+  if (!m_ddsFts->enableAll())
+  {
+    ERROR_LOG(m_logger) << "Could not initialize NmeaManagement enableAll function topic";
+    return false;
+  }
+  INFO_LOG(m_logger) << "Fts initialised";
+
+  // TODO: call at the end of main_handler init:
+  this->pacemaker()->setNewState(Core::RunningState::Running);
+
+  return true;
+}
+
+} // Namespace PDM

Lts/Services/NmeaManagement/dds_handler.h

@@ -0,0 +1,56 @@
+/**
+  * DdsHandler for DDS
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#pragma once
+
+#include <QObject>
+#include <DDS/DDSConnector/dds_connector.h>
+#include <DDS/Core/core_dts_types.h>
+#include <DDS/Core/core_dtc.h>
+#include <DDS/Core/pacemaker.h>
+
+#include <NmeaManagement/nme_dts.h>
+#include <NmeaManagement/nme_fts.h>
+#include "logger.h"
+
+namespace Core
+{
+class Pacemaker;
+}
+
+namespace NmeaManagement
+{
+class DdsHandler final : public QObject
+{
+  Q_OBJECT
+public:
+  DdsHandler(int domainId);
+  ~DdsHandler();
+
+  bool init(const QStringList &qosFileList = QStringList());
+
+  std::shared_ptr<Core::Pacemaker> pacemaker() const
+  {
+    return m_pacemaker;
+  }
+
+
+  std::shared_ptr<NmeaManagement::Interface::Dts> dts() const { return m_ddsDts;}
+  std::shared_ptr<NmeaManagement::Interface::Fts> fts() const { return m_ddsFts;}
+
+private:
+  std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnector;
+  std::shared_ptr<DTS::CurrentRunningState>   m_dtsCurrentRunningState;
+  std::shared_ptr<Core::Pacemaker>            m_pacemaker;
+  std::shared_ptr<NmeaManagement::Interface::Dts>  m_ddsDts;
+  std::shared_ptr<NmeaManagement::Interface::Fts>  m_ddsFts;
+
+  NGL::INGLLogger          &m_logger;
+};
+
+} // namespace NmeaManagement

Lts/Services/NmeaManagement/log4cxx_nme.props

@@ -0,0 +1,78 @@
+log4j.reset=true
+log4j.rootLogger=WARN, file
+
+# Service NMEA-Manager
+###########################################################
+
+#log4j.logger.NME=WARN
+#log4j.logger.NME.main=WARN
+
+# File
+###########################################################
+log4j.appender.file=Lts::RollingFileAppender
+log4j.appender.file.MaxFileSize=1MB
+log4j.appender.file.MaxBackupIndex=9
+log4j.appender.file.layout=org.apache.log4j.PatternLayout
+log4j.appender.file.layout.ConversionPattern=%d %-5p %c |#| %m (%.50F:%L) %n
+
+
+# Appnd_Console
+###########################################################
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern= %d %p %c %c{1} - %m (%-.30F:%L) %n
+
+
+# Appnd_Syslog
+###########################################################
+log4j.appender.syslog=org.apache.log4j.SyslogAppender
+log4j.appender.syslog.Threshold=ERROR
+log4j.appender.syslog.SysLogHost=localhost
+log4j.appender.syslog.Facility=LOCAL7
+log4j.appender.syslog.layout=org.apache.log4j.PatternLayout
+log4j.appender.syslog.layout.ConversionPattern= %-4r %-5p %c %x - %m
+log4j.appender.syslog.LevelRangeFilter.AcceptOnMatch=true
+log4j.appender.syslog.LevelRangeFilter.LevelMin=INFO
+log4j.appender.syslog.LevelRangeFilter.LevelMax=FATAL
+
+
+###########################################################
+###########################################################
+###########################################################
+# 1) Available Levels in LOG4CXX Version 0.10.0:
+# TRACE,
+# DEBUG,
+# INFO,
+# WARN,
+# ERROR
+# FATAL
+#
+# d = date/time
+# p = priority (Level)
+# c = category/channel
+# m = message
+# F = file
+# L = line
+# n = platform dependent line separator character or characters.
+# ....
+#
+# Examples for console:
+# a)
+# %d %p %c #%m# (%.50F:%L)%n
+# date/time
+#    priority
+#       category/channel
+#          #message#
+#                (Maximal 50Character des Filename von rechts:Line)
+#                       line separator
+#
+# b)
+# %d (%.15F:%L) %-5p %c |#| %m%n
+# date/time
+#    (Maximal 15Character des Filename von rechts:Line)
+#               priority, Right pad with spaces if the priority name is less than 5 characters long.
+#                    category/channel
+#                           message
+#                             line separator
+#
+# Examples for files:

Lts/Services/NmeaManagement/logger.cpp

@@ -0,0 +1,38 @@
+/**
+  * @RDE_HEADER@
+  * Building Config - logging facility
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include "logger.h"
+
+#include <NGLLogger/NGLLoggerBootstrap.h>
+
+namespace NmeaManagement
+{
+
+LOGGER_T getLogger(const char *name)
+{
+  static const char ns[] = "NME.";
+  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 NmeaManagement

Lts/Services/NmeaManagement/logger.h

@@ -0,0 +1,24 @@
+/**
+  * @RDE_HEADER@
+  * Logging for NmeaManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+#include "nme_export.h"
+
+namespace NmeaManagement
+{
+using LOGGER_T = NGL::INGLLogger &;
+
+NME_COMMON_EXPORT LOGGER_T getLogger(const char *name);
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} // namespace NmeaManagement

Lts/Services/NmeaManagement/main.cpp

@@ -0,0 +1,43 @@
+/**
+  * @RDE_HEADER@
+  * main for NmeaManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include <nglapplication/nglcoreapplication.h>
+#include <LtsCommandLineParser/LtsCommandLineParser.h>
+
+#include "main_handler.h"
+#include "logger.h"
+#include "settings.h"
+
+int main(int argc, char **argv)
+{
+  NGLCoreApplication app(argc, argv);
+
+  LtsCommandLineParser::LtsCommandLineParser options;
+  if (!options.init())
+    return -1;
+  app.createLogger("NME", options.exerciseId());
+
+  NmeaManagement::Settings::setIniFile(options.iniFile());
+
+  int iRet = -3;
+  {
+    std::unique_ptr<NmeaManagement::MainHandler> mainHandler(new NmeaManagement::MainHandler);
+
+    if (!mainHandler->init(options.domainId()))
+      return iRet;
+
+    STARTUP_LOG(app.baseLogger());
+
+    iRet = app.exec();
+
+    SHUTDOWN_LOG(app.baseLogger());
+  }
+
+  return iRet;
+}

Lts/Services/NmeaManagement/main_handler.cpp

@@ -0,0 +1,52 @@
+/**
+  * MainHandler for AssetManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include "main_handler.h"
+#include "settings.h"
+
+#include <DDS/DDSConnector/dds_connector.h>
+
+namespace NmeaManagement
+{
+
+MainHandler::MainHandler(QObject *parent)
+  : QObject(parent)
+  , m_logger(getLogger("MainHandler"))
+{}
+
+MainHandler::~MainHandler()
+{
+  m_ddsHandler.reset();
+  m_socketHandler.reset();
+  m_nmeaHandler.reset();
+}
+
+bool MainHandler::init(int domainId)
+{
+  NOTICE_LOG(m_logger) << "MainHandler::init";
+  // initialize DDS
+  m_ddsHandler = std::make_shared<DdsHandler>(domainId);
+  if (!m_ddsHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Initialisation ddsHandler failed.";
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "Initialisation ddsHandler succesful.";
+
+  m_nmeaHandler = std::make_shared<NmeaHandler>(m_ddsHandler, this);
+  m_nmeaHandler->init();
+
+  m_socketHandler = std::make_shared<SocketHandler>(m_ddsHandler, m_nmeaHandler, this);
+  m_socketHandler->init(Settings::getNmeaHost(), Settings::getNmeaPort());
+
+  return true;
+}
+
+
+
+}   // namespace NmeaManagement

Lts/Services/NmeaManagement/main_handler.h

@@ -0,0 +1,38 @@
+/**
+  * MainHandler for AereaEffectSimulation
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+#pragma once
+
+#include <QObject>
+#include <memory>
+#include "dds_handler.h"
+#include "socket_handler.h"
+#include "nmea_handler.h"
+#include "logger.h"
+
+namespace NmeaManagement
+{
+
+class MainHandler : public QObject
+{
+  Q_OBJECT
+public:
+  explicit MainHandler(QObject *parent = nullptr);
+  ~MainHandler();
+
+  bool init(int domainId);
+
+  std::shared_ptr<DdsHandler> dds() const { return m_ddsHandler; }
+
+private:
+  std::shared_ptr<DdsHandler>            m_ddsHandler;
+  std::shared_ptr<SocketHandler>         m_socketHandler;
+  std::shared_ptr<NmeaHandler>           m_nmeaHandler;
+  NGL::INGLLogger                       &m_logger;
+
+};
+} // namespace NmeaManagement

Lts/Services/NmeaManagement/nme_export.h

@@ -0,0 +1,52 @@
+/**
+  * Export definitions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+#ifndef NME_COMMON_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define NME_COMMON_EXPORT
+# else
+#  if defined(MAKE_SVCNMECOMMON_LIB)
+#   define NME_COMMON_EXPORT Q_DECL_EXPORT
+#   ifndef WIN32
+#     ifdef NDDSUSERDllExport
+#      undef NDDSUSERDllExport
+#     endif
+#     define NDDSUSERDllExport Q_DECL_EXPORT
+#   endif
+#  else
+#   define NME_COMMON_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif
+
+#ifndef NME_CLIENT_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define NME_CLIENT_EXPORT
+# else
+#  if defined(MAKE_SVCNMECLIENT_LIB)
+#   define NME_CLIENT_EXPORT Q_DECL_EXPORT
+#  else
+#   define NME_CLIENT_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif
+
+#ifndef NME_SERVER_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define NME_SERVER_EXPORT
+# else
+#  if defined(MAKE_SVCNMESERVER_LIB)
+#   define NME_SERVER_EXPORT Q_DECL_EXPORT
+#  else
+#   define NME_SERVER_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif

Lts/Services/NmeaManagement/nme_service.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<service namespace="NmeaManagement" abbreviation="NME" procNames="NmeaManagement" exerciseDependency="Global" groups="Core" prio="">
+  <rcs>
+    <Id Id="$Id: ea_export_script.txt 41311 2018-04-23 09:43:45Z ehrlicher $"/>
+    <HeadURL HeadURL="$HeadURL: svn://slssvn/TDS/branches/product/devel/trunk/Lts/Common/CodeGen/ea_export_script.txt $"/>
+    <Author Author="$Author: ehrlicher $"/>
+  </rcs>
+  <tables/>
+  <views/>
+  <dbServiceStructs/>
+  <enumerations>
+    <enumeration name="ServiceControlEnum">
+      <attribute key="PRESHUTDOWN" value="0"/>
+      <attribute key="SHUTDOWN" value="1"/>
+      <attribute key="STOP" value="2"/>
+    </enumeration>
+  </enumerations>
+  <topicTypes>
+    <topicType name="BatteryAlarm" isDataObject="1" autosubscribe="1" routeToClient="1" routeToServer="0" routeInReplay="0">
+      <column name="id" idlType="long"/>
+      <column name="description" idlType="string"/>
+      <column name="acknowledge" idlType="boolean"/>
+      <column name="condition" idlType="boolean"/>
+      <column name="uniqueAlarmNumber" idlType="long"/>
+      <column name="time" idlType="long long"/>
+    </topicType>
+    <topicType name="BatteryState" isDataObject="1" autosubscribe="1" routeToClient="1" routeToServer="0" routeInReplay="0">
+      <column name="id" idlType="long" isKey="1" comment="value 1 and 2 "/>
+      <column name="battery" idlType="long" comment="0-5 = 0 = empty, 5 = full bennetec intern"/>
+      <column name="temperature" idlType="long" comment="Celsius"/>
+      <column name="frequency" idlType="long"/>
+      <column name="generic" idlType="double" comment="x.x = variable data"/>
+      <column name="current" idlType="long" comment="Current in ma"/>
+      <column name="switchOrValue" idlType="boolean" comment="1 = ON/ CLOSED, 0 = OFF/ OPEN"/>
+      <column name="voltage" idlType="long" comment="mV"/>
+      <column name="serialNumber" idlType="string"/>
+    </topicType>
+    <topicType name="PositionExcon" isDataObject="1" autosubscribe="1" routeToClient="1" routeToServer="0" routeInReplay="0">
+      <column name="position" idlType="Core::GeoPosition2D"/>
+      <column name="valid" idlType="boolean"/>
+    </topicType>
+    <topicType name="ServiceControl" isDataObject="1" autosubscribe="1" routeToClient="1" routeToServer="0" routeInReplay="0">
+      <column name="ServiceControlState" idlType="ServiceControlEnum"/>
+    </topicType>
+    <topicType name="TurnRadioMasterOffRequest">
+      <column name="shutdown" idlType="boolean"/>
+    </topicType>
+  </topicTypes>
+  <functionTopics>
+    <functionTopic name="TurnRadioMasterOff" requestTopicType="TurnRadioMasterOffRequest" replyTopicType="Core::FunctionReply" requestTopicName="TurnRadioMasterOffRequest" replyTopicName="TurnRadioMasterOffReply" routeInReplay="0"/>
+  </functionTopics>
+</service>

Lts/Services/NmeaManagement/nmea_handler.cpp

@@ -0,0 +1,407 @@
+/**
+  * NmeaHandler
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+#include <QTime>
+#include <QDateTime>
+#include "nmea_handler.h"
+namespace NmeaManagement
+{
+NmeaHandler::NmeaHandler(const std::shared_ptr<DdsHandler> &ddsHandler,
+                         QObject *parent)
+  : QObject(parent)
+  , m_ddsHandler(ddsHandler)
+  , m_logger(getLogger("NmeaHandler"))
+{
+
+}
+
+
+void NmeaHandler::init()
+{
+
+}
+
+
+bool NmeaHandler::checksum(QString package)
+{
+  short start = 0;
+
+  start = package.indexOf(QStringLiteral("*"));
+  if (start < 0)
+    packagesInvalid++;
+  QString to_chk = package.mid(1, start - 1);
+  package.remove(0, start + 1);
+  int cksm = 0;
+
+  for (int i = 0; i < to_chk.size(); i++)
+  {
+    QChar letra = to_chk.at(i);
+    cksm = cksm ^ letra.toLatin1();
+  }
+
+  if (cksm == package.toInt(nullptr, 16))
+    return true;
+  packagesInvalid++;
+  return false;
+}
+
+void NmeaHandler::IIXDR(QString package)
+{
+  int battery;
+  int temperature;
+  int frequency;
+  double generic;
+  int current;
+  bool switchOrValue;
+  int voltage;
+  QString serialNumber = QStringLiteral("");
+  QString timeStr;
+
+
+  NmeaManagement::BatteryState batteryState;
+  NmeaManagement::ServiceControl  serviceControl;
+  QRegExp sep(QStringLiteral("(\\,|\\*)"));
+  QStringList pkt_data = package.split(sep);
+  INFO_LOG(m_logger) << "----------------------------------------------------";
+  INFO_LOG(m_logger) << "batteryState pkt_data.size=" << pkt_data.size();
+  for (int i = 0; i < pkt_data.size(); i++)
+    INFO_LOG(m_logger) << "i=" << i << "Value=" << pkt_data[i];
+
+
+  int index = pkt_data.indexOf(QLatin1String("S")) + 1;
+  if ( index >= 1)
+  {
+    INFO_LOG(m_logger) << "Ausschalten!!!";
+    if (pkt_data[4] == QStringLiteral("SERVICE_CONTROL_PRESHUTDOWN"))
+    {
+        INFO_LOG(m_logger) << "SERVICE_CONTROL_PRESHUTDOWN";
+        serviceControl.ServiceControlState(ServiceControlEnum_def::PRESHUTDOWN);
+    }
+    if (pkt_data[4] == QStringLiteral("SERVICE_CONTROL_SHUTDOWN"))
+    {
+        INFO_LOG(m_logger) << "SERVICE_CONTROL_SHUTDOWN";
+        serviceControl.ServiceControlState(ServiceControlEnum_def::SHUTDOWN);
+    }
+    if (pkt_data[4] == QStringLiteral("SERVICE_CONTROL_STOP"))
+    {
+        INFO_LOG(m_logger) << "SERVICE_CONTROL_STOP";
+        serviceControl.ServiceControlState(ServiceControlEnum_def::STOP);
+    }
+    m_ddsHandler->dts()->publish(serviceControl);
+    return;
+  }
+
+  if ( pkt_data.size()>=4)
+    serialNumber =   (pkt_data[4]);
+
+  {
+    if ( !m_batteries.contains(serialNumber))
+    {
+      if (m_batteries.size() == 2)
+      {
+        m_batteries.clear();
+      }
+      m_batteries.append(serialNumber);
+    }
+
+    batteryState.id(m_batteries.indexOf(serialNumber));
+  }
+
+  index = pkt_data.indexOf(QLatin1String("B")) + 1;
+  if ( index >= 0)
+    battery = pkt_data[index].toInt() ;
+  else
+    battery = -1;
+  batteryState.battery(battery );
+
+  index = pkt_data.indexOf(QLatin1String("C")) + 1;
+  if ( index >= 0)
+    temperature = pkt_data[index].toInt() ;
+  else
+    temperature = -1;
+  batteryState.temperature(temperature);
+
+  index = pkt_data.indexOf(QLatin1String("F")) + 1;
+  if ( index >= 0)
+    frequency = pkt_data[index].toInt() ;
+  else
+    frequency = -1;
+  batteryState.frequency(frequency);
+
+  index = pkt_data.indexOf(QLatin1String("F")) + 1;
+  if ( index >= 0)
+    generic = pkt_data[index].toDouble() ;
+  else
+    generic = -1.0;
+  batteryState.generic(generic);
+
+  index = pkt_data.lastIndexOf(QLatin1String("I")) + 1;
+
+  if ( index >= 0)
+    current = pkt_data[index].toInt();
+  else
+    current = -1;
+  batteryState.current(current);
+  index = pkt_data.indexOf(QLatin1String("S")) + 1;
+  switchOrValue = false;
+  if ( index >= 0)
+    if (  pkt_data[index].toInt() == 1 )
+      switchOrValue = true;
+  batteryState.switchOrValue(switchOrValue);
+
+  index = pkt_data.indexOf(QLatin1String("U")) + 1;
+  if ( index >= 0)
+    voltage = pkt_data[index].toInt() ;
+  else
+    voltage = -1;
+  batteryState.voltage(voltage);
+
+  batteryState.serialNumber(serialNumber.toStdString()) ;
+  INFO_LOG(m_logger) << "publish batteryState serialNumber=" << serialNumber;
+  m_ddsHandler->dts()->publish(batteryState);
+}
+
+qint64 NmeaHandler::getDateTime(QString receivedTimeStr)
+{
+  int pos = receivedTimeStr.indexOf(QStringLiteral("."));
+  QString receivedTimeStr1 =  receivedTimeStr.left(pos);
+  QTime currentTime = QTime::currentTime();
+  qint64 currentDateTime = QDateTime::currentMSecsSinceEpoch();
+  QTime receivedTime;
+  int msecsSinceStartOfDay = currentTime.msecsSinceStartOfDay();
+  qint64 currentDate = currentDateTime - msecsSinceStartOfDay;
+
+  QString dateFormat = QStringLiteral("hhmmss");
+  receivedTime = QTime::fromString(receivedTimeStr1, dateFormat);
+  qint64 receivedTimeMs = receivedTime.msecsSinceStartOfDay();
+
+  return currentDate + receivedTimeMs;
+}
+
+void NmeaHandler::IIALR(QString package)
+{
+  NmeaManagement::BatteryAlarm batteryAlarm;
+  QRegExp sep(QStringLiteral("(\\,|\\*)"));
+  QStringList pkt_data = package.split(sep);
+  alarm_state packageData;
+  INFO_LOG(m_logger) << "pkt_data.size=" << pkt_data.size();
+  //    for ( int i = 0; i < pkt_data.size(); i++)
+  //    {
+  //        INFO_LOG(m_logger)<< "i=" << i << "Value=" << pkt_data[i];
+  //    }
+  packageData.time = pkt_data[1];
+  packageData.number = pkt_data[2].toInt();
+  if (pkt_data[3] == QStringLiteral("A"))
+    packageData.condition = true;
+  else
+    packageData.condition = false;
+  if (pkt_data[4] == QStringLiteral("A"))
+    packageData.acknowledgeState = true;
+  else
+    packageData.acknowledgeState = false;
+  packageData.description = pkt_data[5];
+
+  qint64 timeAlarm = getDateTime(packageData.time);
+
+  INFO_LOG(m_logger) << "time=" << packageData.time
+                     << " timeAlarm=" << timeAlarm
+                     << " number=" << packageData.number
+                     << " condition=" <<  packageData.condition
+                     << " acknowledgeState=" << packageData.acknowledgeState
+                     << " description=" << packageData.description;
+  batteryAlarm.id(0);
+  batteryAlarm.time(timeAlarm);
+  batteryAlarm.description(packageData.description.toStdString());
+  batteryAlarm.acknowledge(packageData.acknowledgeState);
+  batteryAlarm.condition(packageData.condition);
+  batteryAlarm.uniqueAlarmNumber(packageData.number);
+
+  m_ddsHandler->dts()->publish(batteryAlarm);
+}
+
+
+void NmeaHandler::GPGGA(QString package)
+{
+  NmeaManagement::PositionExcon  PositionExcon;
+  double latDecimal;
+  double lonDecimal;
+  QRegExp sep(QStringLiteral("(\\,|\\*)"));
+  QStringList pkt_data = package.split(sep);
+  gpgga_data packageData;
+
+
+  packageData.A_hour = pkt_data[1];
+  packageData.B_latitude = pkt_data[2];
+  packageData.C_latitude_dir = pkt_data[3].toStdString()[0];
+  packageData.D_longitude = pkt_data[4];
+  packageData.E_longitude_dir = pkt_data[5].toStdString()[0];
+  packageData.F_qualidade_fixa = pkt_data[6].toInt();
+  packageData.G_quantidade_satelites = pkt_data[7].toInt();
+  packageData.H_diluicao_da_precisao_horizontal = pkt_data[8].toFloat();
+  packageData.I_altitude = pkt_data[9].toFloat();
+  packageData.J_unidade_medida_altura = pkt_data[10].toStdString()[0];
+  packageData.K_altura_geoide_acima_elipsoide = pkt_data[11].toFloat();
+  packageData.L_unidade_medida_geoide = pkt_data[12].toStdString()[0];
+  packageData.M_idade_ultima_atualizacao_dgps = pkt_data[13].toFloat();
+  packageData.N_dgps_id = pkt_data[14].toInt();
+
+
+  QString hora;
+  hora = packageData.A_hour.mid(0, 6);
+  int inserts = 0;
+  for (int var = 1; var < hora.size() - inserts; ++var)
+  {
+    if (var % 2 == 0)
+    {
+      hora.insert(var + inserts, QStringLiteral(":"));
+      inserts++;
+    }
+  }
+
+
+  int inteiro;
+  double real;
+  QString val;
+  while (packageData.B_latitude[0] == QStringLiteral("0"))
+    packageData.B_latitude.remove(0, 1);
+  val = packageData.B_latitude.mid(0, 2);
+  packageData.B_latitude = packageData.B_latitude.remove(0, 2);
+  inteiro = val.toInt();
+  val = packageData.B_latitude;
+  real = val.toDouble();
+
+
+  if (packageData.C_latitude_dir == 'S' || packageData.C_latitude_dir == 's')
+    latDecimal = ((real / 60) + inteiro) * -1;
+  //INFO_LOG(m_logger) << QString::number(((real / 60) + inteiro) * -1, 'g', 9);
+  else
+    latDecimal = ((real / 60) + inteiro);
+  //INFO_LOG(m_logger) << "latitude=" << QString::number(((real / 60) + inteiro), 'g', 9);
+
+
+  while (packageData.D_longitude[0] == QStringLiteral("0"))
+    packageData.D_longitude.remove(0, 1);
+
+  val = packageData.D_longitude.mid(0, 2);
+  packageData.D_longitude = packageData.D_longitude.remove(0, 2);
+  inteiro = val.toInt();
+  val = packageData.D_longitude;
+  real = val.toDouble();
+
+  if (packageData.E_longitude_dir == 'W' || packageData.E_longitude_dir == 'w')
+  {
+    lonDecimal = ((real / 60) + inteiro) * -1;
+  }
+  else
+  {
+    lonDecimal = ((real / 60) + inteiro);
+  }
+
+  INFO_LOG(m_logger) << "longitude=" << lonDecimal
+                     << " latitude=" << latDecimal;
+
+
+  PositionExcon.position().lat(latDecimal * M_PI / 180.0);
+  PositionExcon.position().lon(lonDecimal * M_PI / 180.0);
+  PositionExcon.valid(true);
+  m_ddsHandler->dts()->publish(PositionExcon);
+}
+
+
+
+
+void NmeaHandler::GPRMC(QString package)
+{
+  QRegExp sep(QStringLiteral("(\\,|\\*)"));
+  QStringList pkt_data = package.split(sep);
+  gprmc_data packageData;
+
+  packageData.A_hour = (int)pkt_data[1].toFloat();
+  packageData.B_warning = pkt_data[2].toStdString()[0];
+  packageData.C_latitude = pkt_data[3].toFloat();
+  packageData.D_latitude_coord = pkt_data[4].toStdString()[0];
+  packageData.E_longitude = pkt_data[5].toFloat();
+  packageData.F_longitude_coord = pkt_data[6].toStdString()[0];
+  packageData.G_velocity = pkt_data[7].toFloat();
+  packageData.H_CMG = pkt_data[8].toFloat();
+  packageData.I_data = pkt_data[9].toInt();
+  packageData.J_variacao_magnetica = pkt_data[10].toFloat();
+  packageData.K_variacao_magnetica_coord = pkt_data[11].toStdString()[0];
+
+
+  INFO_LOG(m_logger) << "velocidade=" << QString::number(packageData.G_velocity * 1.852);
+
+}
+
+
+
+void NmeaHandler::decode(QString nmeaPackage)
+{
+  QString nmeaType;
+  int startingPoint;
+
+
+  startingPoint = 0;
+  if (nmeaPackage == QStringLiteral(""))
+    return;
+  while (nmeaPackage.at(startingPoint) != QStringLiteral("$"))
+  {
+    startingPoint++;
+    if (startingPoint >= nmeaPackage.size())
+      return;
+  }
+
+  nmeaPackage.remove(0, startingPoint);
+
+  nmeaType = nmeaPackage.mid(1, 5);
+  INFO_LOG(m_logger) << "nmeaType=" << nmeaType;
+
+  if (nmeaType == QStringLiteral("IIXDR"))
+  {
+      NOTICE_LOG(m_logger) << "IIXDR  Battery-State";
+   }
+
+  if (nmeaType == QStringLiteral("GPGGA"))
+  {
+    INFO_LOG(m_logger) << "Eigenposition";
+    if (checksum(nmeaPackage))
+    {
+      INFO_LOG(m_logger) << "Eigenposition checksum ok";
+      GPGGA(nmeaPackage);
+    }
+  }
+  else if (nmeaType == QStringLiteral("GPRMC"))
+  {
+    if (checksum(nmeaPackage))
+      GPRMC(nmeaPackage);
+
+  }
+  else if (nmeaType == QStringLiteral("IIXDR"))
+  {
+    NOTICE_LOG(m_logger) << "IIXDR";
+    if (checksum(nmeaPackage))
+    {
+      NOTICE_LOG(m_logger) << "IIXDR checksum OK";
+      IIXDR(nmeaPackage);
+    }
+    else
+      NOTICE_LOG(m_logger) << "IIXDR checksum NOT OK";
+
+  }
+  else if (nmeaType == QStringLiteral("IIALR"))
+  {
+    if (checksum(nmeaPackage))
+      IIALR(nmeaPackage);
+  }
+  else
+    packagesInvalid++;
+}
+}   // namespace NmeaManagement
+
+
+
+

Lts/Services/NmeaManagement/nmea_handler.h

@@ -0,0 +1,130 @@
+/**
+  * NmeaHandler 
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#ifndef NMEADECODER_H
+#define NMEADECODER_H
+
+#include <cmath>
+#include <QQueue>
+#include <QObject>
+#include "dds_handler.h"
+#include "logger.h"
+
+namespace NmeaManagement
+{
+class NmeaHandler final
+    : public QObject
+
+{
+public:
+  NmeaHandler(const std::shared_ptr<DdsHandler> &ddsHandler, QObject *parent);
+  void init();
+  void decode(QString package);
+private:
+
+  struct gpgga_data  //Global Positioning System Fix Data
+  {
+    QString A_hour;
+    QString B_latitude;
+    char C_latitude_dir;
+    QString D_longitude;
+    char E_longitude_dir;
+    int F_qualidade_fixa = -1;
+    int G_quantidade_satelites = -1;
+    float H_diluicao_da_precisao_horizontal = -1;
+    float I_altitude = -1;
+    char J_unidade_medida_altura;
+    float K_altura_geoide_acima_elipsoide = -1;
+    char L_unidade_medida_geoide;
+    float M_idade_ultima_atualizacao_dgps = -1;
+    int N_dgps_id = -1;
+  };
+
+  struct battery_state
+  {
+    QString serialNumber;
+    int battery;        //  0-5 = 0 = empty, 5 = full bennetec intern
+    int temperature;    // Celsius
+    int frequency;      // Hertz
+    float generic;      // x.x = variable data
+    long current;       // mA
+    bool G_velocity; // 1 = ON/ CLOSED, 0 = OFF/ OPEN
+    long voltage;       // [mV]
+  };
+
+  struct alarm_state
+  {
+    QString time;
+    int number;
+    bool condition;
+    bool acknowledgeState;
+    QString description;
+  };
+
+
+  struct gpgsa_data  //GPS DOP and active satellites
+  {
+    char A_modo = -1;
+    char B_modo_dimensional = -1;
+    int  *CN_ids_satelites;
+    float O_PDOP = -1;
+    float P_HDOP = -1;
+    float Q_VDOP = -1;
+  };
+
+  struct satelite
+  {
+    int A_sv_prn = -1;
+    int B_elevacao_graus = -1; //90 max
+    int C_azimuth = -1;
+    int D_snr = -1;
+  };
+
+  struct gpgsv_data  //GPS Satellites in view
+  {
+    unsigned A_total_mensagens = -1;
+    unsigned B_numero_desta_mensagem = -1;
+    int C_satelites_visiveis = -1;
+    satelite DS_sats[4];
+  };
+
+  struct gprmc_data  //Recommended minimum specific GPS/Transit data
+  {
+    int A_hour = -1;
+    char B_warning = -1;
+    float C_latitude = -1;
+    char D_latitude_coord = -1;
+    float E_longitude = -1;
+    char F_longitude_coord = -1;
+    float G_velocity = -1;
+    float H_CMG = -1;
+    int I_data = -1;
+    float J_variacao_magnetica = -1;
+    char K_variacao_magnetica_coord = -1;
+
+
+  };
+
+  unsigned packagesInvalid = 0;
+
+
+  void GPGGA(QString package);
+  void GPRMC(QString package);
+  void IIXDR(QString package);
+  void IIALR(QString package);
+
+  bool checksum(QString package);
+  qint64 getDateTime(QString receivedTimeStr);
+
+private:
+  std::shared_ptr<DdsHandler>    m_ddsHandler;
+  QStringList                    m_batteries;
+  LOGGER_T                       m_logger;
+};
+}   // namespace NmeaManagement
+#endif // NMEADECODER_H

Lts/Services/NmeaManagement/settings.cpp

@@ -0,0 +1,53 @@
+/**
+  * Settings for NmeaManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include "settings.h"
+
+#include <QtCore/QSettings>
+#include <nglsettings/nglsettings_settings.h>
+#include <ngltools/ngltools_filesystem.h>
+
+namespace NmeaManagement
+{
+class NGLSettingsClass : public NGL::Settings
+{
+public:
+  NGLSettingsClass()
+    : NGL::Settings(s_iniFile.isEmpty() ? NGL::findProjectConfigFile() : s_iniFile)
+  {}
+  static void setIniFile(const QString &fn)
+  {
+    s_iniFile = fn;
+  }
+  static QString s_iniFile;
+};
+QString NGLSettingsClass::s_iniFile;
+Q_GLOBAL_STATIC(NGLSettingsClass, s)
+
+//-----------------------------------------------------------------------------
+NGL::Settings *Settings::settings()
+{
+  return s();
+}
+//-----------------------------------------------------------------------------
+void Settings::setIniFile(const QString &ini)
+{
+  NGLSettingsClass::setIniFile(ini);
+}
+
+QString Settings::getNmeaHost()
+{
+  return s()->settings()->value(QStringLiteral("NME/nmeaHost"), QStringLiteral("localhost")).toString();
+}
+
+int Settings::getNmeaPort()
+{
+  return s()->settings()->value(QStringLiteral("NME/nmeaPort"), 10110).toInt();
+}
+
+} // namespace NmeaManagement

Lts/Services/NmeaManagement/settings.h

@@ -0,0 +1,28 @@
+/**
+  * Settings for NmeaManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#pragma once
+#include <QString>
+
+namespace NGL
+{
+class Settings;
+}
+
+namespace NmeaManagement
+{
+namespace Settings
+{
+NGL::Settings *settings();
+void setIniFile(const QString &ini);
+
+QString getNmeaHost();
+int     getNmeaPort();
+}
+
+} // namespace NmeaManagement

Lts/Services/NmeaManagement/socket_handler.cpp

@@ -0,0 +1,140 @@
+/**
+  * SocketHandler
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#include "socket_handler.h"
+#include <QTimer>
+#include <QLatin1String>
+#include "nmea_handler.h"
+#include  <QHostAddress>
+
+namespace NmeaManagement
+{
+
+
+SocketHandler::SocketHandler(const std::shared_ptr<DdsHandler> &ddsHandler,
+                             const std::shared_ptr<NmeaHandler> &nmeaHandler,
+                             QObject *parent) :
+  QObject(parent)
+  , TurnRadioMasterOffRequestHandler(ddsHandler->fts())
+  , m_ddsHandler(ddsHandler)
+  , m_nmeaHandler(nmeaHandler)
+  , m_logger(getLogger("SocketHandler"))
+{
+  // create a timer
+  m_reconnectTimer = new QTimer(this);
+
+  // setup signal and slot
+  connect(m_reconnectTimer, SIGNAL(timeout()),
+          this, SLOT(reconnectTimerSlot()));
+
+}
+
+void SocketHandler::init(QString nmeaHost, int nmeaPort)
+{
+  m_nmeaHost = nmeaHost;
+  m_nmeaPort = nmeaPort;
+  socket = new QUdpSocket(this);
+  connect(socket, SIGNAL(connected()), this, SLOT(connected()));
+  connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
+  connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));
+
+  connect(socket, SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWritten(qint64)));
+
+  INFO_LOG(m_logger) << "Connecting,..";
+  INFO_LOG(m_logger) << nmeaHost << " port: " << nmeaPort;
+  //socket->connectToHost(QHostAddress::LocalHost, nmeaPort);
+  //socket->connectToHost(nmeaHost, nmeaPort);
+  reconnect();
+
+}
+
+void SocketHandler::reconnect()
+{
+    INFO_LOG(m_logger) << "Connecting,.." << " host = " << m_nmeaHost
+                     <<  " port = " << m_nmeaPort;;
+
+  if(!socket->bind(m_nmeaPort, QAbstractSocket::BindFlag::ShareAddress))
+  {
+    ERROR_LOG(m_logger) << "Error from Socket: " << socket->errorString();
+    m_reconnectTimer->start(10000);
+  }
+
+}
+
+void SocketHandler::connected()
+{
+  m_reconnectTimer->stop();
+
+  INFO_LOG(m_logger) << "Connected!";
+}
+
+
+void SocketHandler::disconnected()
+{
+  INFO_LOG(m_logger) << "Disconnected!";
+}
+
+void SocketHandler::bytesWritten(qint64 bytes)
+{
+  TRACE_LOG(m_logger) << "We wrote: " << bytes;
+}
+
+void SocketHandler::reconnectTimerSlot()
+{
+  m_reconnectTimer->stop();
+  INFO_LOG(m_logger) << "Reconnect NMEA-Socket "
+                      << " host = " << m_nmeaHost
+                      <<  " port = " << m_nmeaPort;
+  reconnect();
+}
+
+
+void SocketHandler::readyRead()
+{
+  bool hasData = true;
+  INFO_LOG(m_logger) << "Reading...";
+ // QByteArray ba = socket->readDatagram();
+ 
+  QByteArray ba;
+
+  while (socket->hasPendingDatagrams()) 
+  {
+
+    ba.resize(int(socket->pendingDatagramSize()));
+    socket->readDatagram(ba.data(), ba.size());
+    INFO_LOG(m_logger) << ba;
+    QByteArray nmeaDataBa = ba; // ba.mid(startNmeaData, endNmeaData);
+    std::string nmeaDataStd = nmeaDataBa.toStdString() ;
+    QString nmeaData = QString::fromLocal8Bit(nmeaDataStd.c_str());
+
+
+    INFO_LOG(m_logger) << "nmeaDecoder :" << nmeaData;
+    //ba = ba.mid(endNmeaData, ba.length());
+    m_nmeaHandler->decode(nmeaData);
+
+    INFO_LOG(m_logger) << "NMEA-Data=" << nmeaData;
+    INFO_LOG(m_logger) << "NMEA-Data ba=" << ba;
+  }
+}
+
+void SocketHandler::onTurnRadioMasterOffRequest(const rti::core::SampleIdentity &cookie, const TurnRadioMasterOffRequest &request)
+{
+    //patric: Du hattest den Reply 端berschrieben nicht den Request ;)
+
+  Core::FunctionReplyObject reply;
+  if (reply.error())
+    WARNING_LOG(m_logger) << "onTurnRadioMasterOffReply: " << reply();
+
+  m_ddsHandler->fts()->turnRadioMasterOffReply(cookie, reply);
+
+  QByteArray queryTimeline ("$IIXDR,S,1,,SERVICE_CONTROL_PRESHUTDOWN*79");
+  qDebug() << queryTimeline;
+  socket->writeDatagram(queryTimeline, QHostAddress(m_nmeaHost), m_nmeaPort);
+
+}
+}

Lts/Services/NmeaManagement/socket_handler.h

@@ -0,0 +1,62 @@
+/**
+  * NmeaHandler
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Gerlinde Rudolphus, SLTE, 2022-06-09
+  */
+
+#pragma once
+
+#include <QObject>
+#include <QTcpSocket>
+#include <QTcpServer>
+#include <QUdpSocket>
+#include <QAbstractSocket>
+#include <QTimer>
+#include <NmeaManagement/nme_dts.h>
+#include <NmeaManagement/nme_fts.h>
+
+#include <QObject>
+#include "dds_handler.h"
+#include "nmea_handler.h"
+#include "logger.h"
+namespace NmeaManagement
+{
+
+class SocketHandler final
+    : public QObject
+    , protected NmeaManagement::Interface::Fts::TurnRadioMasterOffRequestHandler
+{
+  Q_OBJECT
+public:
+  explicit SocketHandler(const std::shared_ptr<DdsHandler> &ddsHandler,
+                         const std::shared_ptr<NmeaHandler> &nmeaHandler,
+                         QObject *parent = 0);
+  void init(QString nmeaHost, int nmeaPort);
+  void onTurnRadioMasterOffRequest(const rti::core::SampleIdentity &cookie, const TurnRadioMasterOffRequest &request);
+signals:
+
+public slots:
+
+  void connected();
+  void disconnected();
+  void bytesWritten(qint64 bytes);
+  void readyRead();
+
+  void reconnectTimerSlot();
+private:
+  std::shared_ptr<DdsHandler>                             m_ddsHandler;
+  std::shared_ptr<NmeaHandler>                            m_nmeaHandler;
+  void reconnect();
+
+  int         m_nmeaPort;
+  QString     m_nmeaHost;
+  QUdpSocket *socket;
+
+  QTimer      *m_reconnectTimer;
+  LOGGER_T     m_logger;
+
+};
+} // namespace NmeaManagement
+