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;

Otarcik_CAN/Sources/CloudLogging/MQTTClientWrapper.cpp

@@ -1,11 +1,13 @@
 #include "MQTTClientWrapper.h"
 #include "OtarcikCan.h"
+#include "CANDevice.h"
 
 CMQTTClientWrapper::CMQTTClientWrapper()
 {
     connect(&mMQTTClient,&QMqttClient::stateChanged,this,&CMQTTClientWrapper::StateChanged);
     mMQTTRefreshTimer = new QTimer;
     mMQTTRefreshTimer->setSingleShot(true);
+    connect(mMQTTRefreshTimer,&QTimer::timeout,this,&CMQTTClientWrapper::MQTTSendTimerExpired);
     mProgramPtr = 0;
 }
 
@@ -45,29 +47,29 @@ int CMQTTClientWrapper::DisconnectFromBroker()
 
 int CMQTTClientWrapper::NewMQTTMessages(QList<CMQTTMessage> MessagesList)
 {
-    if(mMQTTClient.state() != QMqttClient::Connected)
-    {
-        return RET_GENERAL_ERROR;
-    }
-    if(mMQTTRefreshTimer->remainingTime() > 0)
-    {
-   //     qDebug("MQTT timer value: %d",mMQTTRefreshTimer->remainingTime());
-        return RET_OK;
-    }
-    if(MessagesList.isEmpty())
-    {
-        return RET_GENERAL_ERROR;
-    }
+//    if(mMQTTClient.state() != QMqttClient::Connected)
+//    {
+//        return RET_GENERAL_ERROR;
+//    }
+//    if(mMQTTRefreshTimer->remainingTime() > 0)
+//    {
+//   //     qDebug("MQTT timer value: %d",mMQTTRefreshTimer->remainingTime());
+//        return RET_OK;
+//    }
+//    if(MessagesList.isEmpty())
+//    {
+//        return RET_GENERAL_ERROR;
+//    }
 
 
-    for(int i = 0; i < MessagesList.size(); i++)
-    {
-        qint32 res = mMQTTClient.publish(MessagesList.at(i).mMessageTopic,MessagesList.at(i).mMessagePayload.toLocal8Bit(),0,true);
-        qDebug("%s : %s",qPrintable(MessagesList.at(i).mMessageTopic), qPrintable(MessagesList.at(i).mMessagePayload));
+//    for(int i = 0; i < MessagesList.size(); i++)
+//    {
+//        qint32 res = mMQTTClient.publish(MessagesList.at(i).mMessageTopic,MessagesList.at(i).mMessagePayload.toLocal8Bit(),0,true);
+//        qDebug("%s : %s",qPrintable(MessagesList.at(i).mMessageTopic), qPrintable(MessagesList.at(i).mMessagePayload));
 
-    }
-    mMQTTRefreshTimer->start(mMQTTParams.mMQTTTransmitTimeout);
-    qDebug("Sent %d MQTT messages",MessagesList.size());
+//    }
+//    mMQTTRefreshTimer->start(mMQTTParams.mMQTTTransmitTimeout);
+//    qDebug("Sent %d MQTT messages",MessagesList.size());
 
 
     return RET_OK;
@@ -81,11 +83,13 @@ void CMQTTClientWrapper::StateChanged()
         {
             qDebug("MQTT client Disconnected");
             mProgramPtr->SetMQTTConnectionSatusRequest(false);
+            mMQTTRefreshTimer->stop();
             break;
         }
         case QMqttClient::Connected:
         {
             mProgramPtr->SetMQTTConnectionSatusRequest(true);
+            mMQTTRefreshTimer->start(mMQTTParams.mMQTTTransmitTimeout);
             qDebug("MQTT client Connected");
             break;
         }
@@ -101,4 +105,43 @@ int CMQTTClientWrapper::SendMQTTTestMessage()
 {
     mMQTTClient.publish(QString("Otarcik/Test"),QString("Test Payload").toLocal8Bit(),0,true);
     qDebug("Sending MQTT test message");
+    return RET_OK;
+}
+
+int CMQTTClientWrapper::SetCANDevicesList(QList<CCANDevice *> *List)
+{
+    mCANDevicesList = List;
+    return RET_OK;
+}
+
+void CMQTTClientWrapper::MQTTSendTimerExpired()
+{
+    if(mMQTTClient.state() != QMqttClient::Connected)
+    {
+        return;
+    }
+    if(mCANDevicesList == 0)
+    {
+        return;
+    }
+
+    //Send the CANbus devices messsages
+    for(int j = 0; j < mCANDevicesList->size(); j++)
+    {
+        CCANDevice *Device = mCANDevicesList->at(j);
+        QList<CMQTTMessage> *MessagesList = Device->GetMQTTMessagesList();
+        if(MessagesList != 0)
+        {
+            for(int i = 0; i < MessagesList->size(); i++)
+            {
+                qint32 res = mMQTTClient.publish(MessagesList->at(i).mMessageTopic,MessagesList->at(i).mMessagePayload.toLocal8Bit(),0,true);
+                qDebug("%s : %s",qPrintable(MessagesList->at(i).mMessageTopic), qPrintable(MessagesList->at(i).mMessagePayload));
+
+            }
+            qDebug("Sent %d MQTT messages",MessagesList->size());
+        }
+    }
+
+    mMQTTRefreshTimer->start(mMQTTParams.mMQTTTransmitTimeout);
+
 }

Otarcik_CAN/Sources/CloudLogging/MQTTClientWrapper.h

@@ -8,7 +8,9 @@
 #include "MQTTMessage.h"
 #include <QList>
 
+
 class COtarcikCan;
+class CCANDevice;
 
 class CMQTTClientWrapper : public QObject
 {
@@ -21,6 +23,7 @@ public:
     int NewMQTTMessages(QList<CMQTTMessage> MessagesList);
     int DisconnectFromBroker();
     int SendMQTTTestMessage();
+    int SetCANDevicesList(QList<CCANDevice*> *List);
 
     COtarcikCan *mProgramPtr;
     QString mMQTTClientID;
@@ -30,9 +33,11 @@ public:
 private:
     QMqttClient mMQTTClient;
     CCloudParams mMQTTParams;
+    QList<CCANDevice*> *mCANDevicesList;
 
 public slots:
     void StateChanged();
+    void MQTTSendTimerExpired();
 
 };
 

Otarcik_CAN/Sources/Gui/CANViewerPage.cpp

@@ -145,33 +145,33 @@ void CCANViewerPage::MessageSelectionChanged()
             for(int signal = 0; signal < Msg->mSignalsList.size(); signal++)
             {
                 //Signal name
-                QTableWidgetItem *NewItem = new QTableWidgetItem(Msg->mSignalsList.at(signal)->mSignalName);
+                QTableWidgetItem *NewItem = new QTableWidgetItem(Msg->mSignalsList.at(signal).mSignalName);
                 ui->mCANSignalTableWidget->setItem(signal,0,NewItem);
 
                 //Phys value
 
-                if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
+                if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
                 {
-                    NewItem = new QTableWidgetItem(QString("%1").arg((quint64)Msg->mSignalsList.at(signal)->mPhysicalValue));
+                    NewItem = new QTableWidgetItem(QString("%1").arg((quint64)Msg->mSignalsList.at(signal).mPhysicalValue));
                 }
-                else if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
+                else if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
                 {
 
-                    NewItem = new QTableWidgetItem(QString("%1").arg((qint64)Msg->mSignalsList.at(signal)->mPhysicalValue));
+                    NewItem = new QTableWidgetItem(QString("%1").arg((qint64)Msg->mSignalsList.at(signal).mPhysicalValue));
                 }
-                else if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
-                        Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
+                else if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
+                        Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
                 {
-                    NewItem = new QTableWidgetItem(QString("%1").arg(Msg->mSignalsList.at(signal)->mPhysicalValue,0,'f',1));
+                    NewItem = new QTableWidgetItem(QString("%1").arg(Msg->mSignalsList.at(signal).mPhysicalValue,0,'f',1));
                 }
                 ui->mCANSignalTableWidget->setItem(signal,1,NewItem);
 
                 //Raw value
-                NewItem = new QTableWidgetItem(QString("0x%1").arg(Msg->mSignalsList.at(signal)->mRawValue,0,16));
+                NewItem = new QTableWidgetItem(QString("0x%1").arg(Msg->mSignalsList.at(signal).mRawValue,0,16));
                 ui->mCANSignalTableWidget->setItem(signal,2,NewItem);
 
                 //Units
-                NewItem = new QTableWidgetItem(Msg->mSignalsList.at(signal)->mSignalUnit);
+                NewItem = new QTableWidgetItem(Msg->mSignalsList.at(signal).mSignalUnit);
                 ui->mCANSignalTableWidget->setItem(signal,3,NewItem);
 
             }
@@ -195,28 +195,28 @@ int CCANViewerPage::UpdateSignalsTable()
             for(int signal = 0; signal < Msg->mSignalsList.size(); signal++)
             {
                 //Signal name
-                ui->mCANSignalTableWidget->item(row,0)->setText(Msg->mSignalsList.at(signal)->mSignalName);
+                ui->mCANSignalTableWidget->item(row,0)->setText(Msg->mSignalsList.at(signal).mSignalName);
 
                 //Phys value
-                if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
+                if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT)
                 {
-                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg((quint64)Msg->mSignalsList.at(signal)->mPhysicalValue));
+                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg((quint64)Msg->mSignalsList.at(signal).mPhysicalValue));
                 }
