modularization/src/driver/driver_can_vci/vcican.cpp

#include "vcican.h"
#include <QTime>
#include <iostream>


#define VCI_ACCCODE_DEFAULT		0x00000000
#define VCI_ACCMASK_DEFAULT		0xFFFFFFFF
#define VCI_TIMER0_DEFAULT		0x00
#define VCI_TIMER1_DEFAULT		0x1C
#define VCI_FILTER_DEFAULT		1
#define VCI_MODE_DEFAULT		0

//unsigned char gbaudtiming0[] = {0xBF,0x31,0x18,0x87,0x09,0x83,0x04,0x03,0x81,0x01,0x80,0x00,0x80,0x00,0x00};
//unsigned char gbaudtiming1[] = {0xFF,0x1C,0x1C,0xFF,0x1C,0xFF,0x1C,0x1C,0xFA,0x1C,0xFA,0x1C,0xB6,0x16,0x14};


unsigned char gbaudtiming0[] = {0x31,0x09,0x04,0x03,0x01,0x00,0x00};
unsigned char gbaudtiming1[] = {0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x14};

extern iv::Ivfault *mfault;
extern iv::Ivlog *mivlog;


#define BUF_SIZE 1000

#include <QDateTime>

vcican::vcican(int devnum,int nbaudindex,int nch2baudindex )
{

#ifdef IV_WIN
    LoadVCILibrary();

#endif
    mnDevNum = devnum;

    unsigned char timing0,timing1;

     mfault = new iv::Ivfault("can_vci");
     mivlog = new iv::Ivlog("can_vci");

    timing0 = 0x00;
    timing1 = 0x1C;

    if((nbaudindex>=0)&&(nbaudindex<=6))
    {
        timing0 = gbaudtiming0[nbaudindex];
        timing1 = gbaudtiming1[nbaudindex];
    }

    initconfig.AccCode = VCI_ACCCODE_DEFAULT;
    initconfig.AccMask = VCI_ACCMASK_DEFAULT;
    initconfig.Timing0 = timing0;
    initconfig.Timing1 = timing1;
    initconfig.Filter = VCI_FILTER_DEFAULT;
    initconfig.Mode = VCI_MODE_DEFAULT;

    if((nch2baudindex>=0)&&(nch2baudindex<=6))
    {
        timing0 = gbaudtiming0[nch2baudindex];
        timing1 = gbaudtiming1[nch2baudindex];
    }

    initconfig2.AccCode = VCI_ACCCODE_DEFAULT;
    initconfig2.AccMask = VCI_ACCMASK_DEFAULT;
    initconfig2.Timing0 = timing0;
    initconfig2.Timing1 = timing1;
    initconfig2.Filter = VCI_FILTER_DEFAULT;
    initconfig2.Mode = VCI_MODE_DEFAULT;

}

