source: pacpussensors/trunk/CanGateway/driver/KVaserCanDriver.cpp@ 134

/// @date created 2015/06/23
/// @author Gerald Dherbomez
/// @version $Id$

#include "KVaserCanDriver.h"
/*
#ifdef WIN32
#include "kvaser/windows/canlib.h"
#else
#include "kvaser/linux/canlib.h"
#endif
*/


#include <canlib.h>

#include <cassert>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <string>
#include <string.h>

#include "Pacpus/kernel/Log.h"
#include "../CanFrame.h"

using namespace pacpus;
using namespace std;

DECLARE_STATIC_LOGGER("pacpussensors.CanGateway.KVaserCanDriver");

#define WAIT_RECEIVING_FRAME_TIMEOUT 1000

/*
#define RX_QUEUE_SIZE 4096
#define QUEUE_LEVEL 1

bool checkXlStatus(const XLstatus status) {
        if ( status != XL_SUCCESS ) {
                XLstringType error = xlGetErrorString(status);
                LOG_ERROR(error);
                return false;
        } else {
                return true;
        }

}
*/
//
// Check a status code and issue an error message if the code isn't canOK.
//
void ErrorExit(string id, canStatus stat)
{
    char buf[50];
    if (stat != canOK) {
        buf[0] = '\0';
        canGetErrorText(stat, buf, sizeof(buf));
        LOG_ERROR(id << ": failed, stat=" << (int)stat << " (" << buf << ")");
        //exit(1);
    }
}

/**
* Constructor which enables to initialize the different attributes of the class with default values.
* @see ~KVaserCanDriver (void)
*/

KVaserCanDriver::KVaserCanDriver(int channel, unsigned int bitRate)
{
  LOG_INFO("Notice : KVASER CAN Driver used\n");
  canChannel_ = channel;
  canBitRate_ = bitRate;
  kvaserHardwareType_ = 0;
}


/**
* Constructor which enables to initialize the different attributes of the class with default values.
* @see ~KVaserCanDriver (void)
* @see KVaserCanDriver (unsigned int gHwTypeT, Vaccess gChannelMaskT, unsigned int gCanIdT, unsigned int gBitRateT,int gHwChannelT)
*/

KVaserCanDriver::KVaserCanDriver (void)
{
  LOG_INFO("Notice : KVASER CAN Driver used\n");
  canChannel_ = 0;
  canBitRate_ = 500000;
  kvaserHardwareType_ = 0;
}

/**
* Constructor which enables to initialize the different attributes of the class with values given in parameters.
* @see ~KVaserCanDriver (void)
* @see KVaserCanDriver (void)
*/
KVaserCanDriver::KVaserCanDriver(const int hwType, const int hwChannel, const unsigned long bitrate)
{
  canChannel_ = hwChannel;
  canBitRate_ = bitrate;
  kvaserHardwareType_ = hwType;
}


/**
* Constructor which enables to select the channel and to initialize the different attributes of the class with default values..
* @see ~KVaserCanDriver (void)
* @see KVaserCanDriver (void)
*/

KVaserCanDriver::KVaserCanDriver(int channel)
{
  LOG_INFO("Notice : KVASER CAN Driver used\n");
  canChannel_ = channel;
  canBitRate_ = 500000;
  kvaserHardwareType_ = 0;
}



/**
* Destructor which clean up the different attributs of the class.
* @see KVaserCanDriver (void)
*/
KVaserCanDriver::~KVaserCanDriver (void)
{

}



void KVaserCanDriver::displayHardware()
{
        LOG_INFO("----------------------------------------------------------");
        LOG_INFO("KVASER DRIVER HARDWARE INFORMATION -- TODO");
        LOG_INFO("KVASER DRIVER VERSION: 5_11_931 ");
        LOG_INFO("----------------------------------------------------------");
}