-                else if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
+                else if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT)
                 {
-                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg((qint64)Msg->mSignalsList.at(signal)->mPhysicalValue));
+                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg((qint64)Msg->mSignalsList.at(signal).mPhysicalValue));
                 }
-                else if(Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
-                        Msg->mSignalsList.at(signal)->mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
+                else if(Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT ||
+                        Msg->mSignalsList.at(signal).mValueType == CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE)
                 {
-                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg(Msg->mSignalsList.at(signal)->mPhysicalValue,0,'f',1));
+                    ui->mCANSignalTableWidget->item(row,0)->setText(QString("%1").arg(Msg->mSignalsList.at(signal).mPhysicalValue,0,'f',1));
                 }
 
                 //Raw value
-                ui->mCANSignalTableWidget->item(row,0)->setText(QString("0x%1").arg(Msg->mSignalsList.at(signal)->mRawValue,0,16));
+                ui->mCANSignalTableWidget->item(row,0)->setText(QString("0x%1").arg(Msg->mSignalsList.at(signal).mRawValue,0,16));
 
                 //Units
-                ui->mCANSignalTableWidget->item(row,0)->setText(Msg->mSignalsList.at(signal)->mSignalUnit);
+                ui->mCANSignalTableWidget->item(row,0)->setText(Msg->mSignalsList.at(signal).mSignalUnit);
 
             }
         }

