261 lines
8.5 KiB
C++
Executable File
261 lines
8.5 KiB
C++
Executable File
/**
|
|
* Convert Json from WLS to internal telegrams
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Ehrlicher, SLSE, 2016-09-26
|
|
*/
|
|
|
|
#include "wls_handler_rx.h"
|
|
#include "wls_dispatcher.h"
|
|
|
|
#include <TrainingAreaBase/training_area_telegrams.h>
|
|
#include <QJsonDocument>
|
|
|
|
#include <CoPrtCnv/CoPrtCnvCentralTelegram.hpp>
|
|
#include <CoPrtCnv/CoPrtCnvRadioTelegram.hpp>
|
|
#include <CoPrtCnv/CoPrtCnvTelegramConverter.hpp>
|
|
|
|
namespace WlsTetra
|
|
{
|
|
|
|
WlsHandlerRx::WlsHandlerRx(const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
|
|
WlsDispatcher *dispatcher)
|
|
: m_rxHandler(recvFromTabCb)
|
|
, m_dispatcher(dispatcher)
|
|
, m_bWarnedOnce(false)
|
|
, m_logger(getLogger("WlsHandlerRx"))
|
|
{}
|
|
|
|
bool WlsHandlerRx::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->onWlsExternalConnectionStateChanged(ProxyConnectionState::fromJson(data).connectedToSystem);
|
|
break;
|
|
case Constraints<WlsBinarySfmData>::id(): // 3003
|
|
sfmData(WlsBinarySfmData::fromJson(data));
|
|
break;
|
|
case Constraints<WlsParticipantsConnectionState>::id(): // 3004
|
|
{
|
|
const auto tele = WlsParticipantsConnectionState::fromJson(data);
|
|
emit participantConnectionState(tele.equipmentNumber, tele.dataCommunicationPossible);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not parse json: " << e.what() << " (" << baJson << ")";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void WlsHandlerRx::participantLicenseChange(const TrainingAreaBase::TetraIcd::ParticipantLicenseChange &lc)
|
|
{
|
|
if (lc.equipmentNumber <= 0)
|
|
{
|
|
return;
|
|
}
|
|
switch (lc.licenseState)
|
|
{
|
|
case TrainingAreaBase::TetraIcd::ParticipantLicenseState::Licensed:
|
|
m_licensedEquipmentNumbers.insert(lc.equipmentNumber);
|
|
break;
|
|
case TrainingAreaBase::TetraIcd::ParticipantLicenseState::Rejected:
|
|
case TrainingAreaBase::TetraIcd::ParticipantLicenseState::Unlicense:
|
|
m_licensedEquipmentNumbers.remove(lc.equipmentNumber);
|
|
break;
|
|
case TrainingAreaBase::TetraIcd::ParticipantLicenseState::Unknown:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
template <>
|
|
void WlsHandlerRx::rxData(const TrainingAreaBase::TetraIcd::RequestBroadcastTelegrams &data)
|
|
{
|
|
emit m_dispatcher->broadcastTelegramsRequest(data.header.equipmentNumber,
|
|
data.broadcastIndex,
|
|
data.resetCounter);
|
|
}
|
|
|
|
template <typename T>
|
|
static inline T toSpecialized(TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tabTele)
|
|
{
|
|
return *(static_cast<T*>(tabTele));
|
|
}
|
|
|
|
bool WlsHandlerRx::handleTelegram(TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tabTele)
|
|
{
|
|
using namespace TrainingAreaBase::TetraIcd;
|
|
switch (tabTele->id())
|
|
{
|
|
// Telegrams converted from WlsBinarySfmData
|
|
case Constraints<ManipulationReport>::id(): // 2
|
|
rxData(toSpecialized<ManipulationReport>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentOperationalState>::id(): // 7
|
|
rxData(toSpecialized<EquipmentOperationalState>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentConfigurationReport>::id(): // 11
|
|
rxData(toSpecialized<EquipmentConfigurationReport>(tabTele));
|
|
break;
|
|
case Constraints<CtaDataError>::id(): // 12
|
|
rxData(toSpecialized<CtaDataError>(tabTele));
|
|
break;
|
|
case Constraints<MineTriggered>::id(): // 41
|
|
rxData(toSpecialized<MineTriggered>(tabTele));
|
|
break;
|
|
case Constraints<DefinitionIed>::id(): // 43
|
|
rxData(toSpecialized<DefinitionIed>(tabTele));
|
|
break;
|
|
case Constraints<StateIed>::id(): // 44
|
|
rxData(toSpecialized<StateIed>(tabTele));
|
|
break;
|
|
case Constraints<DusSingleMineState>::id(): // 45
|
|
rxData(toSpecialized<DusSingleMineState>(tabTele));
|
|
break;
|
|
case Constraints<StateChangeDirect>::id(): // 52
|
|
rxData(toSpecialized<StateChangeDirect>(tabTele));
|
|
break;
|
|
case Constraints<StateChangeIndirect>::id(): // 53
|
|
rxData(toSpecialized<StateChangeIndirect>(tabTele));
|
|
break;
|
|
case Constraints<OperatorAction>::id(): // 55
|
|
rxData(toSpecialized<OperatorAction>(tabTele));
|
|
break;
|
|
case Constraints<SelectiveReammunition>::id(): // 56
|
|
rxData(toSpecialized<SelectiveReammunition>(tabTele));
|
|
break;
|
|
case Constraints<StateChange>::id(): // 61
|
|
rxData(toSpecialized<StateChange>(tabTele));
|
|
break;
|
|
case Constraints<OpaquePayloadDataIn>::id(): // 71
|
|
rxData(toSpecialized<OpaquePayloadDataIn>(tabTele));
|
|
break;
|
|
case Constraints<RequestBroadcastTelegrams>::id(): // 82
|
|
rxData(toSpecialized<RequestBroadcastTelegrams>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentEvent>::id(): // 185
|
|
rxData(toSpecialized<EquipmentEvent>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentGearAssignment>::id(): // 200
|
|
rxData(toSpecialized<EquipmentGearAssignment>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentGearChargeState>::id(): // 202
|
|
rxData(toSpecialized<EquipmentGearChargeState>(tabTele));
|
|
break;
|
|
case Constraints<BiteReport>::id(): // 205
|
|
rxData(toSpecialized<BiteReport>(tabTele));
|
|
break;
|
|
case Constraints<EquipmentGearEvent>::id(): // 210
|
|
rxData(toSpecialized<EquipmentGearEvent>(tabTele));
|
|
break;
|
|
case Constraints<ParticipantSwVersions>::id(): // 213
|
|
rxData(toSpecialized<ParticipantSwVersions>(tabTele));
|
|
break;
|
|
case Constraints<ParticipantModeReport>::id(): // 231
|
|
rxData(toSpecialized<ParticipantModeReport>(tabTele));
|
|
break;
|
|
case Constraints<ParticipantConfigurationReport>::id(): // 233
|
|
rxData(toSpecialized<ParticipantConfigurationReport>(tabTele));
|
|
break;
|
|
default:
|
|
ERROR_LOG(m_logger) << "WlsHandlerRx::handleTelegram no Handler for " << tabTele->id();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
class RadioTelegram : public N_CoPrtCnv::CoPrtCnvRadioTelegram
|
|
{
|
|
public:
|
|
RadioTelegram(const QByteArray &data)
|
|
: N_CoPrtCnv::CoPrtCnvRadioTelegram(data)
|
|
{}
|
|
|
|
uint16_t getPayloadSize() const override
|
|
{
|
|
return m_data.size() - CoPrtCnvRadioTelegram::DATA_IND_REQ_HEADER_LENGTH;
|
|
}
|
|
};
|
|
|
|
void WlsHandlerRx::sfmData(const TrainingAreaBase::TetraIcd::WlsBinarySfmData &data)
|
|
{
|
|
if (data.payload.size() < 2)
|
|
{
|
|
ERROR_LOG(m_logger) << "Invalid binary data from WLS: " << QJsonDocument(data.toJson()).toJson(QJsonDocument::Compact);
|
|
return;
|
|
}
|
|
|
|
using namespace N_CoPrtCnv;
|
|
const int offset = CoPrtCnvRadioTelegram::DATA_IND_REQ_HEADER_LENGTH;
|
|
QByteArray ba(data.payload.size() + offset, Qt::Uninitialized);
|
|
memcpy(&ba.data()[offset], data.payload.data(), data.payload.size());
|
|
const RadioTelegram radio(ba);
|
|
TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tabTele = CoPrtCnvTelegramConverter::convertToTabTele(&radio);
|
|
if (!tabTele)
|
|
{
|
|
WARNING_LOG(m_logger) << "Can not convert binary sfm data to a valid tetra telegram - ignoring ("
|
|
<< data.header.equipmentNumber << "): " << QByteArray::fromRawData(reinterpret_cast<const char *>(data.payload.data()),
|
|
data.payload.size()).toHex();
|
|
return;
|
|
}
|
|
handleTelegram(tabTele);
|
|
delete tabTele;
|
|
}
|
|
|
|
template<typename T>
|
|
void WlsHandlerRx::rxData(const T &data)
|
|
{
|
|
if (!m_rxHandler)
|
|
{
|
|
if (!m_bWarnedOnce)
|
|
{
|
|
ERROR_LOG(m_logger) << "No RecvFromTab available";
|
|
m_bWarnedOnce = true;
|
|
}
|
|
return;
|
|
}
|
|
if (data.header.equipmentNumber != 0 &&
|
|
data.id() != TrainingAreaBase::TetraIcd::BITE_MELDUNG2 &&
|
|
!m_licensedEquipmentNumbers.contains(data.header.equipmentNumber))
|
|
return;
|
|
emit m_dispatcher->wlsTelegramReceived(&data);
|
|
return m_rxHandler->rxData(data);
|
|
}
|
|
|
|
} // namespace WlsTetra
|