Initial commit

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/CMakeLists.txt

@@ -0,0 +1,35 @@
+#
+# Commmunication with HlaProxy
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+SET(SRCS
+  logger.cpp
+  logger.h
+  main_dispatcher.cpp
+  main_dispatcher.h
+  main_handler_tx.cpp
+  main_handler_tx.h
+  plugin.cpp
+  plugin.h
+
+  hla_dispatcher.cpp
+  hla_dispatcher.h
+  hla_handler_rx.cpp
+  hla_handler_rx.h
+  hla_handler_tx.cpp
+  hla_handler_tx.h
+)
+NGL_ADD_LIBRARY(AAR SV tabPluginHla MODULE ${SRCS})
+NGL_INSTALL_TARGET(tabPluginHla)
+NGL_TARGET_LINK_LIBRARIES(tabPluginHla
+  NGLLogger
+  nglsettings
+  Qt5::Core
+  Qt5::Network
+  Qt5::WebSockets
+  tabPluginInterface
+  tabTelegrams
+)

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_dispatcher.cpp

@@ -0,0 +1,114 @@
+/**
+  * Send / Receive telegrams to/from Hla
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "hla_dispatcher.h"
+#include "hla_handler_rx.h"
+#include "hla_handler_tx.h"
+
+#include <QSettings>
+#include <QWebSocket>
+#include <QTimer>
+#include <nglsettings/nglsettings_settings.h>
+
+namespace HlaJson
+{
+HlaDispatcher::HlaDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
+                             const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                             NGL::Settings *settings)
+  : m_recvFromTabCb(recvFromTabCb)
+  , m_recvFromHla(std::make_shared<HlaHandlerRx>(recvFromTabCb, this))
+  , m_sendToHla(std::make_shared<HlaHandlerTx>(pdp))
+  , m_settings(settings)
+  , m_webSocket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this))
+  , m_webSocketReconnectTimer(new QTimer(this))
+  , m_bWarnedOnce(false)
+  , m_logger(getLogger("HlaDispatcher"))
+{
+  connect(m_webSocket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
+          this, &HlaDispatcher::onWebSocketError);
+  connect(m_webSocket, &QWebSocket::connected,
+          this, &HlaDispatcher::onHlaConnected);
+  connect(m_webSocket, &QWebSocket::disconnected,
+          this, &HlaDispatcher::onHlaDisconnected);
+  connect(m_webSocket, &QWebSocket::textMessageReceived,
+          this, &HlaDispatcher::onTextMessageReceived);
+  connect(m_webSocketReconnectTimer, &QTimer::timeout,
+          this, &HlaDispatcher::init);
+  connect(m_recvFromHla.get(), &HlaHandlerRx::participantConnectionState,
+          m_sendToHla.get(), &HlaHandlerTx::onParticipantConnectionState);
+}
+
+bool HlaDispatcher::init()
+{
+  // TODO
+  const QUrl url(webSocketUrl());
+  if (!m_bWarnedOnce)
+    NOTICE_LOG(m_logger) << "Using WebSocket url: " << url.toString();
+  m_webSocket->open(url);
+  return true;
+}
+
+std::shared_ptr<TrainingAreaBase::SendToTab> HlaDispatcher::sendToTab()
+{
+  return std::static_pointer_cast<TrainingAreaBase::SendToTab>(m_sendToHla);
+}
+
+bool HlaDispatcher::canSendData() const
+{
+  return m_webSocket && m_webSocket->state() == QAbstractSocket::ConnectedState;
+}
+
+void HlaDispatcher::onHlaConnected()
+{
+  QWebSocket *ws = qobject_cast<QWebSocket *>(sender());
+  m_sendToHla->onHlaConnected(ws);
+  m_webSocketReconnectTimer->stop();
+  m_bWarnedOnce = false;
+}
+
+void HlaDispatcher::onHlaDisconnected()
+{
+  INFO_LOG(m_logger) << "Hla socket disconnected";
+  m_webSocketReconnectTimer->start(5000);
+  m_sendToHla->onHlaDisconnected();
+
+  emit connectionState(QString::fromUtf8(name()), false);
+}
+
+void HlaDispatcher::onHlaExternalConnectionStateChanged(bool bConnected)
+{
+  m_sendToHla->onHlaConnectedToExternalSystem(bConnected);
+  emit connectionState(QString::fromUtf8(name()), bConnected);
+}
+
+void HlaDispatcher::onWebSocketError()
+{
+  if (!m_webSocket)
+    return;
+  if (!m_bWarnedOnce)
+    WARNING_LOG(m_logger) << "Error connecting to " << webSocketUrl().toString() << ": " << m_webSocket->errorString();
+  m_webSocket->close();
+  m_webSocketReconnectTimer->start(5000);
+  m_bWarnedOnce = true;
+
+  emit connectionState(QString::fromUtf8(name()), false);
+}
+
+void HlaDispatcher::onTextMessageReceived(const QString &message)
+{
+  // convert from json to internal representation, send to TAB
+  m_recvFromHla->handleTelegram(message.toUtf8());
+}
+
+QUrl HlaDispatcher::webSocketUrl() const
+{
+  const quint16 port = m_settings->settings()->value(QStringLiteral("hla/webSocketListenPort"), 12347).toInt();
+  const QString addr = m_settings->settings()->value(QStringLiteral("hla/webSocketHostname"), QStringLiteral("localhost")).toString();
+  return QUrl(QStringLiteral("ws://%1:%2/").arg(addr).arg(port));
+}
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_dispatcher.h

@@ -0,0 +1,62 @@
+/**
+  * Send / Receive telegrams to/from Hla
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include <QObject>
+#include <QWebSocket>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <DDS/Core/function_reply_object.h> // tr_lts
+#include "logger.h"
+
+class QTimer;
+namespace HlaJson
+{
+class HlaHandlerRx;
+class HlaHandlerTx;
+
+class HlaDispatcher final : public TrainingAreaBase::Plugin::Interface
+{
+  Q_OBJECT
+public:
+  HlaDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
+                const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                NGL::Settings *settings);
+
+public Q_SLOTS:
+  bool init() override;
+public:
+  std::shared_ptr<TrainingAreaBase::SendToTab> sendToTab() override;
+  bool isDebugInterface() const override { return false; }
+  bool canSendData() const override;
+  void exerciseChanged() override { return; }
+  const char *name() const override { return tr_lts("dds", "WLS"); }
+public Q_SLOTS:
+  void onHlaConnected();
+  void onHlaDisconnected();
+  void onHlaExternalConnectionStateChanged(bool bConnected);
+  void onWebSocketError();
+  void onTextMessageReceived(const QString &message);
+Q_SIGNALS:
+  void broadcastTelegramsRequest(int equipmentNumber, int broadcastIndex, int resetCounter);
+  void wlsTelegramReceived(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele);
+private:
+  QUrl webSocketUrl() const;
+private:
+  std::shared_ptr<TrainingAreaBase::RecvFromTab> m_recvFromTabCb;
+  std::shared_ptr<HlaHandlerRx> m_recvFromHla;
+  std::shared_ptr<HlaHandlerTx> m_sendToHla;
+  NGL::Settings *m_settings;
+  QWebSocket *m_webSocket;
+  QTimer *m_webSocketReconnectTimer;
+  bool m_bWarnedOnce;
+  NGL::INGLLogger &m_logger;
+
+};
+
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_handler_rx.cpp

@@ -0,0 +1,156 @@
+/**
+  * Convert Json from WLS to internal telegrams
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "hla_handler_rx.h"
+#include "hla_dispatcher.h"
+
+#include <TrainingAreaBase/training_area_telegrams.h>
+#include <QJsonDocument>
+
+namespace HlaJson
+{
+
+HlaHandlerRx::HlaHandlerRx(const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                           HlaDispatcher *dispatcher)
+  : m_rxHandler(recvFromTabCb)
+  , m_dispatcher(dispatcher)
+  , m_bWarnedOnce(false)
+  , m_logger(getLogger("HlaHandlerRx"))
+{}
+
+bool HlaHandlerRx::handleTelegram(const QByteArray &baJson)
+{
+  using namespace TrainingAreaBase::TetraIcd;
+
+  if (baJson.isEmpty())
+    return false;
+  const QJsonObject obj = QJsonDocument::fromJson(baJson).object();
+  TRACE_LOG(m_logger) << "incoming telegram: " << baJson;
+
+//  const QJsonValue sendCounter = obj.value(QStringLiteral("counter"));
+//  if (!sendCounter.isUndefined())
+//  {
+//    if (!sendCounter.isDouble())
+//      return false;
+//    recvCounter = sendCounter.toInt(-1);
+//    DEBUG_LOG(m_logger) << "Incoming telegram with Id " << obj.value(QStringLiteral("type")).toString();
+//    if (recvCounter < 0)
+//      return false;
+//  }
+  const QJsonValue typeId = obj.value(QStringLiteral("typeId"));
+  if (!typeId.isDouble())
+  {
+    ERROR_LOG(m_logger) << "Can not read type id: " << baJson;
+    return false;
+  }
+  const QJsonObject data = obj.value(QStringLiteral("data")).toObject();
+  try
+  {
+    switch (typeId.toInt())
+    {
+    case Constraints<PositionReport>::id(): // 21
+      rxData(PositionReport::fromJson(data));
+      break;
+    case Constraints<ProxyConnectionState>::id(): // 2013
+      m_dispatcher->onHlaExternalConnectionStateChanged(ProxyConnectionState::fromJson(data).connectedToSystem);
+      break;
+    case Constraints<ManipulationReport>::id(): // 2
+      rxData(ManipulationReport::fromJson(data));
+      break;
+    case Constraints<EquipmentOperationalState>::id():  // 7
+      rxData(EquipmentOperationalState::fromJson(data));
+      break;
+    case Constraints<EquipmentConfigurationReport>::id(): // 11
+      rxData(EquipmentConfigurationReport::fromJson(data));
+      break;
+    case Constraints<CtaDataError>::id(): // 12
+      rxData(CtaDataError::fromJson(data));
+      break;
+    case Constraints<MineTriggered>::id(): // 41
+      rxData(MineTriggered::fromJson(data));
+      break;
+    case Constraints<DefinitionIed>::id(): // 43
+      rxData(DefinitionIed::fromJson(data));
+      break;
+    case Constraints<StateIed>::id(): // 44
+      rxData(StateIed::fromJson(data));
+      break;
+    case Constraints<DusSingleMineState>::id(): // 45
+      rxData(DusSingleMineState::fromJson(data));
+      break;
+    case Constraints<StateChangeDirect>::id(): // 52
+      rxData(StateChangeDirect::fromJson(data));
+      break;
+    case Constraints<StateChangeIndirect>::id(): // 53
+      rxData(StateChangeIndirect::fromJson(data));
+      break;
+    case Constraints<OperatorAction>::id(): // 55
+      rxData(OperatorAction::fromJson(data));
+      break;
+    case Constraints<StateChange>::id(): // 61
+      rxData(StateChange::fromJson(data));
+      break;
+    case Constraints<EquipmentEvent>::id(): // 185
+      rxData(EquipmentEvent::fromJson(data));
+      break;
+    case Constraints<EquipmentGearAssignment>::id(): // 200
+      rxData(EquipmentGearAssignment::fromJson(data));
+      break;
+    case Constraints<EquipmentGearChargeState>::id(): // 202
+      rxData(EquipmentGearChargeState::fromJson(data));
+      break;
+    case Constraints<BiteReport>::id(): // 205
+      rxData(BiteReport::fromJson(data));
+      break;
+    case Constraints<EquipmentGearEvent>::id(): // 210
+      rxData(EquipmentGearEvent::fromJson(data));
+      break;
+    case Constraints<ParticipantSwVersions>::id(): // 213
+      rxData(ParticipantSwVersions::fromJson(data));
+      break;
+    case Constraints<ParticipantModeReport>::id(): // 231
+      rxData(ParticipantModeReport::fromJson(data));
+      break;
+    case Constraints<ParticipantConfigurationReport>::id(): // 233
+      rxData(ParticipantConfigurationReport::fromJson(data));
+      break;
+    case Constraints<WlsParticipantsConnectionState>::id(): // 3004
+    {
+      const auto tele = WlsParticipantsConnectionState::fromJson(data);
+      emit participantConnectionState(tele.equipmentNumber, tele.dataCommunicationPossible);
+      break;
+    }
+    default:
+      return false;
+    }
+  }
+  catch (const std::exception &e)
+  {
+    WARNING_LOG(m_logger) << "Could not parse json: " << e.what() << " (" << baJson << ")";
+    return false;
+  }
+  return true;
+}
+
+template<typename T>
+void HlaHandlerRx::rxData(const T &data)
+{
+  if (!m_rxHandler)
+  {
+    if (!m_bWarnedOnce)
+    {
+      ERROR_LOG(m_logger) << "No RecvFromTab available";
+      m_bWarnedOnce = true;
+    }
+    return;
+  }
+  emit m_dispatcher->wlsTelegramReceived(&data);
+  return m_rxHandler->rxData(data);
+}
+
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_handler_rx.h

@@ -0,0 +1,40 @@
+/**
+  * Convert Json from WLS to internal telegrams
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include <TrainingAreaBase/recv_from_tab.h>
+#include <QObject>
+#include <QString>
+#include <memory>
+#include "logger.h"
+
+namespace HlaJson
+{
+class HlaDispatcher;
+class HlaHandlerRx : public QObject
+{
+  Q_OBJECT
+public:
+  explicit HlaHandlerRx(const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                        HlaDispatcher *dispatcher);
+
+  bool handleTelegram(const QByteArray &baJson);
+  bool handleTelegram(TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tabTele);
+Q_SIGNALS:
+  void participantConnectionState(int equipmentNumber, bool dataCommunicationPossible);
+private:
+  template<typename T>
+  void rxData(const T &data);
+private:
+  std::shared_ptr<TrainingAreaBase::RecvFromTab> m_rxHandler;
+  HlaDispatcher *m_dispatcher;
+  bool m_bWarnedOnce;
+  LOGGER_T m_logger;
+};
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_handler_tx.cpp

@@ -0,0 +1,329 @@
+/**
+  * Convert telegrams to Json and sent to WLS proxy
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "hla_handler_tx.h"
+#include <QJsonDocument>
+#include <QWebSocket>
+
+namespace HlaJson
+{
+
+HlaHandlerTx::HlaHandlerTx(TrainingAreaBase::Plugin::DataProvider *pdp)
+  : m_pdp(pdp)
+  , m_webSocket(nullptr)
+  , m_bHlaConnectedToExternalSystem(false)
+  , m_logger(getLogger("HlaHandlerTx"))
+{}
+
+void HlaHandlerTx::onHlaConnected(QWebSocket *webSocket)
+{
+  m_webSocket = webSocket;
+  if (!m_webSocket)
+    return;
+  NOTICE_LOG(m_logger) << "Connected to HLA - sending exercise state data";
+  const auto tele = m_pdp->exerciseStateData();
+  sendToTx(&tele, true);
+}
+
+void HlaHandlerTx::onHlaDisconnected()
+{
+  m_webSocket = nullptr;
+}
+
+void HlaHandlerTx::onHlaConnectedToExternalSystem(bool bConnected)
+{
+  m_bHlaConnectedToExternalSystem = bConnected;
+}
+
+TrainingAreaBase::SendToTab::HandleState HlaHandlerTx::canHandleTelegram(int equipmentNumber, int telegramId) const
+{
+  if (!m_webSocket || !m_bHlaConnectedToExternalSystem)
+    return HandleState::No;
+
+  using namespace TrainingAreaBase::TetraIcd;
+  if (telegramId == Constraints<ExerciseEquipmentAssignmentComplete>::id() ||
+      telegramId == Constraints<ExerciseStateData>::id())
+    return HandleState::YesShare;
+
+  if (equipmentNumber <= 0 || !m_dataCommunicationPossible.value(equipmentNumber, false))
+    return HandleState::No;
+
+  if (telegramId == Constraints<Init>::id() ||
+      telegramId == Constraints<CesHitInformation>::id() ||
+      telegramId == Constraints<DemandBite>::id() ||
+      telegramId == Constraints<SelectiveReammunition>::id() ||
+      telegramId == Constraints<DemandVulnerabilityStateChange>::id()
+      )
+    return HandleState::YesConsume;
+
+  // currently no data to wls, TODO
+  return HandleState::No;
+}
+
+void HlaHandlerTx::resetSendCounter()
+{
+  // nothing to do
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Acknowledge &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandBite &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Init &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::SetVulnerabilityModel &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandEquipmentConfigurationReport &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandVulnerabilityStateChange &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::LanguageSelection &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::EquipmentMessage &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::EquipmentMessageOC &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateSingleExplosion &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateAreaExplosion &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateMineArea &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::MineAreaSingleMineState &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateNContamination &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateCContamination &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DeactivateEffectSimulation &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ModifyAreaEffectSimulationName &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::PauseEffectSimulation &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ResumeEffectSimulation &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::MineTriggered &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DusMineReactivation &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateFunctionalArea &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CreateDusSingleMine &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseEnvironmentData &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseStateData &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataOut &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantSwVersionsRequest &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::TechnicalArea &data)
+{
+  Q_UNUSED(data);
+  return false; // only for Tetra - really?
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::SetDevicePowerRequest &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::UAVPerformMission &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::UAVChangeState &data)
+{
+  Q_UNUSED(data);
+  return false;
+}
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CesHitInformation &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::CesHitRequest &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantMode &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandParticipantMode &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ParticipantConfiguration &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::DemandParticipantConfiguration &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::Sanitation &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::SelectiveReammunition &data)
+{
+  return sendToTx(&data);
+}
+
+bool HlaHandlerTx::txData(const TrainingAreaBase::TetraIcd::OcCommand &data)
+{
+  return sendToTx(&data);
+}
+
+void HlaHandlerTx::onParticipantConnectionState(int equipmentNumber, bool dataCommunicationPossible)
+{
+  INFO_LOG(m_logger) << "onParticipantConnectionState - " << equipmentNumber
+                     << ", communication possible: " << dataCommunicationPossible;
+  if (equipmentNumber == -1)
+    m_dataCommunicationPossible.clear();
+  m_dataCommunicationPossible[equipmentNumber] = dataCommunicationPossible;
+}
+
+bool HlaHandlerTx::sendToTx(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, bool bForce)
+{
+  if (!m_webSocket || (!m_bHlaConnectedToExternalSystem && !bForce))
+    return false;
+  QJsonObject obj;
+  obj[QStringLiteral("data")] = data->toJson();
+  obj[QStringLiteral("type")] = data->type();
+  obj[QStringLiteral("typeId")] = data->id();
+  //  if (data->id() != TrainingAreaBase::TetraIcd::TelegramId::BESTAETIGUNG)
+  //    obj[QStringLiteral("counter")] = m_sendCounter++;
+  const QByteArray ba = QJsonDocument(obj).toJson(QJsonDocument::Compact);
+  if (data->id() != TrainingAreaBase::TetraIcd::TelegramId::BESTAETIGUNG)
+    DEBUG_LOG(m_logger) << "Sending tele: " << ba;
+  m_webSocket->sendTextMessage(QString::fromUtf8(ba));
+  return true;
+}
+
+
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/hla_handler_tx.h

@@ -0,0 +1,89 @@
+/**
+  * Convert telegrams to Json and sent to WLS proxy
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include "logger.h"
+#include <TrainingAreaBase/send_to_tab.h>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <QHash>
+
+class QWebSocket;
+namespace HlaJson
+{
+class HlaHandlerTx final : public QObject, public TrainingAreaBase::SendToTab
+{
+  Q_OBJECT
+public:
+  explicit HlaHandlerTx(TrainingAreaBase::Plugin::DataProvider *pdp);
+
+  void onHlaConnected(QWebSocket *webSocket);
+  void onHlaDisconnected();
+  void onHlaConnectedToExternalSystem(bool bConnected);
+
+  const char *name() const override { return "Hla"; }
+  HandleState canHandleTelegram(int equipmentNumber, int telegramId) const override;
+  void resetSendCounter() override;
+  bool txData(const TrainingAreaBase::TetraIcd::Acknowledge &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandBite &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::Init &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SetVulnerabilityModel &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandEquipmentConfigurationReport &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandVulnerabilityStateChange &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::LanguageSelection &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::EquipmentMessage &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::EquipmentMessageOC &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateSingleExplosion &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateAreaExplosion &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateMineArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::MineAreaSingleMineState &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateNContamination &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateCContamination &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DeactivateEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ModifyAreaEffectSimulationName &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::PauseEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ResumeEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::MineTriggered &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DusMineReactivation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateFunctionalArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateDusSingleMine &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseEnvironmentData &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseStateData &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataOut &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantSwVersionsRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::TechnicalArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CesHitInformation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CesHitRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantMode &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandParticipantMode &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantConfiguration &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandParticipantConfiguration &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::Sanitation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SelectiveReammunition &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SetDevicePowerRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::OcCommand &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::UAVPerformMission &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::UAVChangeState &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExFireReadiness &) override {return false;};  
+  bool txData(const TrainingAreaBase::TetraIcd::ExFiredReport&) override {return false;};  
+  bool txData(const TrainingAreaBase::TetraIcd::ExConfirmationReport &) override {return false;};
+  
+
+public Q_SLOTS:
+  void onParticipantConnectionState(int equipmentNumber, bool dataCommunicationPossible);
+private:
+  bool sendToTx(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, bool bForce = false);
+private:
+  QHash<int, bool> m_dataCommunicationPossible; // equioNo, reachable
+  TrainingAreaBase::Plugin::DataProvider *m_pdp;
+  QWebSocket *m_webSocket;
+  bool m_bHlaConnectedToExternalSystem;
+  LOGGER_T m_logger;
+};
+}

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/logger.cpp

@@ -0,0 +1,38 @@
+/**
+  * @RDE_HEADER@
+  * Building Config - logging facility
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-04-14
+  */
+
+#include "logger.h"
+
+#include <NGLLogger/NGLLoggerBootstrap.h>
+
+namespace HlaJson
+{
+
+LOGGER_T getLogger(const char *name)
+{
+  static const char ns[] = "TAB.HLA.";
+  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 HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/logger.h

@@ -0,0 +1,23 @@
+/**
+  * @RDE_HEADER@
+  * Logging for TrainingAreaBase
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-04-14
+  */
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+
+namespace HlaJson
+{
+using LOGGER_T = NGL::INGLLogger&;
+
+LOGGER_T getLogger(const char *name);
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/main_dispatcher.cpp

@@ -0,0 +1,52 @@
+/**
+  * Send / Receive telegrams to/from Hla
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "main_dispatcher.h"
+#include "main_handler_tx.h"
+#include "hla_dispatcher.h"
+#include "hla_handler_tx.h"
+
+namespace HlaJson
+{
+MainDispatcher::MainDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
+                               const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                               NGL::Settings *settings)
+  : m_wlsDispatcher(new HlaDispatcher(pdp, recvFromTabCb, settings))
+  , m_recvFromTabCb(recvFromTabCb)
+  , m_mainHandlerTx(std::make_shared<MainHandlerTx>(std::dynamic_pointer_cast<HlaHandlerTx>(m_wlsDispatcher->sendToTab())))
+  , m_logger(getLogger("MainDispatcher"))
+{}
+
+MainDispatcher::~MainDispatcher()
+{
+  m_mainHandlerTx = nullptr;
+  m_recvFromTabCb = nullptr;
+  delete m_wlsDispatcher;
+}
+
+bool MainDispatcher::init()
+{
+  return m_wlsDispatcher->init();
+}
+
+std::shared_ptr<TrainingAreaBase::SendToTab> MainDispatcher::sendToTab()
+{
+  return m_mainHandlerTx;
+}
+
+bool MainDispatcher::canSendData() const
+{
+  return m_wlsDispatcher->canSendData();
+}
+
+void MainDispatcher::exerciseChanged()
+{
+  m_wlsDispatcher->exerciseChanged();
+}
+
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/main_dispatcher.h

@@ -0,0 +1,46 @@
+/**
+  * Send / Receive telegrams to/from Hla
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include <QObject>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <DDS/Core/function_reply_object.h> // tr_lts
+#include "logger.h"
+
+namespace HlaJson
+{
+class HlaDispatcher;
+class MainDispatcher final : public TrainingAreaBase::Plugin::Interface
+{
+  Q_OBJECT
+public:
+  MainDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
+                 const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                 NGL::Settings *settings);
+  ~MainDispatcher();
+
+public Q_SLOTS:
+  bool init() override;
+
+public:
+  std::shared_ptr<TrainingAreaBase::SendToTab> sendToTab() override;
+  bool isDebugInterface() const override { return false; }
+  bool canSendData() const override;
+  void exerciseChanged() override;
+  const char *name() const override { return tr_lts("dds", "HlaJson"); }
+
+private:
+  HlaDispatcher *m_wlsDispatcher;
+
+  std::shared_ptr<TrainingAreaBase::RecvFromTab> m_recvFromTabCb;
+  std::shared_ptr<TrainingAreaBase::SendToTab> m_mainHandlerTx;
+  NGL::INGLLogger &m_logger;
+
+};
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/main_handler_tx.cpp

@@ -0,0 +1,241 @@
+/**
+  * Convert telegrams to Json and sent to WLS proxy
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "main_handler_tx.h"
+#include "hla_handler_tx.h"
+
+using namespace TrainingAreaBase;
+
+namespace HlaJson
+{
+MainHandlerTx::MainHandlerTx(const std::shared_ptr<HlaHandlerTx> &wlsTx)
+  : m_wlsHandlerTx(wlsTx)
+  , m_logger(getLogger("MainHandlerTx"))
+{}
+
+SendToTab::HandleState MainHandlerTx::canHandleTelegram(int equipmentNumber, int telegramId) const
+{
+  return m_wlsHandlerTx->canHandleTelegram(equipmentNumber, telegramId);
+}
+
+void MainHandlerTx::resetSendCounter()
+{
+  m_wlsHandlerTx->resetSendCounter();
+}
+
+bool MainHandlerTx::txData(const TetraIcd::Acknowledge &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DemandBite &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::Init &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::SetVulnerabilityModel &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DemandEquipmentConfigurationReport &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DemandVulnerabilityStateChange &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::LanguageSelection &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::EquipmentMessage &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::EquipmentMessageOC &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateSingleExplosion &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateAreaExplosion &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateMineArea &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::MineAreaSingleMineState &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateNContamination &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateCContamination &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DeactivateEffectSimulation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ModifyAreaEffectSimulationName &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::PauseEffectSimulation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ResumeEffectSimulation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::MineTriggered &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DusMineReactivation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateFunctionalArea &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CreateDusSingleMine &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ExerciseEnvironmentData &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ExerciseStateData &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::OpaquePayloadDataOut &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ParticipantSwVersionsRequest &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::TechnicalArea &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CesHitInformation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::CesHitRequest &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ParticipantMode &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DemandParticipantMode &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ParticipantConfiguration &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::DemandParticipantConfiguration &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::ExerciseEquipmentAssignmentComplete &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::Sanitation &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::SelectiveReammunition &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::SetDevicePowerRequest &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::OcCommand &data)
+{
+  return sendToTxMixin(&data);
+}
+
+bool MainHandlerTx::txData(const TetraIcd::UAVPerformMission &data)
+{
+  return sendToTxMixin(&data);
+}
+bool MainHandlerTx::txData(const TetraIcd::UAVChangeState &data)
+{
+  return sendToTxMixin(&data);
+}
+
+template <typename T>
+bool MainHandlerTx::sendToTxMixin(const T *data)
+{
+  return m_wlsHandlerTx->txData(*data);
+}
+
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/main_handler_tx.h

@@ -0,0 +1,82 @@
+/**
+  * Convert telegrams to Json and sent to WLS proxy
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include <QObject>
+#include "logger.h"
+#include <TrainingAreaBase/send_to_tab.h>
+#include <memory>
+
+class QWebSocket;
+namespace HlaJson
+{
+class HlaHandlerTx;
+
+class MainHandlerTx final : public QObject, public TrainingAreaBase::SendToTab
+{
+  Q_OBJECT
+public:
+  explicit MainHandlerTx(const std::shared_ptr<HlaHandlerTx> &wlsTx);
+
+  const char *name() const override { return "HlaJson"; }
+  HandleState canHandleTelegram(int equipmentNumber, int telegramId) const override;
+  void resetSendCounter() override;
+  bool txData(const TrainingAreaBase::TetraIcd::Acknowledge &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandBite &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::Init &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SetVulnerabilityModel &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandEquipmentConfigurationReport &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandVulnerabilityStateChange &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::LanguageSelection &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::EquipmentMessage &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::EquipmentMessageOC &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateSingleExplosion &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateAreaExplosion &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateMineArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::MineAreaSingleMineState &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateNContamination &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateCContamination &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DeactivateEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ModifyAreaEffectSimulationName &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::PauseEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ResumeEffectSimulation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::MineTriggered &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DusMineReactivation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateFunctionalArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CreateDusSingleMine &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseEnvironmentData &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseStateData &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataOut &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantSwVersionsRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::TechnicalArea &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CesHitInformation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::CesHitRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantMode &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandParticipantMode &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ParticipantConfiguration &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::DemandParticipantConfiguration &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::Sanitation &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SelectiveReammunition &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::SetDevicePowerRequest &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::OcCommand &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::UAVPerformMission &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::UAVChangeState &data) override;
+  bool txData(const TrainingAreaBase::TetraIcd::ExFireReadiness &) override { return false; };  
+  bool txData(const TrainingAreaBase::TetraIcd::ExFiredReport &) override { return false; };
+  bool txData(const TrainingAreaBase::TetraIcd::ExConfirmationReport &) override { return false; };
+private:
+
+  template <typename T>
+  bool sendToTxMixin(const T *data);
+private:
+  std::shared_ptr<HlaHandlerTx> m_wlsHandlerTx;
+  LOGGER_T m_logger;
+};
+}

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/plugin.cpp

@@ -0,0 +1,28 @@
+/**
+  * Send / Receive telegrams to/from TX/RX directory
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#include "plugin.h"
+#include "main_dispatcher.h"
+#include <nglsettings/nglsettings_settings.h>
+
+namespace HlaJson
+{
+
+//
+// TetraXdrPlugin
+//
+std::shared_ptr<TrainingAreaBase::Plugin::Interface> TabHlaPlugin::createInterface(TrainingAreaBase::Plugin::DataProvider *pdp,
+                                                                                   const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                                                                                   const std::shared_ptr<TrainingAreaBase::TxMixin> &,
+                                                                                   const std::shared_ptr<TrainingAreaBase::DdsHandler> &,
+                                                                                   NGL::Settings *settings)
+{
+  Q_UNUSED(pdp)
+  return std::make_shared<MainDispatcher>(pdp, recvFromTabCb, settings);
+}
+} // namespace HlaJson

Lts/Proxies/TrainingAreaBase/Plugins/HlaJson/plugin.h

@@ -0,0 +1,31 @@
+/**
+  * Send / Receive telegrams to/from TX/RX directory
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-09-26
+  */
+
+#pragma once
+
+#include <QObject>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+
+namespace HlaJson
+{
+class TabHlaPlugin : public QObject, public TrainingAreaBase::Plugin::Plugin
+{
+  Q_OBJECT
+  Q_PLUGIN_METADATA(IID "special:3:tab.hla")
+  Q_INTERFACES(TrainingAreaBase::Plugin::Plugin)
+public:
+  TabHlaPlugin() = default;
+  ~TabHlaPlugin() = default;
+  std::shared_ptr<TrainingAreaBase::Plugin::Interface> createInterface(TrainingAreaBase::Plugin::DataProvider *pdp,
+                                                                       const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                                                                       const std::shared_ptr<TrainingAreaBase::TxMixin> &sendToTabCb,
+                                                                       const std::shared_ptr<TrainingAreaBase::DdsHandler> &ddsHandler,
+                                                                       NGL::Settings *settings) override;
+};
+
+} // namespace HlaJson