Plusieurs développements, dont l'implémentation du endian Intel

Otarcik_CAN/Sources/CANBus/CANSignal.cpp

@@ -1,5 +1,6 @@
 #include "CANSignal.h"
 #include "defines.h"
+#include <QtEndian>
 
 
 CCANSignal::CCANSignal():
@@ -14,12 +15,18 @@ int CCANSignal::ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize)
 {
     if(mEncoding == CAN_SIGNAL_ENCODING_INTEL)
     {
-        //TODO: trouver un device qui crache du intel??
-        mRawValue = NewValue;
+
+        mRawValue = qFromBigEndian(NewValue);
+//        mRawValue = NewValue;
+        mRawValue >>= mStartBit;
+        quint64 mask = 1;
+        mask <<= mSignalSize;
+        mask -= 1;
+        mRawValue &= mask;
+
     }
     else if(mEncoding == CAN_SIGNAL_ENCODING_MOTOROLA)
     {
-        //mRawValue = MotorolaValue;
         mRawValue = NewValue;
         int StartIndex = mStartBit - (mStartBit % 8) + 7 - (mStartBit % 8);
         int shift = ((MessageSize * 8) - StartIndex -1);
@@ -36,9 +43,67 @@ int CCANSignal::ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize)
     }
 
 
-    mPhysicalValue = ((signed) mRawValue * mValueFactor) + mValueOffset;
-//    mPhysicalValueUINT = ((quint64)((quint64) mRawValue * mValueFactor)) + (quint64)mValueOffset;
-//    mPhysicalValue = (qint64)((qint64) mRawValue * mValueFactor) + (qint64)mValueOffset;
+    //JFM 2023-06-13 - Ajout casting des variables en fonction du data size.
+    //L'idée c'est de contenir la valeur physique dans un double, ce qui permet de ne pas avoir à gérer le type
+    //à chaque fois qu'on accède à la donnée.  Mais pour que ça marche, il faut initialiser ce double comme il faut
+    //en castant en fonction de la taille et du signe de la donnée
+    qint64 SignedRawValue = 0;
+    if(mSignalSize <= 8)
+    {
+        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
+        {
+            SignedRawValue = (double)((qint8)mRawValue);
+        }
+        else
+        {
+            SignedRawValue = (double)((quint8)mRawValue);
+        }
+
+    }
+    else if(mSignalSize <= 16)
+    {
+        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
+        {
+            SignedRawValue = (double)((qint16)mRawValue);
+        }
+        else
+        {
+            SignedRawValue = (double)((quint16)mRawValue);
+        }
+//        qint16 RawShort = (qint16)mRawValue;
+//        SignedRawValue = (double)RawShort;
+    }
+    else if(mSignalSize <= 32)
+    {
+        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
+        {
+            SignedRawValue = (double)((qint32)mRawValue);
+        }
+        else
+        {
+            SignedRawValue = (double)((quint32)mRawValue);
+        }
+        //SignedRawValue = (signed)mRawValue;
+    }
+    else
+    {
+        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
+        {
+            SignedRawValue = (double)((signed)mRawValue);
+        }
+        else
+        {
+            SignedRawValue = (double)(mRawValue);
+        }
+    }
+    mPhysicalValue = (double)SignedRawValue;
+    mPhysicalValue *= mValueFactor;
+    mPhysicalValue += mValueOffset;
+
+    //JFM 2023-06-13 tentative de corriger le casting avec la vraie patente
+    //mPhysicalValue = ((signed) mRawValue * mValueFactor) + mValueOffset;
+
+
 
     return RET_OK;