1

// IXXAT adapter driver for CanFestival-3 Win32 port

     2

// Copyright (C) 2007 Leonid Tochinski, ChattenAssociates, Inc.

     3

//

     4

// Notes

     5

//--------------------------------------------

     6

// For building of this project you will need 

     7

// the following IXXAT API files

     8

// Vci2.h

     9

// Vci11un6.lib

    10

//

    11

// IXXAT Win32 drivers and API can be downloaded from

    12

// http://www.ixxat.com/download_vci_en,7547,5873.html

    13

//

    14

// Copy Vci2.h & Vci11un6.lib files to can_ixxat_win32 folder of add path to them in Project settings.

    15

    16

#include <stdio.h>

    17

extern "C" {

    18

#include "applicfg.h"

    19

#include "can_driver.h"

    20

#include "def.h"

    21

}

    22

#include "VCI2.h"

    23

#include "async_access_que.h"

    24

    25

#pragma warning(disable:4996)

    26

    27

#define CAN_NUM 0

    28

    29

class IXXAT

    30

   {

    31

   public:

    32

      class error

    33

        {

    34

        };

    35

      IXXAT(s_BOARD *board);

    36

      ~IXXAT();

    37

      bool send(const Message *m);

    38

      bool receive(Message *m);

    39

   private:

    40

      bool open(const char* board_name, int board_number, const char* baud_rate);

    41

      bool close();                             

    42

      void receive_queuedata(UINT16 que_hdl, UINT16 count, VCI_CAN_OBJ* p_obj);

    43

      // VCI2 handler      

    44

      static void VCI_CALLBACKATTR message_handler(char *msg_str);

    45

      static void VCI_CALLBACKATTR receive_queuedata_handler(UINT16 que_hdl, UINT16 count, VCI_CAN_OBJ* p_obj);

    46

      static void VCI_CALLBACKATTR exception_handler(VCI_FUNC_NUM func_num, INT32 err_code, UINT16 ext_err, char* err_str);

    47

    48

   private:

    49

      UINT16 m_BoardHdl;

    50

      UINT16 m_TxQueHdl;

    51

      UINT16 m_RxQueHdl;

    52

      async_access_que<VCI_CAN_OBJ> m_RX_Que;

    53

      static IXXAT* m_callbackPtr;

    54

   };

    55

    56

IXXAT *IXXAT::m_callbackPtr = NULL;

    57

    58

IXXAT::IXXAT(s_BOARD *board) : m_BoardHdl(0xFFFF),

    59

                               m_TxQueHdl(0xFFFF),

    60

                               m_RxQueHdl(0xFFFF)

    61

    62

   {

    63

   char busname[100];

    64

   ::strcpy(busname,board->busname);

    65

   char board_name[100];      

    66

   long board_number = 0;   

    67

   char *ptr = ::strrchr(busname,':');

    68

   if (ptr != 0)

    69

      {

    70

      *ptr = 0;

    71

      ::strcpy(board_name,busname);

    72

      if (++ptr - busname < (int)::strlen(board->busname))

    73

         board_number = ::atoi(ptr);

    74

      }

    75

   if (!open(board_name,board_number,board->baudrate))

    76

      {

    77

      close();

    78

      throw error();

    79

      }

    80

   m_callbackPtr = this;

    81

   }

    82

    83

IXXAT::~IXXAT()

    84

   {

    85

   close();

    86

   m_callbackPtr = 0;

    87

   }

    88

    89

bool IXXAT::send(const Message *m)

    90

   {

    91

   if (m_BoardHdl == 0xFFFF)

    92

      return false;

    93

   long res = VCI_ERR;

    94

   if (m->rtr == NOT_A_REQUEST)

    95

      res = VCI_TransmitObj(m_BoardHdl, m_TxQueHdl, m->cob_id.w, m->len, const_cast<unsigned char*>(m->data));

    96

   else

    97

      res = VCI_RequestObj(m_BoardHdl, m_TxQueHdl, m->cob_id.w, m->len);

    98

   return (res == VCI_OK);   

    99

   }

   100

   101

   102