void KVaserCanDriver::initialize(const int hwType, const int hwChannel, const unsigned long bitrate)
{
  LOG_INFO("Notice : KVASER CAN Driver used\n");
  displayHardware();

  canHandle_ = canOpenChannel(hwChannel, 0);
    if (canHandle_ < 0) {
        ErrorExit("canOpenChannel", (canStatus) canHandle_);
    }
        else
        {
                int ret = 0;
                switch (bitrate)
                {
                        case 125000:
                                ret = canSetBusParams(canHandle_, canBITRATE_125K, 0, 0, 0, 0, 0);
                                break;
                        case 250000:
                                ret = canSetBusParams(canHandle_, canBITRATE_250K, 0, 0, 0, 0, 0);
                                break;
                        case 500000:
                                ret = canSetBusParams(canHandle_, canBITRATE_500K, 4, 3, 1, 1, 0);
                                break;
                        default:
                                ret = canERR_NOTFOUND;
                                break;
                }
                if (ret < 0) {
                        ErrorExit("canSetBusParams", (canStatus)ret);
                }

                ret = canBusOn(canHandle_);
                if (ret < 0) {
                        ErrorExit("canBusOn", (canStatus)ret);

                }
        }
}


/**
* Member used to initialise the configuration of the CAN Card.
* @see cleanUpPort (void)
* @return a Vstatus variable which contain the error code of the function. On success, it return VSUCCESS. On failure, it return Vstatus error code which is defined in VCanD.h
*/
short KVaserCanDriver::initPort (void)
{
#ifdef WIN32
    // Initialize CANLIB.
    //
    canInitializeLibrary();
#endif

        // open the physical CAN interface
        initialize(kvaserHardwareType_, canChannel_, canBitRate_);

        return 0;
}


/**
* Member used to clean up the configuration of the CAN Card.
* @see initPort (void)
* @return a Vstatus variable which contain the error code of the function. On success, it return VSUCCESS. On failure, it return Vstatus error code which is defined in VCanD.h
*/
short KVaserCanDriver::cleanUpPort (void)
{

        //traceXLCommand("xlCloseDriver", xlCloseDriver());

        canBusOff(canHandle_);
        canClose(canHandle_);

        return 0;
}


/**
* Member which permit to send a frame on the CAN bus and test if the frame is well acknowledged.
*/
short KVaserCanDriver::sendFrame (struct CanFrame frame)
{
        canStatus stat = canWrite(canHandle_, frame.id,frame.data, frame.dlc, 0);
        if (stat == canOK )
        {
                return 0;
        } else {
                LOG_WARN("Kvaser driver - sendFrame method - Failed to send the CAN frame");
                return 1;
        }
}


/**
* Member which permit to receive of a frame on the CAN bus.
*/
//Vstatus KVaserCanDriver::receiveFrame (unsigned char * flags, unsigned char * dlc, unsigned char * data, int * identifiant)
short KVaserCanDriver::receiveFrame (struct CanFrame &frame)
{
        long id;
        unsigned int dlc, flags;
        unsigned char msg[8];
        //DWORD timestamp;
        unsigned long timestamp;

        canStatus stat = canReadWait(canHandle_, &id, msg, &dlc, &flags, &timestamp, WAIT_RECEIVING_FRAME_TIMEOUT);
        if (stat == canOK )
        {
                if ((flags & canMSG_ERROR_FRAME) == 0)
                {
                        // Get the message data
                        /*fprintf(f, "%8lu%c%c%c%c  %02lu ",
                                id,
                                flags & canMSG_EXT        ? 'x' : ' ',
                                flags & canMSG_RTR        ? 'R' : ' ',
                                flags & canMSGERR_OVERRUN ? 'o' : ' ',
                                flags & canMSG_NERR       ? 'N' : ' ', // TJA 1053/1054 transceivers only
                                dlc);*/
                        frame.id = id;
                        frame.dlc = dlc;
                        memcpy(frame.data, msg, frame.dlc);
                        return 0;
                }
        }
        else if (stat == canERR_NOMSG ) {
                        // timeout occurs
                        LOG_WARN("Kvaser card - receiveFrame() method - TIMEOUT");
                        return 1;
        }
        else {
                        // An error frame.
                        LOG_WARN("Kvaser card, error frame");
                        return 1;
        }


        return 1;
}


/**
* Member which wait the reception of a frame on the CAN bus.
* @see sendFrame (unsigned char flags, unsigned char dlc, unsigned char * data)
* @see receiveFrame (unsigned char * flags, unsigned char * dlc, unsigned char ** data)
*/
void KVaserCanDriver::waitReceivingFrame(void)
{
        LOG_WARN("KVASER driver - waitReceivingFrame(void) method - Not yet implemented");
}