142 lines
3.9 KiB
C++
142 lines
3.9 KiB
C++
#include "CANSignal.h"
|
|
#include "defines.h"
|
|
#include <QtEndian>
|
|
|
|
|
|
CCANSignal::CCANSignal():
|
|
mRawValue(0),
|
|
mPhysicalValue(0.0)
|
|
{
|
|
mEncoding = CAN_SIGNAL_ENCODING_INVALID;
|
|
|
|
}
|
|
|
|
int CCANSignal::ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize)
|
|
{
|
|
if(mEncoding == CAN_SIGNAL_ENCODING_INTEL)
|
|
{
|
|
//Le CAN encode les bytes à l'envers. Il faut faire un miroir des bytes du buffer.
|
|
//Puisque notre CPU est un X86 (little endian) il faut tromper Qt en lui faisant
|
|
//accroire que notre buffer est encodé en Big Endian (ce qui n'est pas le cas).
|
|
//D'où l'appel à qFromBigEndian. Ceci inverse l'ordre des bytes et permet une utilisation
|
|
//simple et directe du buffer.
|
|
mRawValue = qFromBigEndian(NewValue);
|
|
|
|
mRawValue >>= mStartBit;
|
|
quint64 mask = 1;
|
|
mask <<= mSignalSize;
|
|
mask -= 1;
|
|
mRawValue &= mask;
|
|
|
|
}
|
|
else if(mEncoding == CAN_SIGNAL_ENCODING_MOTOROLA)
|
|
{
|
|
mRawValue = NewValue;
|
|
int StartIndex = mStartBit - (mStartBit % 8) + 7 - (mStartBit % 8);
|
|
int shift = ((MessageSize * 8) - StartIndex -1);
|
|
mRawValue >>= shift;
|
|
quint64 mask = 1;
|
|
mask <<= mSignalSize;
|
|
mask -= 1;
|
|
mRawValue &= mask;
|
|
}
|
|
else
|
|
{
|
|
//TODO: À faire!!!
|
|
return RET_GENERAL_ERROR;
|
|
}
|
|
|
|
|
|
//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;
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
this->mRawValue = source.mRawValue;
|
|
this->mPhysicalValue = source.mPhysicalValue;
|
|
|
|
|
|
return *this;
|
|
}
|