bool IXXAT::receive(Message *m)

   103

   {

   104

   if (m_BoardHdl == 0xFFFF)

   105

      return false;

   106

   VCI_CAN_OBJ obj;

   107

   if (m_RX_Que.extract_top(obj))

   108

      {

   109

      m->cob_id.w = obj.id;

   110

      m->len = obj.len;

   111

      m->rtr = (obj.rtr == VCI_RX_BUF) ? NOT_A_REQUEST : REQUEST;

   112

      if (m->rtr == NOT_A_REQUEST)

   113

         ::memcpy(m->data, obj.a_data, m->len);

   114

      return true;

   115

      }

   116

   return false;

   117

   }

   118

   119

bool IXXAT::open(const char* board_name, int board_number, const char* baud_rate)

   120

   {

   121

   // check, if baudrate is supported

   122

   struct IXXAT_baud_rate_param 

   123

     { 

   124

     UINT8  bt0; 

   125

     UINT8  bt1;

   126

     };

   127

   struct IXXAT_look_up_table

   128

     {

   129

     char baud_rate[20];

   130

     IXXAT_baud_rate_param bt;

   131

     };

   132

   static const IXXAT_look_up_table br_lut[] = {

   133

               {"10K",{VCI_10KB}},

   134

               {"20K",{VCI_20KB}},

   135

               {"50K",{VCI_50KB}},

   136

               {"100K",{VCI_100KB}},

   137

               {"125K",{VCI_125KB}},

   138

               {"250K",{VCI_250KB}},

   139

               {"500K",{VCI_500KB}},

   140

               {"800K",{VCI_800KB}},

   141

               {"1M",{VCI_1000KB}}

   142

               };

   143

   static const long br_lut_size = sizeof (br_lut)/sizeof(IXXAT_look_up_table);

   144

   int index;

   145

   for (index = 0; index < br_lut_size; ++index)

   146

       {

   147

       if (::strcmp(br_lut[index].baud_rate,baud_rate)==0)

   148

          break;

   149

       }

   150

   if (index == br_lut_size)    

   151

      return false;

   152

   // close existing board   

   153

   close();

   154

   // init IXXAT board

   155

   unsigned long board_type = VCI_GetBrdTypeByName(const_cast<char*>(board_name));

   156

   long res = VCI2_PrepareBoard( board_type,                  // board type

   157

                                   board_number,              // unique board index

   158

                                   NULL,                      // pointer to buffer for additional info 

   159

                                   0,                         // length of additional info buffer

   160

                                   message_handler,           // pointer to msg-callbackhandler

   161

                                   receive_queuedata_handler, // pointer to receive-callbackhandler

   162

                                   exception_handler);        // pointer to exception-callbackhandler

   163

   if (res < 0)

   164

      return false;

   165

   m_BoardHdl = (UINT16)res;

   166

   167

   VCI_ResetBoard(m_BoardHdl);

   168

   169

   // init CAN parameters

   170

   171

   // initialize CAN-Controller

   172

   res = VCI_InitCan(m_BoardHdl, CAN_NUM, br_lut[index].bt.bt0,br_lut[index].bt.bt1, VCI_11B);

   173

   174

   //  definition of Acceptance-Mask (define to receive all IDs)

   175

   res = VCI_SetAccMask(m_BoardHdl, CAN_NUM, 0x0UL, 0x0UL);

   176

   177

   // definition of Transmit Queue

   178

   res = VCI_ConfigQueue(m_BoardHdl, CAN_NUM, VCI_TX_QUE, 100 , 0, 0, 0,  &m_TxQueHdl);

   179

   180

   //  definition of Receive Queue (interrupt mode)

   181

   res = VCI_ConfigQueue(m_BoardHdl, CAN_NUM, VCI_RX_QUE, 50, 1, 0, 100,  &m_RxQueHdl);

   182

   183

   //  assign the all IDs to the Receive Queue

   184

   res = VCI_AssignRxQueObj(m_BoardHdl, m_RxQueHdl ,VCI_ACCEPT, 0, 0) ;

   185

   186

   //  And now start the CAN

   187

   res = VCI_StartCan(m_BoardHdl, CAN_NUM);

   188

   189

   return true;

   190

   }

   191

   192