void vcican::run()
{
    mbRunning = true;
    int init;
    int nch;
    int i;
    VCI_CAN_OBJ receivedata[2500];
    int nRecFail = 0;
    int nsend = 0;
    int res;
    int status = VCI_OpenDevice(4,mnDevNum, 0);		//打开设备0
    if(status != 1)
    {
        mivlog->error("open can card fail");
        std::cout<<"open can card fail"<<std::endl;
        mfault->SetFaultState(1, 0, "Open can card fail");
        VCI_CloseDevice(4,mnDevNum);

        emit SIG_CANOPENSTATE(false,-1,"open can card fail");
        goto VCIEND;
    }


    init = VCI_InitCAN(4,mnDevNum,0, &initconfig);	//初始化设备
    if (init == 1)
    {
        if (VCI_StartCAN(4,mnDevNum,0) == 1) {

        }
        else
        {
            VCI_CloseDevice(4,mnDevNum);
            emit SIG_CANOPENSTATE(false,-2,"start ch0 error");
            goto VCIEND;
        }
    }
    else
    {
        VCI_CloseDevice(4,mnDevNum);
        emit SIG_CANOPENSTATE(false,-3,"init ch0 error");
        goto VCIEND;
    }
    init = VCI_InitCAN(4,mnDevNum,1, &initconfig2);	//初始化设备
    if (init == 1)
    {
        if (VCI_StartCAN(4,mnDevNum,1) == 1) {

        }
        else
        {
            VCI_CloseDevice(4,mnDevNum);
            emit SIG_CANOPENSTATE(false,-4,"start ch1 error");
            goto VCIEND;
        }
    }
    else
    {
        VCI_CloseDevice(4,mnDevNum);
        emit SIG_CANOPENSTATE(false,-6,"init ch1 error");
        goto VCIEND;
    }

    VCI_BOARD_INFO xbi;
    VCI_ReadBoardInfo(4,mnDevNum,&xbi);
    strncpy(mstrsn,xbi.str_Serial_Num,100);
//    mivlog->verbose("sn is %s",mstrsn);

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

    std::cout<<"open vci can card successfully."<<std::endl;


//    VCI_BOARD_INFO xinfo;
//    VCI_ReadBoardInfo(4,mnDevNum,&xinfo);
//    if(strcmp(xinfo.str_Serial_Num,"019100007B2") == 0)
//    {
//        std::cout<<"card is ok."<<std::endl;
//    }
//    else
//    {
//        std::cout<<"not this card."<<std::endl;
//    }

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


        for(nch=0;nch < 2;nch++)
        {
            res  = VCI_Receive(4, mnDevNum, nch, receivedata, 2500, 5);
            if(res > 0)
            {
                mivlog->verbose("vci","has data");
                nRecFail = 0;

                mMutex.lock();
                for(i=0;i<res;i++)
                {
                    basecan_msg msg;
                    msg.id = receivedata[i].ID;
                    mivlog->verbose("vci","id %x",msg.id);
                    msg.isExtern = receivedata[i].ExternFlag;
                    msg.isRemote = receivedata[i].RemoteFlag;
                    msg.nLen = receivedata[i].DataLen;
                    memcpy(msg.data,receivedata[i].Data,8);
                    if(mMsgRecvBuf[nch].size()<BUF_SIZE)
                    {
                        mMsgRecvBuf[nch].push_back(msg);
                    }
                }
                mMutex.unlock();
            }
            else
            {
                if(res < 0)nRecFail++;
            }
        }

        for(nch =0;nch<2;nch++)
        {
            nsend = 0;
            mMutex.lock();
  //          qDebug("size  is %d  time is %ld",mMsgSendBuf[nch].size(),QDateTime::currentMSecsSinceEpoch());
            for(i=0;i<mMsgSendBuf[nch].size();i++)
            {
                if(i>=2500)break;
                memcpy(receivedata[i].Data,mMsgSendBuf[nch].at(i).data,8);
                receivedata[i].ID = mMsgSendBuf[nch].at(i).id;
                receivedata[i].ExternFlag = mMsgSendBuf[nch].at(i).isExtern;
                receivedata[i].RemoteFlag = mMsgSendBuf[nch].at(i).isRemote;
                receivedata[i].DataLen = mMsgSendBuf[nch].at(i).nLen;
                nsend++;
            }
            mMsgSendBuf[nch].clear();
//            qDebug("nsend is %d ",nsend);
//            qDebug("size  is %d ",mMsgSendBuf[nch].size());
            mMutex.unlock();
            if(nsend > 0)
            {
                res = VCI_Transmit(4,mnDevNum,nch,receivedata,nsend);
            }

        }

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



    }


    VCI_CloseDevice(4,mnDevNum);
    emit SIG_CANOPENSTATE(false,0,"close can card successfully");

VCIEND:
    mbRunning = false;
}

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

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

char * vcican::GetSerialNum()
{
    return mstrsn;
}

int vcican::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 vcican::SetMessage(const int nch, basecan_msg *pMsg)
{
    if((nch>1)||(nch < 0))return -1;

//    qDebug("send.");

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

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