1 // can_uvccm_win32 adapter (http://www.gridconnect.com)

     2 // driver for CanFestival-3 Win32 port

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

     4 

     5 

     6 #include <sstream>

     7 #include <iomanip>

     8 #if 0  // change to 1 if you use boost

     9 #include <boost/algorithm/string/case_conv.hpp>

    10 #else

    11 #include <algorithm>

    12 #endif

    13 

    14 extern "C" {

    15 #include "can_driver.h"

    16 }

    17 class can_uvccm_win32

    18    {

    19    public:

    20       class error

    21         {

    22         };

    23       can_uvccm_win32(s_BOARD *board);

    24       ~can_uvccm_win32();

    25       bool send(const Message *m);

    26       bool receive(Message *m);

    27    private:

    28       bool open_rs232(int port = 1, int baud_rate = 57600);

    29       bool close_rs232();

    30       bool get_can_data(const char* can_cmd_buf, long& bufsize, Message* m);

    31       bool set_can_data(const Message& m, std::string& can_cmd);

    32    private:

    33       HANDLE m_port;

    34       HANDLE m_read_event;

    35       HANDLE m_write_event;

    36       std::string m_residual_buffer;

    37    };

    38 

    39 can_uvccm_win32::can_uvccm_win32(s_BOARD *board) : m_port(INVALID_HANDLE_VALUE),

    40       m_read_event(0),

    41       m_write_event(0)

    42    {

    43    if (strcmp( board->baudrate, "125K") || !open_rs232(1))

    44       throw error();

    45    }

    46 

    47 can_uvccm_win32::~can_uvccm_win32()

    48    {

    49    close_rs232();

    50    }

    51 

    52 bool can_uvccm_win32::send(const Message *m)

    53    {

    54    if (m_port == INVALID_HANDLE_VALUE)

    55       return false;

    56 

    57    // build can_uvccm_win32 command string

    58    std::string can_cmd;

    59    set_can_data(*m, can_cmd);

    60 

    61    OVERLAPPED overlapped;

    62    ::memset(&overlapped, 0, sizeof overlapped);

    63    overlapped.hEvent = m_write_event;

    64    ::ResetEvent(overlapped.hEvent);

    65 

    66    unsigned long bytes_written = 0;

    67    ::WriteFile(m_port, can_cmd.c_str(), (unsigned long)can_cmd.size(), &bytes_written, &overlapped);

    68    // wait for write operation completion

    69    enum { WRITE_TIMEOUT = 1000 };

    70    ::WaitForSingleObject(overlapped.hEvent, WRITE_TIMEOUT);

    71    // get number of bytes written

    72    ::GetOverlappedResult(m_port, &overlapped, &bytes_written, FALSE);

    73 

    74    bool result = (bytes_written == can_cmd.size());

    75 

    76    return result;

    77    }

    78 

    79 

    80 bool can_uvccm_win32::receive(Message *m)

    81    {

    82    if (m_port == INVALID_HANDLE_VALUE)

    83       return false;

    84 

    85    long res_buffer_size = (long)m_residual_buffer.size();

    86    bool result = get_can_data(m_residual_buffer.c_str(), res_buffer_size, m);

    87    if (result)

    88       {

    89       m_residual_buffer.erase(0, res_buffer_size);

    90       return true;

    91       }

    92 

    93    enum { READ_TIMEOUT = 500 };

    94 

    95    OVERLAPPED overlapped;

    96    ::memset(&overlapped, 0, sizeof overlapped);

    97    overlapped.hEvent = m_read_event;

    98    ::ResetEvent(overlapped.hEvent);

    99    unsigned long event_mask = 0;

   100 

   101    if (FALSE == ::WaitCommEvent(m_port, &event_mask, &overlapped) && ERROR_IO_PENDING == ::GetLastError())

   102       {

   103       if (WAIT_TIMEOUT == ::WaitForSingleObject(overlapped.hEvent, READ_TIMEOUT))

   104          return false;

   105       }

   106 

   107    // get number of bytes in the input que

   108    COMSTAT stat;

   109    ::memset(&stat, 0, sizeof stat);

   110    unsigned long errors = 0;

   111    ::ClearCommError(m_port, &errors, &stat);

   112    if (stat.cbInQue == 0)

   113       return false;

   114    char buffer[3000];

   115 

   116    unsigned long bytes_to_read = min(stat.cbInQue, sizeof (buffer));

   117 

   118    unsigned long bytes_read = 0;

   119    ::ReadFile(m_port, buffer, bytes_to_read, &bytes_read, &overlapped);

   120    // wait for read operation completion

   121    ::WaitForSingleObject(overlapped.hEvent, READ_TIMEOUT);

   122    // get number of bytes read

   123    ::GetOverlappedResult(m_port, &overlapped, &bytes_read, FALSE);

   124    result = false;

   125    if (bytes_read > 0)

   126       {

   127       m_residual_buffer.append(buffer, bytes_read);

   128       res_buffer_size = (long)m_residual_buffer.size();

   129       result = get_can_data(m_residual_buffer.c_str(), res_buffer_size, m);

   130       if (result)

   131          m_residual_buffer.erase(0, res_buffer_size);

   132       }

   133    return result;

   134    }

   135 

   136 bool can_uvccm_win32::open_rs232(int port, int baud_rate)

   137    {

   138    if (m_port != INVALID_HANDLE_VALUE)

   139       return true;

   140 

   141    std::ostringstream device_name;

   142    device_name << "COM" << port;

   143 

   144    m_port = ::CreateFile(device_name.str().c_str(),

   145                          GENERIC_READ | GENERIC_WRITE,

   146                          0,   // exclusive access

   147                          NULL,   // no security

   148                          OPEN_EXISTING,

   149                          FILE_FLAG_OVERLAPPED,   // overlapped I/O

   150                          NULL); // null template

   151 

   152    // Check the returned handle for INVALID_HANDLE_VALUE and then set the buffer sizes.

   153    if (m_port == INVALID_HANDLE_VALUE)

   154       return false;

   155 

   156    //  SetCommMask(m_hCom,EV_RXCHAR|EV_TXEMPTY|EV_CTS|EV_DSR|EV_RLSD|EV_BREAK|EV_ERR|EV_RING); //

   157    ::SetCommMask(m_port, EV_RXFLAG);

   158 

   159    COMMTIMEOUTS timeouts;

   160    ::memset(&timeouts, 0, sizeof (timeouts));

   161    timeouts.ReadIntervalTimeout = -1;

   162    timeouts.ReadTotalTimeoutConstant = 0;

   163    timeouts.ReadTotalTimeoutMultiplier = 0;

   164    timeouts.WriteTotalTimeoutConstant = 5000;

   165    timeouts.WriteTotalTimeoutMultiplier = 0;

   166    SetCommTimeouts(m_port, &timeouts); //

   167 

   168    ::SetupComm(m_port, 1024, 512); // set buffer sizes

   169 

   170    // Port settings are specified in a Data Communication Block (DCB). The easiest way to initialize a DCB is to call GetCommState to fill in its default values, override the values that you want to change and then call SetCommState to set the values.

   171    DCB dcb;

   172    ::memset(&dcb, 0, sizeof (dcb));

   173    ::GetCommState(m_port, &dcb);

   174    dcb.BaudRate = baud_rate;

   175    dcb.ByteSize = 8;

   176    dcb.Parity = NOPARITY;

   177    dcb.StopBits = ONESTOPBIT;

   178    dcb.fAbortOnError = TRUE;

   179    dcb.EvtChar = 0x0A; // '\n' character

   180    ::SetCommState(m_port, &dcb);

   181 

   182    ::PurgeComm(m_port, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR);

   183 

   184    m_read_event = ::CreateEvent(NULL, TRUE, FALSE, NULL);

   185    m_write_event = ::CreateEvent(NULL, TRUE, FALSE, NULL);

   186 

   187    return true;

   188    }

   189 

   190 bool can_uvccm_win32::close_rs232()

   191    {

   192    if (m_port != INVALID_HANDLE_VALUE)

   193       {

   194       ::PurgeComm(m_port, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR);

   195       ::CloseHandle(m_port);

   196       m_port = INVALID_HANDLE_VALUE;

   197       ::CloseHandle(m_read_event);

   198       m_read_event = 0;

   199       ::CloseHandle(m_write_event);

   200       m_write_event = 0;

   201       m_residual_buffer.clear();

   202       }

   203    return true;

   204    }

   205 

   206 bool can_uvccm_win32::get_can_data(const char* can_cmd_buf, long& bufsize, Message* m)

   207    {

   208    if (bufsize < 5)

   209       {

   210       bufsize = 0;

   211       return false;

   212       }

   213 

   214    Message msg;

   215    ::memset(&msg, 0 , sizeof (msg));

   216    char colon = 0, type = 0, request = 0;

   217    std::istringstream buf(std::string(can_cmd_buf, bufsize));

   218    buf >> colon >> type >> std::hex >> msg.cob_id.w >> request;

   219    if (colon != ':' || (type != 'S' && type != 'X'))

   220       {

   221       bufsize = 0;

   222       return false;

   223       }

   224    if (request == 'N')

   225       {

   226       msg.rtr = 0;

   227       for (msg.len = 0; msg.len < 8; ++msg.len)

   228          {

   229          std::string data_byte_str;

   230          buf >> std::setw(2) >> data_byte_str;

   231          if (data_byte_str[0] == ';')

   232             break;

   233          long byte_val = -1;

   234          std::istringstream(data_byte_str) >> std::hex >> byte_val;

   235          if (byte_val == -1)

   236             {

   237             bufsize = 0;

   238             return false;

   239             }

   240          msg.data[msg.len] = (UNS8)byte_val;

   241          }

   242       if (msg.len == 8)

   243          {

   244          char semicolon = 0;

   245          buf >> semicolon;

   246          if (semicolon != ';')

   247             {

   248             bufsize = 0;

   249             return false;

   250             }

   251          }

   252 

   253       }

   254    else if (request == 'R')

   255       {

   256       msg.rtr = 1;

   257       buf >> msg.len;

   258       }

   259    else

   260       {

   261       bufsize = 0;

   262       return false;

   263       }

   264 

   265    bufsize = buf.tellg();

   266 

   267    *m = msg;

   268    return true;

   269    }

   270 

   271 bool can_uvccm_win32::set_can_data(const Message& m, std::string& can_cmd)

   272    {

   273    // build can_uvccm_win32 command string

   274    std::ostringstream can_cmd_str;

   275    can_cmd_str << ":S" << std::hex << m.cob_id.w;

   276    if (m.rtr == 1)

   277       {

   278       can_cmd_str << 'R' << (long)m.len;

   279       }

   280    else

   281       {

   282       can_cmd_str << 'N';

   283       for (int i = 0; i < m.len; ++i)

   284          can_cmd_str << std::hex << std::setfill('0') << std::setw(2) << (long)m.data[i];

   285       }

   286    can_cmd_str << ';';

   287    can_cmd = can_cmd_str.str();

   288 #ifdef BOOST_VERSION

   289    boost::to_upper(can_cmd);

   290 #else

   291    std::transform(can_cmd.begin(),can_cmd.end(),can_cmd.begin(),::toupper);

   292 #endif

   293    return true;

   294    }

   295 

   296 

   297 //------------------------------------------------------------------------

   298 extern "C"

   299    UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)

   300    {

   301    return (UNS8)(!(reinterpret_cast<can_uvccm_win32*>(fd0)->receive(m)));

   302    }

   303 

   304 extern "C"

   305    UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)

   306    {

   307    return (UNS8)reinterpret_cast<can_uvccm_win32*>(fd0)->send(m);

   308    }

   309 

   310 extern "C"

   311    CAN_HANDLE canOpen_driver(s_BOARD *board)

   312    {

   313    try

   314       {

   315       return (CAN_HANDLE) new can_uvccm_win32(board);

   316       }

   317    catch (can_uvccm_win32::error&)

   318       {

   319       return NULL;

   320       }

   321    }

   322 

   323 extern "C"

   324    int canClose_driver(CAN_HANDLE inst)

   325    {

   326    delete reinterpret_cast<can_uvccm_win32*>(inst);

   327    return 1;

   328    }

   329 

   330 

   331