YULTek/Otarcik_CAN/Sources/CANBus/CANMessage.cpp

#include "CANMessage.h"
#include "defines.h"
#include <QtEndian>

CCANMessage::CCANMessage():
    mPendingData(false)
{
    mSignalsList.clear();
}

CCANMessage::CCANMessage(const CCANMessage &Src):
    mPendingData(false)
{
    *this = Src;
}

CCANMessage::CCANMessage(const quint32 Channel, const TPCANMsg CANMsg, const TPCANTimestamp CANTimeStamp)
{
    SetDataFromDriver(Channel,CANMsg,CANTimeStamp);
}
CCANMessage::~CCANMessage()
{
//    while (!mSignalsList.isEmpty())
//    {
//          delete mSignalsList.takeFirst();
//    }
}

int CCANMessage::SetDataFromDriver(quint32 Channel, TPCANMsg CANMsg, TPCANTimestamp CANTimeStamp)
{
    mCANChannel = Channel;
    mCANMsgID = (unsigned long long)CANMsg.ID;
    mCANMsgLength = (unsigned char)CANMsg.LEN;
    mCANMsgType = CANMsg.MSGTYPE;
    //mCANMsgData = QByteArray((const char*)&CANMsg.DATA);
    for(unsigned int i = 0; i < mCANMsgLength; i++)
    {
        mCANMsgData.append(CANMsg.DATA[i]);
     }
    mCANMsgMicrosecs = CANTimeStamp.micros;
    mCANMsgMillisecs = CANTimeStamp.millis;
    mCANMsgMillisecsOverflow = CANTimeStamp.millis_overflow;


    return 0;
}

int CCANMessage::AddSignal(CCANSignal *NewSignal)
{
    if(NewSignal == 0)
    {
        return RET_GENERAL_ERROR;
    }

    mSignalsList.append(*NewSignal);
    return RET_OK;
}

int CCANMessage::UpdateValue(CCANMessage *NewDeviceMessage)
{
    if(NewDeviceMessage->mCANMsgID != mCANMsgID)
    {
        qDebug("CCANMEssage error: Trying to update mismatching message ID");
        return RET_GENERAL_ERROR;
    }

    if(NewDeviceMessage->mCANMsgLength != mCANMsgLength)
    {
        qDebug("CCANMessage error: New device message length different than database!!!");
        return RET_GENERAL_ERROR;
    }

    mCANMsgData = QByteArray(NewDeviceMessage->mCANMsgData);

//    if(NewDeviceMessage->mCANMsgID == 0x524)
//        int toto = 5;

    mCANRawDataMotorola = mCANRawDataIntel= 0;

    for(unsigned int i = 0; i < mCANMsgLength; i++)
    {
        mCANRawDataIntel += ((unsigned char)(mCANMsgData[i]) & 0xFF);
        mCANRawDataMotorola += ((unsigned char)(mCANMsgData[(mCANMsgLength - 1) - i]) & 0xFF);

        if(i < mCANMsgLength-1)
        {
            mCANRawDataIntel <<= 8;
            mCANRawDataMotorola <<= 8;
        }
    }

    for(int i = 0; i < mSignalsList.size(); i++)
    {
        mSignalsList[i].ComputeNewSignalValue(mCANRawDataIntel, mCANMsgLength);
    }

    return RET_OK;

}

//This function should be used to set the raw data to send over CAN
//It will do the byte swapping crap and fill the data array
int CCANMessage::SetRawData(quint64 RawData, int Encoding)
{
    if(Encoding != CCANSignal::CAN_SIGNAL_ENCODING_INTEL)
    {
        //MOTOROLA encoding not supported for now...
        return RET_GENERAL_ERROR;
    }

    mCANRawDataIntel = qToLittleEndian(RawData);
 //   mCANRawDataIntel = RawData;


    for(unsigned int i = 0; i < mCANMsgLength; i++)
    {
        unsigned char byte;
        byte = (unsigned char)((mCANRawDataIntel >> (i*8)) & 0xFF);
        mCANMsgData[i] = byte;
    }
}

quint64 CCANMessage::GetRawData()
{
//    return qFromBigEndian(mCANRawDataIntel);
    return mCANRawDataIntel;
}

QDataStream &operator<<(QDataStream &out, const CCANMessage &source)
{
    out << source.mCANChannel
        << source.mCANMsgID
        << source.mCANMsgType
        << source.mCANMsgLength
        << source.mCANMsgData
        << source.mCANMsgMillisecs
        << source.mCANMsgMillisecsOverflow
        << source.mCANMsgMicrosecs;

           return out;
}

QDataStream &operator>>(QDataStream &in, CCANMessage &dest)
{
    in >> dest.mCANChannel
       >> dest.mCANMsgID
       >> dest.mCANMsgType
       >> dest.mCANMsgLength
       >> dest.mCANMsgData
       >> dest.mCANMsgMillisecs
       >> dest.mCANMsgMillisecsOverflow
       >> dest.mCANMsgMicrosecs;

    return in;
}

CCANMessage& CCANMessage::operator=(const CCANMessage &source)
{
    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->mCANMsgName = source.mCANMsgName;
    this->mCANMsgComment = source.mCANMsgComment;
    this->mCANMsgFlags = source.mCANMsgFlags;
    this->mCANRawDataMotorola = source.mCANRawDataMotorola;
    this->mCANRawDataIntel = source.mCANRawDataIntel;
    this->mOwnerDeviceName = source.mOwnerDeviceName;
    this->mSignalsList.clear();
    for(int i = 0; i < source.mSignalsList.size(); i++)
    {
        CCANSignal NewSignal = source.mSignalsList.at(i);
        this->mSignalsList.append(NewSignal);
    }

    return *this;
}