modularization/src/driver/driver_can_kvaser/kvasercan.cpp

#include "kvasercan.h"

#include <QTime>
#include <iostream>

#define BUF_SIZE 1000

long gbaudlist[] = {canBITRATE_10K,canBITRATE_50K,canBITRATE_100K,canBITRATE_125K,
                 canBITRATE_250K,canBITRATE_500K,canBITRATE_1M};

extern iv::Ivfault *gfault;
extern iv::Ivlog *givlog;

kvasercan::kvasercan(int ch1baudindex,int ch2baudindex)
{
    mbaud1 = canBITRATE_500K;
    mbaud2 = canBITRATE_500K;

    if((ch1baudindex>=0)&&(ch1baudindex<=6))
    {
        mbaud1 = gbaudlist[ch1baudindex];
    }

    if((ch2baudindex>=0)&&(ch2baudindex<=6))
    {
        mbaud2 = gbaudlist[ch2baudindex];
    }
}

void kvasercan::run()
{
    canStatus stat;
    mbRunning = false;

    mkvaserch1 = canOpenChannel(0, 0);
    if(mkvaserch1 < 0)
    {
        emit SIG_CANOPENSTATE(false,-1,"open ch1 fail");
        return;
    }

    mkvaserch2 = canOpenChannel(1,0);
    if(mkvaserch2 <0)
    {
        emit SIG_CANOPENSTATE(false,-2,"open ch2 fail");
        return;
    }

    stat = canSetBusParams(mkvaserch1, mbaud1, 0, 0, 0, 0, 0);
    if (stat != canOK) {
        emit SIG_CANOPENSTATE(false,-3,"ch1 SetBusParams fail");
        return;
    }


    stat = canBusOn(mkvaserch1);
    if (stat != canOK) {
        emit SIG_CANOPENSTATE(false,-4,"ch1 Buson fail");
        return;
    }

    stat = canSetBusParams(mkvaserch2, mbaud2, 0, 0, 0, 0, 0);
    if (stat != canOK) {
        emit SIG_CANOPENSTATE(false,-5,"ch2 SetBusParams fail");
        return;
    }

    stat = canBusOn(mkvaserch2);
    if (stat != canOK) {
        emit SIG_CANOPENSTATE(false,-6,"ch2 Buson fail");
        return;
    }

    mbCANOpen = true;
    emit SIG_CANOPENSTATE(true,0,"open can card successfully");

    mkvaserch[0] = mkvaserch1;
    mkvaserch[1] = mkvaserch2;
    int nch;

    int res;

    while((!QThread::isInterruptionRequested())&&(mbCANOpen))
    {


        for(nch=0;nch < 2;nch++)
        {
//            res  = VCI_Receive(4, mnDevNum, nch, receivedata, 2500, 100);

            long id;
            char msgdata[8];
            unsigned int dlc;
            unsigned int flag;
            unsigned long time;
            stat = canRead(mkvaserch[nch],&id,msgdata,&dlc,&flag,&time);

            if(stat == canOK)
            {
   //             qDebug("nch %d id is %x",nch,id);
                mMutex.lock();

                basecan_msg msg;
                msg.id = id;
                //                  msg.isExtern = receivedata[i].ExternFlag;
                msg.isRemote = false;
                msg.nLen = dlc;
                memcpy(msg.data,msgdata,8);
                if(mMsgRecvBuf[nch].size()<BUF_SIZE)
                {
                    mMsgRecvBuf[nch].push_back(msg);
                }

                mMutex.unlock();
            }
            else
            {
                if(stat != canERR_NOMSG)
                {
                    givlog->error("check CAN, CAN Have Error,Error code is %d",(int)stat);
                    gfault->SetFaultState(1, 0, "canErr");
                }
                else
                {
                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
                }

            }

        }

        for(nch =0;nch<2;nch++)
        {
            std::vector<basecan_msg> xMsgSendBuf;
            mMutex.lock();
  //          xMsgSendBuf = mMsgSendBuf[nch];
            int j;
            for(j=0;j<mMsgSendBuf[nch].size();j++)
            {
                xMsgSendBuf.push_back(mMsgSendBuf[nch][j]);
            }

            mMsgSendBuf[nch].clear();
            mMutex.unlock();



            for(j=0;j<xMsgSendBuf.size();j++)
            {
 //               qDebug("%ld ch  is %d ",QDateTime::currentMSecsSinceEpoch(),nch);
//                qDebug("%02x %02x %02x %02x ",xMsgSendBuf[j].data[0],xMsgSendBuf[j].data[1],xMsgSendBuf[j].data[3],
//                        xMsgSendBuf[j].data[4]);
                canWrite(mkvaserch[nch],xMsgSendBuf[j].id,(void *)xMsgSendBuf[j].data,xMsgSendBuf[j].nLen,canMSG_STD);
//                canFlushTransmitQueue(mkvaserch[nch]);
//                qDebug("time is %ld",QDateTime::currentMSecsSinceEpoch());
            }

            xMsgSendBuf.clear();



        }

 //       std::this_thread::sleep_for(std::chrono::milliseconds(1));



    }
}


void kvasercan::startdev()
{
    start();
}

void kvasercan::stopdev()
{
    requestInterruption();
    QTime xTime;
    xTime.start();
    while(xTime.elapsed()<100)
    {
        if(mbRunning == false)
        {
            givlog->warn("can is closed at %d",xTime.elapsed());
            break;
        }
    }
}

int kvasercan::GetMessage(const int nch,basecan_msg *pMsg, const int nCap)
{
    if((nch>1)||(nch < 0))return -1;
    if(mMsgRecvBuf[nch].size() == 0)return 0;

    int nRtn;
    nRtn = nCap;
    mMutex.lock();
    if(nRtn > mMsgRecvBuf[nch].size())nRtn = mMsgRecvBuf[nch].size();
    int i;
    for(i=0;i<nRtn;i++)
    {
        memcpy(&pMsg[i],&(mMsgRecvBuf[nch].at(i)),sizeof(basecan_msg));
    }

    std::vector<basecan_msg>::iterator iter;
    iter = mMsgRecvBuf[nch].begin();
    for(i=0;i<nRtn;i++)
    {
        iter = mMsgRecvBuf[nch].erase(iter);
    }

    mMutex.unlock();

    return nRtn;

}

int kvasercan::SetMessage(const int nch, basecan_msg *pMsg)
{
    if((nch>1)||(nch < 0))return -1;

    if(mMsgSendBuf[nch].size() > BUF_SIZE)return -2;

    mMutex.lock();
    mMsgSendBuf[nch].push_back(*pMsg);
    mMutex.unlock();
    return 0;
}