bool IXXAT::close()

   193

   {

   194

   if (m_BoardHdl == 0xFFFF)

   195

      return true;

   196

   VCI_ResetBoard(m_BoardHdl);   

   197

   VCI_CancelBoard(m_BoardHdl);

   198

   m_BoardHdl = 

   199

   m_TxQueHdl = 

   200

   m_RxQueHdl = 0xFFFF;

   201

   return true;

   202

   }

   203

   204

void IXXAT::receive_queuedata(UINT16 que_hdl, UINT16 count, VCI_CAN_OBJ *p_obj)

   205

   {

   206

   for (int i = 0; i < count; ++i)

   207

       m_RX_Que.append(p_obj[i]); // can packet

   208

   }

   209

   210

void VCI_CALLBACKATTR IXXAT::receive_queuedata_handler(UINT16 que_hdl, UINT16 count, VCI_CAN_OBJ *p_obj)

   211

  {

   212

   if (m_callbackPtr != NULL)

   213

      m_callbackPtr->receive_queuedata(que_hdl, count, p_obj);

   214

  }

   215

   216

void VCI_CALLBACKATTR IXXAT::message_handler(char *msg_str)

   217

  {

   218

  char buf[200];

   219

  ::sprintf(buf,"IXXAT Message: [%s]\n", msg_str);

   220

  ::OutputDebugString(buf);

   221

  }

   222

   223

void VCI_CALLBACKATTR IXXAT::exception_handler(VCI_FUNC_NUM func_num, INT32 err_code, UINT16 ext_err, char* err_str)

   224

  {

   225

  static const char* Num2Function[] =

   226

    {

   227

    "VCI_Init",

   228

    "VCI_Searchboard",

   229

    "VCI_Prepareboard",

   230

    "VCI_Cancel_board",

   231

    "VCI_Testboard",

   232

    "VCI_ReadBoardInfo",

   233

    "VCI_ReadBoardStatus",

   234

    "VCI_Resetboard",

   235

    "VCI_ReadCANInfo",

   236

    "VCI_ReadCANStatus",

   237

    "VCI_InitCAN",

   238

    "VCI_SetAccMask",

   239

    "VCI_ResetCAN",

   240

    "VCI_StartCAN",

   241

    "VCI_ResetTimeStamps",

   242

    "VCI_ConfigQueue",

   243

    "VCI_AssignRxQueObj",

   244

    "VCI_ConfigBuffer",

   245

    "VCI_ReconfigBuffer",

   246

    "VCI_ConfigTimer",

   247

    "VCI_ReadQueStatus",

   248

    "VCI_ReadQueObj",

   249

    "VCI_ReadBufStatus",

   250

    "VCI_ReadBufData",

   251

    "VCI_TransmitObj",

   252

    "VCI_RequestObj",

   253

    "VCI_UpdateBufObj",

   254

    "VCI_CciReqData"

   255

    };

   256

  char buf[200];

   257

  ::sprintf(buf, "IXXAT Exception: %s (%i / %u) [%s]\n", Num2Function[func_num], err_code, ext_err, err_str);

   258

  ::OutputDebugString(buf);

   259

  }

   260

   261

//------------------------------------------------------------------------

   262

extern "C"

   263

   UNS8 canReceive_driver(CAN_HANDLE inst, Message *m)

   264

   {

   265

   return (UNS8)reinterpret_cast<IXXAT*>(inst)->receive(m);

   266

   }

   267

   268

extern "C"

   269

   UNS8 canSend_driver(CAN_HANDLE inst, Message *m)

   270

   {

   271

   return (UNS8)reinterpret_cast<IXXAT*>(inst)->send(m);

   272

   }

   273

   274

extern "C"

   275

   CAN_HANDLE canOpen_driver(s_BOARD *board)

   276

   {

   277

   try

   278

      {

   279

      return new IXXAT(board);

   280

      }

   281

   catch (IXXAT::error&)

   282

      {

   283

      return 0;

   284

      }

   285

   }

   286

   287

extern "C"

   288

   int canClose_driver(CAN_HANDLE inst)

   289

   {

   290

   delete reinterpret_cast<IXXAT*>(inst);

   291

   return 1;

   292

   }