Otarcik_CAN/Sources/Gui/CANbusSettingsPage.cpp

@@ -223,23 +223,23 @@ int CCANbusSettingsPage::UpdateMessageInformation()
          ui->mDBSignalDetailsTable->setRowCount(Message->mSignalsList.size());
         for(int Sig = 0; Sig < Message->mSignalsList.size(); Sig++)
         {
-           CCANSignal *Signal = Message->mSignalsList.at(Sig);
+           CCANSignal Signal = Message->mSignalsList.at(Sig);
            QTableWidgetItem *NewItem;
 
            //Signal name
-           NewItem = new QTableWidgetItem(Signal->mSignalName);
+           NewItem = new QTableWidgetItem(Signal.mSignalName);
            ui->mDBSignalDetailsTable->setItem(Sig,0,NewItem);
 
            //Bit No
-           NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mStartBit));
+           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mStartBit));
            ui->mDBSignalDetailsTable->setItem(Sig,1,NewItem);
 
            //Length
-           NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mSignalSize));
+           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mSignalSize));
            ui->mDBSignalDetailsTable->setItem(Sig,2,NewItem);
 
            //Type
-           switch(Signal->mValueType)
+           switch(Signal.mValueType)
            {
                case CCANSignal::CAN_SIGNAL_TYPE_INVALID:
                {
@@ -270,27 +270,27 @@ int CCANbusSettingsPage::UpdateMessageInformation()
            ui->mDBSignalDetailsTable->setItem(Sig,3,NewItem);
 
            //Max Val
-          NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mMaxValue));
+          NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mMaxValue));
            ui->mDBSignalDetailsTable->setItem(Sig,4,NewItem);
 
            //Min Val
