qtforum.de

Code: Alles auswählen

class Variable : public QObject
{
Q_OBJECT
private: 
  QString _name;
  int* _pointerToVariable;
  int _prevValue;
public:
  explicit Variable( QString name, int* pointerToVariable );
signals:
   void changed( int newValue );
public slots:
  void refresh(){ 
    int actValue = (*_pointerToVariable);
    if( actValue != _prevValue ){
      _prevValue = actValue; 
      emit changed( actValue );
    }
};

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

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

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;
}