Changement à la source de données MQTT

Début codage Watchdog CAN

Otarcik_CAN/Sources/CANBus/CANAnalyzer.cpp

@@ -48,7 +48,7 @@ int CCANAnalyzer::Init(quint8 CANDeviceChannel, TPCANBaudrate CANDeviceBaudrate,
 
     if(mCANDriverIF->GetDeviceHandle(mCANDeviceChannel,mCANDeviceHandle) != RET_OK)
     {
-        QString Log = QString("Impossible de trouver le module CAN avec le channel %1").arg(mCANDeviceChannel);
+        QString Log = QString("Impossible de trouver le module CAN sur le channel %1").arg(mCANDeviceChannel);
         CGeneralMessagesLogDispatcher::instance()->AddLogMessage(Log,true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
         mIsCANInitialized = false;
         return RET_GENERAL_ERROR;

Otarcik_CAN/Sources/CANBus/CANDataLogger.cpp

@@ -5,68 +5,52 @@ CCANDataLogger::CCANDataLogger():
     mTopicDeviceString("")
 {
     mMQTTCLient = 0;
+    mCANMsgList.clear();
+
+    CCANMessage toto;
+    toto.mCANMsgID = 234;
+    CCANSignal test;
+    test.mSignalName = "TOTORO";
+    toto.mSignalsList.append(test);
+
+    CCANMessage Bleh;
+    Bleh = toto;
+
 
 }
 
 
 int CCANDataLogger::LogNewData(const QList<CCANMessage *> *MsgList)
 {
-    //MQTT
-    //For each message in the list, we create a CCANMessage
 
-    //First, clear the current list
-    mMQTTMsgList.clear();
-    //qDebug("\n\n\n");
+    //Since the MQTT msg timeout is different from the CAN read timeout (much faster), and also each CAN device can have it's own timeout we need
+    //store the messages and update the values until it's ready to send to the MQTT broker.
 
     for(int i = 0; i < MsgList->size(); i++)
     {
-        if(MsgList->at(i)->mPendingData == true)
+        bool found = false;
+
+        int j = 0;
+        while(j < mCANMsgList.size() && found == false)
         {
-            CCANMessage *Msg = MsgList->at(i);
-            QString MsgPayload = "{";
-            QString MsgTopic = mTopicDeviceString;
-            MsgTopic.append(Msg->mCANMsgName);
-           // MsgTopic.append("/");
-
-            //For each signal with new data, insert an entry in the JSon payload string
-            for(int signal = 0; signal < Msg->mSignalsList.size(); signal++)
+            if(MsgList->at(i)->mCANMsgID == mCANMsgList.at(j).mCANMsgID &&
+               MsgList->at(i)->mPendingData == true)
             {
-                QString SignalData;
-                CCANSignal *Signal = Msg->mSignalsList.at(signal);
-                if(Signal->mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
-                {
-                    SignalData = QString("\"%1\":%2").arg(Signal->mSignalName).arg((quint64)Signal->mPhysicalValue);
-                }
-                else if(Signal->mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
-                {
-                    SignalData = QString("\"%1\":%2").arg(Signal->mSignalName).arg((qint64)Signal->mPhysicalValue);
-                }
-                else if(Signal->mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
-                        Signal->mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
-                {
-                    SignalData = QString("\"%1\":%2").arg(Signal->mSignalName).arg(Signal->mPhysicalValue,0,'f',1);
-                }
-                MsgPayload.append(SignalData);
-
-                if(signal < Msg->mSignalsList.size()-1)
-                {
-                    MsgPayload.append(",");
-                }
+                //We already had this msg in the list, just update it's value
+                found = true;
+                mCANMsgList[j] = *MsgList->at(i);
             }
-            MsgPayload.append("}");
-
-        //    qDebug("%s",qPrintable(MsgPayload));
-
-            CMQTTMessage NewMessage(MsgTopic, MsgPayload);
-            mMQTTMsgList.append(NewMessage);
-
-        } //if(MsgList->at(i)->mPendingData == true)
+            j++;
+        }
+        if(found == false && MsgList->at(i)->mPendingData == true)
+        {
+            //Message is not in our list, we must add it.
+            CCANMessage NewMsg = *MsgList->at(i);
+            mCANMsgList.append(NewMsg);
+        }
     }
 
-    if(mMQTTCLient != 0)
-    {
-        mMQTTCLient->NewMQTTMessages(mMQTTMsgList);
-    }
+
     return RET_OK;
 
 }
@@ -82,3 +66,67 @@ int CCANDataLogger::SetMQTTClient(CMQTTClientWrapper *MQTTClient)
 {
     mMQTTCLient = MQTTClient;
 }
+
+QList<CMQTTMessage> *CCANDataLogger::GetMQTTMessagesList()
+{
+    //MQTT
+    //The MQTT client wants to send the messages
+    //For each CAN message in the list, we create a MQTT Message
+
+    //First, clear the current list
+    mMQTTMsgList.clear();
+    //qDebug("\n\n\n");
+
+    for(int i = 0; i < mCANMsgList.size(); i++)
+    {
+ //       if(mCANMsgList.size() != 0)
+        {
+            const CCANMessage Msg = mCANMsgList.at(i);
+            QString MsgPayload = "{";
+            QString MsgTopic = mTopicDeviceString;
+            MsgTopic.append(Msg.mCANMsgName);
+           // MsgTopic.append("/");
+
+            //For each signal with new data, insert an entry in the JSon payload string
+            for(int signal = 0; signal < Msg.mSignalsList.size(); signal++)
+            {
+                QString SignalData;
+                CCANSignal Signal = Msg.mSignalsList.at(signal);
+                if(Signal.mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
+                {
+                    SignalData = QString("\"%1\":%2").arg(Signal.mSignalName).arg((quint64)Signal.mPhysicalValue);
+                }
+                else if(Signal.mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
+                {
+                    SignalData = QString("\"%1\":%2").arg(Signal.mSignalName).arg((qint64)Signal.mPhysicalValue);
+                }
+                else if(Signal.mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
+                        Signal.mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
+                {
+                    SignalData = QString("\"%1\":%2").arg(Signal.mSignalName).arg(Signal.mPhysicalValue,0,'f',1);
+                }
+                MsgPayload.append(SignalData);
+
+                if(signal < Msg.mSignalsList.size()-1)
+                {
+                    MsgPayload.append(",");
+                }
+            }
+            MsgPayload.append("}");
+
+        //    qDebug("%s",qPrintable(MsgPayload));
+
+            CMQTTMessage NewMessage(MsgTopic, MsgPayload);
+            mMQTTMsgList.append(NewMessage);
+
+        } //if(MsgList->at(i)->mPendingData == true)
+    }
+
+    mCANMsgList.clear();
+
+//    if(mMQTTCLient != 0)
+//    {
+//        mMQTTCLient->NewMQTTMessages(mMQTTMsgList);
+//    }
+    return &mMQTTMsgList;
+}

Otarcik_CAN/Sources/CANBus/CANDataLogger.h

@@ -5,6 +5,7 @@
 #include <QList>
 #include "CANMessage.h"
 #include "MQTTClientWrapper.h"
+#include <QTimer>
 
 class CCANDataLogger
 {
@@ -18,10 +19,12 @@ public:
     QString mTopicDeviceString;
     QList<CMQTTMessage> mMQTTMsgList;
     CMQTTClientWrapper *mMQTTCLient;
+    QList<CCANMessage> mCANMsgList;
 
     int SetMQTTTopicDevice(QString DeviceString);
     int SetMQTTClient(CMQTTClientWrapper *MQTTClient);
 
+    QList<CMQTTMessage> *GetMQTTMessagesList();
 
 };
 

Otarcik_CAN/Sources/CANBus/CANDevice.cpp

@@ -108,6 +108,11 @@ int CCANDevice::NewMessageParsed()
     return RET_OK;
 }
 
+QList<CMQTTMessage> *CCANDevice::GetMQTTMessagesList()
+{
+    return mCANDataLogger.GetMQTTMessagesList();
+}
+
 
 QDataStream &operator<<(QDataStream &out, const CCANDevice &source)
 {

Otarcik_CAN/Sources/CANBus/CANDevice.h

@@ -11,6 +11,7 @@
 #include "PCANBasic.h"
 #include "CANDeviceConfig.h"
 #include "CANDataLogger.h"
+#include "MQTTMessage.h"
 //#include "MQTTClientWrapper.h"
 
 class CMQTTClientWrapper;
@@ -38,6 +39,7 @@ public:
     CMQTTClientWrapper *mCANMQTTClient;
 
     QList<CCANMessage*> mMessageList;
+    QList<CMQTTMessage> *GetMQTTMessagesList();
 
 //    CCANDevice &operator=(const CCANDevice *source);
 

Otarcik_CAN/Sources/CANBus/CANMessage.cpp

@@ -19,10 +19,10 @@ CCANMessage::CCANMessage(const quint32 Channel, const TPCANMsg CANMsg, const TPC
 }
 CCANMessage::~CCANMessage()
 {
-    while (!mSignalsList.isEmpty())
-    {
-          delete mSignalsList.takeFirst();
-    }
+//    while (!mSignalsList.isEmpty())
+//    {
+//          delete mSignalsList.takeFirst();
+//    }
 }
 
 int CCANMessage::SetDataFromDriver(quint32 Channel, TPCANMsg CANMsg, TPCANTimestamp CANTimeStamp)
@@ -51,7 +51,7 @@ int CCANMessage::AddSignal(CCANSignal *NewSignal)
         return RET_GENERAL_ERROR;
     }
 
-    mSignalsList.append(NewSignal);
+    mSignalsList.append(*NewSignal);
     return RET_OK;
 }
 
@@ -90,7 +90,7 @@ int CCANMessage::UpdateValue(CCANMessage *NewDeviceMessage)
 
     for(int i = 0; i < mSignalsList.size(); i++)
     {
-        mSignalsList.at(i)->ComputeNewSignalValue(mCANRawDataIntel, mCANMsgLength);
+        mSignalsList[i].ComputeNewSignalValue(mCANRawDataIntel, mCANMsgLength);
     }
 
     return RET_OK;
@@ -125,21 +125,27 @@ QDataStream &operator>>(QDataStream &in, CCANMessage &dest)
     return in;
 }
 
-CCANMessage& CCANMessage::operator=(const CCANMessage *source)
+CCANMessage& CCANMessage::operator=(const CCANMessage &source)
 {
-    if(source == this)
+    if(&source == this)
     {
         return *this;
     }
 
-    this->mCANChannel = source->mCANChannel;
-    this->mCANMsgID = source->mCANMsgID;
-    this->mCANMsgType = source->mCANMsgType;
-    this->mCANMsgLength = source->mCANMsgLength;
-    this->mCANMsgData = source->mCANMsgData;
-    this->mCANMsgMillisecs = source->mCANMsgMillisecs;
-    this->mCANMsgMillisecsOverflow = source->mCANMsgMillisecsOverflow;
-    this->mCANMsgMicrosecs = source->mCANMsgMicrosecs;
+    this->mCANChannel = source.mCANChannel;
+    this->mCANMsgID = source.mCANMsgID;
+    this->mCANMsgType = source.mCANMsgType;
+    this->mCANMsgLength = source.mCANMsgLength;
+    this->mCANMsgData = source.mCANMsgData;
+    this->mCANMsgMillisecs = source.mCANMsgMillisecs;
+    this->mCANMsgMillisecsOverflow = source.mCANMsgMillisecsOverflow;
+    this->mCANMsgMicrosecs = source.mCANMsgMicrosecs;
+    this->mSignalsList.clear();
+    for(int i = 0; i < source.mSignalsList.size(); i++)
+    {
+        CCANSignal NewSignal = source.mSignalsList.at(i);
+        this->mSignalsList.append(NewSignal);
+    }
 
     return *this;
 }

Otarcik_CAN/Sources/CANBus/CANMessage.h

@@ -28,14 +28,14 @@ public:
     quint32 mCANMsgFlags;       //Message flags from database
     unsigned int mCANMsgLength;     // Data Length Code of the message (0..8) from database
 
-    QList<CCANSignal*> mSignalsList;
+    QList<CCANSignal> mSignalsList;
 
     //Timestamp
     quint64 mCANMsgMillisecs;             // Base-value: milliseconds: 0.. 2^32-1
     quint32 mCANMsgMillisecsOverflow;    // Roll-arounds of millis
     quint32 mCANMsgMicrosecs;             // Microseconds: 0..999
 
-    CCANMessage &operator=(const CCANMessage *source);
+    CCANMessage &operator=(const CCANMessage &source);
     int SetDataFromDriver(quint32 Channel,TPCANMsg CANMsg,TPCANTimestamp CANTimeStamp);
     int AddSignal(CCANSignal* NewSignal);
     int UpdateValue(CCANMessage* NewDeviceMessage);

Otarcik_CAN/Sources/CANBus/CANSignal.cpp

@@ -43,3 +43,26 @@ int CCANSignal::ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize)
     return RET_OK;
 
 }
+
+CCANSignal& CCANSignal::operator=(const CCANSignal &source)
+{
+    if(&source == this)
+    {
+        return *this;
+    }
+    qDebug("CANSignal Equal operator");
+    this->mSignalName = source.mSignalName;
+    this->mSignalComment = source.mSignalComment;
+    this->mEncoding = source.mEncoding;
+    this->mMultiplexing = source. mMultiplexing;
+    this->mStartBit = source. mStartBit;
+    this->mSignalSize = source. mSignalSize;
+    this->mValueType = source. mValueType;
+    this->mValueFactor = source.mValueFactor;
+    this->mValueOffset = source. mValueOffset;
+    this->mMinValue = source.mMinValue;
+    this->mMaxValue = source.mMaxValue;
+    this->mSignalUnit = source.mSignalUnit;
+
+    return *this;
+}

Otarcik_CAN/Sources/CANBus/CANSignal.h

@@ -54,7 +54,7 @@ public:
     QString mSignalUnit;
 
     int ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize);
-
+    CCANSignal &operator=(const CCANSignal &source);
 
     quint64 mRawValue;
     double mPhysicalValue;