Ah, ok, verstehe was du meinst. Aktuell mache ich ziemlich genau das
Die Klasse heißt bei mir DataObserver... Zur Identifizierung der Variablen innerhalb der C++ Umgebung benutze ich ein enum-Typ, da war mein Gedanke irgendwann Richtung QString zu wechseln, einfach wegen einem schönen Bezeichner.
Über TIpps zur Verbesserung des Codes freue ich mich, bin immer für eine gute Diskussion zu haben
dataids.h
Code: Alles auswählen
#ifndef DATAIDS_H
#define DATAIDS_H
typedef enum
{
eDATA_ID_VOLTAGE_SOURCE,
eDATA_ID_ENGINE_SPEED,
eDATA_ID_TRANS_OUT_SHAFT_SPEED,
eDATA_ID_OPTION_T4I_OR_T4F,
eDATA_ID_SCM_NODE_STATUS,
eDATA_ID_CRANE_OP_MODE,
eDATA_ID_CC_STATE,
eDATA_ID_CARRIER_EMERGENCY_OFF_BTN,
eDATA_ID_OPTION_AMOT_SYSTEM,
eDATA_ID_CO_BUFF_CCM11_TO_CDM_WRITE_SDO,
eDATA_ID_CARRIER_GEARBOX_AIR_PRESSURE_KPA,
eDATA_ID_COMPONENT_SWITCH_KEYON,
eDATA_ID_COMPONENT_SWITCH_KEYACC,
eDATA_ID_ERR_VAL_AIR_PRESS_VALVE_TCPTO_PTO_ON,
eDATA_ID_COUNT
} E_DataId;
#endif // DATAIDS_H
Aktuell bin ich mit der Implementierung noch nicht zufrieden, da ich für verschiedene Datentypen verschiedene Konstruktoren vorsehe, ich denke mal das geht besser, irgendwie über Templates vermute ich, da fehlt mir aber noch die Erfahrung...
DataObserver.h
Code: Alles auswählen
#ifndef DATAOBSERVER_H
#define DATAOBSERVER_H
#include <QObject>
#include <QDebug>
#include <QVariant>
#include "dataids.h"
class DataObserver : public QObject
{
Q_OBJECT
public:
explicit DataObserver(E_DataId eDataId, QMetaType::Type dataType, quint8 *pu8Data, QObject *parent = 0);
explicit DataObserver(E_DataId eDataId, QMetaType::Type dataType, quint16 *pu16Data, QObject *parent = 0);
explicit DataObserver(E_DataId eDataId, QMetaType::Type dataType, qint16 *ps16Data, QObject *parent = 0);
void checkForChange();
bool isDataChanged();
E_DataId getDataId();
QMetaType::Type getDataType();
QVariant getData();
signals:
void dataChanged(E_DataId eDataId, QMetaType::Type dataType, QVariant newData);
public slots:
private:
bool m_startup;
E_DataId eDataId;
QMetaType::Type dataType;
QVariant curData;
QVariant lastData;
// // Use UNION to allow only one variable (to save memory)
// union {
quint8 *pu8Data;
quint16 *pu16Data;
qint16 *ps16Data;
// };
void init(E_DataId eDataId, QMetaType::Type dataType);
};
#endif // DATAOBSERVER_H
Wie man sieht hatte ich mal vor die verschiedenen Datentypen als union zusammenzufassen, da ja stets nur ein Datentyp belegt ist. Hatte das einmal kurz getestet und mir sind auch weiter keine Probleme aufgefallen, war mir dann aber nicht sicher, ob das wirklich korrekt ist, da wollte ich mich erst noch genauer informieren.
DataObserver.cpp
Code: Alles auswählen
#include "dataobserver.h"
DataObserver::DataObserver(E_DataId eDataId, QMetaType::Type dataType, quint8 *pu8Data, QObject *parent)
: QObject(parent)
{
qInfo() << "New DataObserver 1 - " << QString::number(eDataId);
init(eDataId, dataType);
this->pu8Data = pu8Data;
this->lastData.setValue(*pu8Data);
}
DataObserver::DataObserver(E_DataId eDataId, QMetaType::Type dataType, quint16 *pu16Data, QObject *parent)
: QObject(parent)
{
qInfo() << "New DataObserver 2 - " << QString::number(eDataId);
init(eDataId, dataType);
this->pu16Data = pu16Data;
this->lastData.setValue(*pu16Data);
}
DataObserver::DataObserver(E_DataId eDataId, QMetaType::Type dataType, qint16 *ps16Data, QObject *parent)
: QObject(parent)
{
qInfo() << "New DataObserver 3 - " << QString::number(eDataId);
init(eDataId, dataType);
this->ps16Data = ps16Data;
this->lastData.setValue(*ps16Data);
}
void DataObserver::checkForChange()
{
// Check for data type
if(nullptr != this->pu8Data)
{
this->curData.setValue(*this->pu8Data);
}
else if(nullptr != this->pu16Data)
{
this->curData.setValue(*this->pu16Data);
}
else if(nullptr != this->ps16Data)
{
this->curData.setValue(*this->ps16Data);
}
else
{
// Do nothing
}
// Check for data change
if( (this->lastData != this->curData)
|| (this->m_startup)
) // endif
{
this->lastData = this->curData;
emit dataChanged(this->eDataId, this->dataType, this->curData);
}
else
{
// Do nothing
}
this->m_startup = false;
}
E_DataId DataObserver::getDataId()
{
return this->eDataId;
}
QMetaType::Type DataObserver::getDataType()
{
return this->dataType;
}
QVariant DataObserver::getData()
{
return this->curData;
}
void DataObserver::init(E_DataId eDataId, QMetaType::Type dataType)
{
this->m_startup = true;
this->eDataId = eDataId;
this->dataType = dataType;
this->curData.setValue(0);
this->pu8Data = nullptr;
this->pu16Data = nullptr;
this->ps16Data = nullptr;
}
Generelle Frage bezüglich dem Plan des Parsens der C-Code Dateien: Könnt ihr dazu gängige Tools oder Parser empfehlen? Habe bisher C-Code noch nie in so einer Form geparst. Werde noch selber nach Möglichkeiten forschen, aber fragen schadet ja nicht
Bin schon gespannt wie das wird, hehe