-           NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mMinValue));
+           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mMinValue));
            ui->mDBSignalDetailsTable->setItem(Sig,5,NewItem);
 
            //Offset
-           NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mValueOffset));
+           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mValueOffset));
            ui->mDBSignalDetailsTable->setItem(Sig,6,NewItem);
 
            //Scale Factor
-           NewItem = new QTableWidgetItem(QString("%1").arg(Signal->mValueFactor,0,'f',1));
+           NewItem = new QTableWidgetItem(QString("%1").arg(Signal.mValueFactor,0,'f',1));
            ui->mDBSignalDetailsTable->setItem(Sig,7,NewItem);
 
            //Unit
-           NewItem = new QTableWidgetItem(Signal->mSignalUnit);
+           NewItem = new QTableWidgetItem(Signal.mSignalUnit);
            ui->mDBSignalDetailsTable->setItem(Sig,8,NewItem);
 
            //Endian
-           switch(Signal->mEncoding)
+           switch(Signal.mEncoding)
            {
                case CCANSignal::CAN_SIGNAL_ENCODING_INTEL:
                {

Otarcik_CAN/Sources/Gui/CANbusSettingsPage.h

@@ -2,6 +2,7 @@
 #define CANBUSSETTINGSPAGE_H
 
 #include <QWidget>
+#include "CANDevice.h"
 
 class CCANDevice;
 class CCANMessage;

Otarcik_CAN/Sources/Gui/CANbusSettingsPage.ui

@@ -28,7 +28,7 @@
     </font>
    </property>
    <property name="text">
-    <string>Paramètres CAN de la station Otarcik</string>
+    <string>Paramètres des dispositifs CAN</string>
    </property>
   </widget>
   <widget class="QListWidget" name="mDevicesList">

Otarcik_CAN/Sources/Gui/CCANWatchdogSettingsPage.cpp

@@ -0,0 +1,78 @@
+#include "CCANWatchdogSettingsPage.h"
+#include "ui_CCANWatchdogSettingsPage.h"
+#include "CANDevice.h"
+
+CCANWatchdogSettingsPage::CCANWatchdogSettingsPage(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::CCANWatchdogSettingsPage)
+{
+    ui->setupUi(this);
+
+    connect(ui->mCANWatchdogChangBtn,&QPushButton::pressed,this,&CCANWatchdogSettingsPage::ChangeSettingsButtonPressed);
+    connect(ui->mCANWatchdogCancelBtn,&QPushButton::pressed,this,&CCANWatchdogSettingsPage::CancelButtonPressed);
+
+    ui->mCANWatchdogBaudrateComboBx->clear();
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_1M",QVariant(PCAN_BAUD_1M));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_800K",QVariant(PCAN_BAUD_800K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_500K",QVariant(PCAN_BAUD_500K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_250K",QVariant(PCAN_BAUD_250K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_125K",QVariant(PCAN_BAUD_125K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_100K",QVariant(PCAN_BAUD_100K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_95K",QVariant(PCAN_BAUD_95K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_83K",QVariant(PCAN_BAUD_83K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_50K",QVariant(PCAN_BAUD_50K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_47K",QVariant(PCAN_BAUD_47K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_33K",QVariant(PCAN_BAUD_33K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_20K",QVariant(PCAN_BAUD_20K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_10K",QVariant(PCAN_BAUD_10K));
+    ui->mCANWatchdogBaudrateComboBx->addItem("PCAN_BAUD_5K",QVariant(PCAN_BAUD_5K));
+
+    ui->mCANWatchdogCancelBtn->setVisible(false);
+
+    ui->mCANWatchdogBaudrateComboBx->setEnabled(false);
+    ui->mCANWatchdogDeviceIDSpinBx->setEnabled(false);
+    ui->mCANWatchdogTimeoutSpinBx->setEnabled(false);
+
+    mIsSettingsChangeMode = false;
+}
+
+CCANWatchdogSettingsPage::~CCANWatchdogSettingsPage()
+{
+    delete ui;
+}
+
+void CCANWatchdogSettingsPage::CancelButtonPressed()
+{
+
+    mIsSettingsChangeMode = false;
+
+    ui->mCANWatchdogCancelBtn->setVisible(false);
+    ui->mCANWatchdogBaudrateComboBx->setEnabled(false);
+    ui->mCANWatchdogDeviceIDSpinBx->setEnabled(false);
+    ui->mCANWatchdogTimeoutSpinBx->setEnabled(false);
+     ui->mCANWatchdogChangBtn->setText("Modifier");
+}
+
+void CCANWatchdogSettingsPage::ChangeSettingsButtonPressed()
+{
+    if(mIsSettingsChangeMode == false)
+    {
+        mIsSettingsChangeMode = true;
+
+        ui->mCANWatchdogCancelBtn->setVisible(true);
+        ui->mCANWatchdogBaudrateComboBx->setEnabled(true);
+        ui->mCANWatchdogDeviceIDSpinBx->setEnabled(true);
+        ui->mCANWatchdogTimeoutSpinBx->setEnabled(true);
+        ui->mCANWatchdogChangBtn->setText("Sauvegarder");
+    }
+    else
+    {
+        mIsSettingsChangeMode = false;
+
+        ui->mCANWatchdogCancelBtn->setVisible(false);
+        ui->mCANWatchdogBaudrateComboBx->setEnabled(false);
+        ui->mCANWatchdogDeviceIDSpinBx->setEnabled(false);
+        ui->mCANWatchdogTimeoutSpinBx->setEnabled(false);
+        ui->mCANWatchdogChangBtn->setText("Modifier");
+    }
+}

Otarcik_CAN/Sources/Gui/CCANWatchdogSettingsPage.h

@@ -0,0 +1,27 @@
+#ifndef CCANWATCHDOGSETTINGSPAGE_H
+#define CCANWATCHDOGSETTINGSPAGE_H
+
+#include <QWidget>
+
+namespace Ui {
+class CCANWatchdogSettingsPage;
+}
+
+class CCANWatchdogSettingsPage : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit CCANWatchdogSettingsPage(QWidget *parent = 0);
+    ~CCANWatchdogSettingsPage();
+    bool mIsSettingsChangeMode;
+
+private:
+    Ui::CCANWatchdogSettingsPage *ui;
+
+public slots:
+    void ChangeSettingsButtonPressed();
+    void CancelButtonPressed();
+};
+
+#endif // CCANWATCHDOGSETTINGSPAGE_H

Otarcik_CAN/Sources/Gui/CCANWatchdogSettingsPage.ui

@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CCANWatchdogSettingsPage</class>
+ <widget class="QWidget" name="CCANWatchdogSettingsPage">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1085</width>
+    <height>544</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <widget class="QLabel" name="mCANWatchdogPageTitle">
+   <property name="geometry">
+    <rect>
+     <x>310</x>
+     <y>10</y>
+     <width>381</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <pointsize>12</pointsize>
+     <weight>75</weight>
+     <bold>true</bold>
+    </font>
+   </property>
+   <property name="text">
+    <string>CAN Watchdog</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="mCANWatchdogDevIDLbl">
+   <property name="geometry">
+    <rect>
+     <x>110</x>
+     <y>140</y>
+     <width>111</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <pointsize>10</pointsize>
+    </font>
+   </property>
+   <property name="text">
+    <string>CAN Device ID:</string>
+   </property>
+   <property name="scaledContents">
+    <bool>false</bool>
+   </property>
+   <property name="alignment">
+    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+   </property>
+  </widget>
+  <widget class="QLabel" name="mCANWatchdogBaudrateLbl">
+   <property name="geometry">
+    <rect>
+     <x>120</x>
+     <y>180</y>
+     <width>91</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <pointsize>10</pointsize>
+    </font>
+   </property>
+   <property name="text">
+    <string>CAN Baudrate:</string>
+   </property>
+   <property name="scaledContents">
+    <bool>false</bool>
+   </property>
+   <property name="alignment">
+    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+   </property>
+  </widget>
+  <widget class="QSpinBox" name="mCANWatchdogDeviceIDSpinBx">
+   <property name="geometry">
+    <rect>
+     <x>230</x>
+     <y>140</y>
+     <width>61</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="minimum">
+    <number>1</number>
+   </property>
+   <property name="maximum">
+    <number>255</number>
+   </property>
+  </widget>
+  <widget class="QComboBox" name="mCANWatchdogBaudrateComboBx">
+   <property name="geometry">
+    <rect>
+     <x>230</x>
+     <y>180</y>
+     <width>161</width>
+     <height>22</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLabel" name="mCANWatchdogTimeoutLbl">
+   <property name="geometry">
+    <rect>
+     <x>60</x>
+     <y>220</y>
+     <width>151</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <pointsize>10</pointsize>
+    </font>
+   </property>
+   <property name="text">
+    <string>Watchdog Timeout (ms):</string>
+   </property>
+   <property name="scaledContents">
+    <bool>false</bool>
+   </property>
+   <property name="alignment">
+    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+   </property>
+  </widget>
+  <widget class="QSpinBox" name="mCANWatchdogTimeoutSpinBx">
+   <property name="geometry">
+    <rect>
+     <x>230</x>
+     <y>220</y>
+     <width>151</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="minimum">
+    <number>1</number>
+   </property>
+   <property name="maximum">
+    <number>100000</number>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="mCANWatchdogChangBtn">
+   <property name="geometry">
+    <rect>
+     <x>240</x>
+     <y>280</y>
+     <width>80</width>
+     <height>22</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Modifier</string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="mCANWatchdogCancelBtn">
+   <property name="geometry">
+    <rect>
+     <x>130</x>
+     <y>280</y>
+     <width>80</width>
+     <height>22</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Annuler</string>
+   </property>
+  </widget>
+  <widget class="QGroupBox" name="groupBox">
+   <property name="geometry">
+    <rect>
+     <x>50</x>
+     <y>100</y>
+     <width>371</width>
+     <height>231</height>
+    </rect>
+   </property>
+   <property name="title">
+    <string>Paramètres de la puck Watchdog</string>
+   </property>
+  </widget>
+  <zorder>groupBox</zorder>
+  <zorder>mCANWatchdogPageTitle</zorder>
+  <zorder>mCANWatchdogDevIDLbl</zorder>
+  <zorder>mCANWatchdogBaudrateLbl</zorder>
+  <zorder>mCANWatchdogDeviceIDSpinBx</zorder>
+  <zorder>mCANWatchdogBaudrateComboBx</zorder>
+  <zorder>mCANWatchdogTimeoutLbl</zorder>
+  <zorder>mCANWatchdogTimeoutSpinBx</zorder>
+  <zorder>mCANWatchdogChangBtn</zorder>
+  <zorder>mCANWatchdogCancelBtn</zorder>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

Otarcik_CAN/Sources/Gui/GeneralStatusPage.ui

@@ -123,6 +123,16 @@
     <string>Déconnecté</string>
    </property>
   </widget>
+  <widget class="QTableWidget" name="tableWidget">
+   <property name="geometry">
+    <rect>
+     <x>1200</x>
+     <y>20</y>
+     <width>371</width>
+     <height>441</height>
+    </rect>
+   </property>
+  </widget>
  </widget>
  <resources/>
  <connections/>

Otarcik_CAN/Sources/MainWindow.cpp

@@ -29,6 +29,7 @@ CMainWindow::CMainWindow(QWidget *parent) :
     mCANbusSettingsPage = new CCANbusSettingsPage(this);
     mCANViewerPage = new CCANViewerPage(this);
     mDataLoggingSettingsPage = new CLoggingSettingsPage(this);
+    mCANWatchdogSettingsPage = new CCANWatchdogSettingsPage(this);
 
     mProgramsSettingsTabWidget->setTabPosition(QTabWidget::West);
     setCentralWidget(mMainWindowWidget);
@@ -36,8 +37,10 @@ CMainWindow::CMainWindow(QWidget *parent) :
     mMainWindowWidget->addTab(mProgramsSettingsTabWidget,"Paramètres");
     mMainWindowWidget->addTab(mCANViewerPage,"Données CAN");
     mProgramsSettingsTabWidget->addTab(mCANbusSettingsPage,"CAN Bus");
+    mProgramsSettingsTabWidget->addTab(mCANWatchdogSettingsPage,"Watchdog");
     mProgramsSettingsTabWidget->addTab(mDataLoggingSettingsPage,"Archivage");
 
+
     resize(1700,768);
 }
 

Otarcik_CAN/Sources/MainWindow.h

@@ -9,6 +9,7 @@
 #include "CANbusSettingsPage.h"
 #include "CANViewerPage.h"
 #include "LoggingSettingsPage.h"
+#include "CCANWatchdogSettingsPage.h"
 
 namespace Ui {
 class CMainWindow;
@@ -28,6 +29,7 @@ public:
     CCANbusSettingsPage *mCANbusSettingsPage;
     CCANViewerPage *mCANViewerPage;
     CLoggingSettingsPage *mDataLoggingSettingsPage;
+    CCANWatchdogSettingsPage *mCANWatchdogSettingsPage;
 
 
 private:

Otarcik_CAN/Sources/OtarcikCan.cpp

@@ -72,6 +72,8 @@ int COtarcikCan::Start()
 
         mCANBusMQTTClient.SetMQTTParams(&mCloudLoggingParams);
         mCANBusMQTTClient.ConnectToBroker();
+        mCANBusMQTTClient.SetCANDevicesList(&mCANDevicesList);
+
         mGPTimer->setSingleShot(false);
         mGPTimer->start(5000);
 
@@ -194,10 +196,10 @@ void COtarcikCan::GPTimerExpired()
 
 int COtarcikCan::SetCANConnectionStatusRequest(bool Connected)
 {
-    mMainWindow.mGeneralStatusPage->SetCANConnectionStatus(Connected);
+    return mMainWindow.mGeneralStatusPage->SetCANConnectionStatus(Connected);
 }
 
 int COtarcikCan::SetMQTTConnectionSatusRequest(bool Connected)
 {
-    mMainWindow.mGeneralStatusPage->SetMQTTConnectionStatus(Connected);
+    return mMainWindow.mGeneralStatusPage->SetMQTTConnectionStatus(Connected);
 }

Otarcik_CAN/Sources/PCANInterface.cpp

@@ -32,7 +32,7 @@ int CPCANInterface::GetDeviceHandle(quint8 DeviceID, TPCANHandle &Handle)
 {
     TPCANHandle TempHandle;
     QString Parameters = QString("devicetype=pcan_usb, deviceid=%1").arg(DeviceID);
-    if(CAN_LookUpChannel(Parameters.toLocal8Bit().data(),&TempHandle) != PCAN_ERROR_OK)
+    if(CAN_LookUpChannel(Parameters.toLocal8Bit().data(),&TempHandle) != PCAN_ERROR_OK || TempHandle == PCAN_NONEBUS)
     {
         Handle = 0;
         return RET_GENERAL_ERROR;