CanFestival: drivers/can_uvccm_win32/can_uvccm

00001 // can_uvccm_win32 adapter (http://www.gridconnect.com)
+00002 // driver for CanFestival-3 Win32 port
+00003 // Copyright (C) 2007 Leonid Tochinski, ChattenAssociates, Inc.
+00004 
+00005 
+00006 #include <sstream>
+00007 #include <iomanip>
+00008 #if 0  // change to 1 if you use boost
+00009 #include <boost/algorithm/string/case_conv.hpp>
+00010 #else
+00011 #include <algorithm>
+00012 #endif
+00013 
+00014 extern "C" {
+00015 #include "can_driver.h"
+00016 }
+00017 class can_uvccm_win32
+00018    {
+00019    public:
+00020       class error
+00021         {
+00022         };
+00023       can_uvccm_win32(s_BOARD *board);
+00024       ~can_uvccm_win32();
+00025       bool send(const Message *m);
+00026       bool receive(Message *m);
+00027    private:
+00028       bool open_rs232(int port = 1, int baud_rate = 57600);
+00029       bool close_rs232();
+00030       bool get_can_data(const char* can_cmd_buf, long& bufsize, Message* m);
+00031       bool set_can_data(const Message& m, std::string& can_cmd);
+00032    private:
+00033       HANDLE m_port;
+00034       HANDLE m_read_event;
+00035       HANDLE m_write_event;
+00036       std::string m_residual_buffer;
+00037    };
+00038 
+00039 can_uvccm_win32::can_uvccm_win32(s_BOARD *board) : m_port(INVALID_HANDLE_VALUE),
+00040       m_read_event(0),
+00041       m_write_event(0)
+00042    {
+00043    if (strcmp( board->baudrate, "125K") || !open_rs232(1))
+00044       throw error();
+00045    }
+00046 
+00047 can_uvccm_win32::~can_uvccm_win32()
+00048    {
+00049    close_rs232();
+00050    }
+00051 
+00052 bool can_uvccm_win32::send(const Message *m)
+00053    {
+00054    if (m_port == INVALID_HANDLE_VALUE)
+00055       return false;
+00056 
+00057    // build can_uvccm_win32 command string
+00058    std::string can_cmd;
+00059    set_can_data(*m, can_cmd);
+00060 
+00061    OVERLAPPED overlapped;
+00062    ::memset(&overlapped, 0, sizeof overlapped);
+00063    overlapped.hEvent = m_write_event;
+00064    ::ResetEvent(overlapped.hEvent);
+00065 
+00066    unsigned long bytes_written = 0;
+00067    ::WriteFile(m_port, can_cmd.c_str(), (unsigned long)can_cmd.size(), &bytes_written, &overlapped);
+00068    // wait for write operation completion
+00069    enum { WRITE_TIMEOUT = 1000 };
+00070    ::WaitForSingleObject(overlapped.hEvent, WRITE_TIMEOUT);
+00071    // get number of bytes written
+00072    ::GetOverlappedResult(m_port, &overlapped, &bytes_written, FALSE);
+00073 
+00074    bool result = (bytes_written == can_cmd.size());
+00075 
+00076    return result;
+00077    }
+00078 
+00079 
+00080 bool can_uvccm_win32::receive(Message *m)
+00081    {
+00082    if (m_port == INVALID_HANDLE_VALUE)
+00083       return false;
+00084 
+00085    long res_buffer_size = (long)m_residual_buffer.size();
+00086    bool result = get_can_data(m_residual_buffer.c_str(), res_buffer_size, m);
+00087    if (result)
+00088       {
+00089       m_residual_buffer.erase(0, res_buffer_size);
+00090       return true;
+00091       }
+00092 
+00093    enum { READ_TIMEOUT = 500 };
+00094 
+00095    OVERLAPPED overlapped;
+00096    ::memset(&overlapped, 0, sizeof overlapped);
+00097    overlapped.hEvent = m_read_event;
+00098    ::ResetEvent(overlapped.hEvent);
+00099    unsigned long event_mask = 0;
+00100 
+00101    if (FALSE == ::WaitCommEvent(m_port, &event_mask, &overlapped) && ERROR_IO_PENDING == ::GetLastError())
+00102       {
+00103       if (WAIT_TIMEOUT == ::WaitForSingleObject(overlapped.hEvent, READ_TIMEOUT))
+00104          return false;
+00105       }
+00106 
+00107    // get number of bytes in the input que
+00108    COMSTAT stat;
+00109    ::memset(&stat, 0, sizeof stat);
+00110    unsigned long errors = 0;
+00111    ::ClearCommError(m_port, &errors, &stat);
+00112    if (stat.cbInQue == 0)
+00113       return false;
+00114    char buffer[3000];
+00115 
+00116    unsigned long bytes_to_read = min(stat.cbInQue, sizeof (buffer));
+00117 
+00118    unsigned long bytes_read = 0;
+00119    ::ReadFile(m_port, buffer, bytes_to_read, &bytes_read, &overlapped);
+00120    // wait for read operation completion
+00121    ::WaitForSingleObject(overlapped.hEvent, READ_TIMEOUT);
+00122    // get number of bytes read
+00123    ::GetOverlappedResult(m_port, &overlapped, &bytes_read, FALSE);
+00124    result = false;
+00125    if (bytes_read > 0)
+00126       {
+00127       m_residual_buffer.append(buffer, bytes_read);
+00128       res_buffer_size = (long)m_residual_buffer.size();
+00129       result = get_can_data(m_residual_buffer.c_str(), res_buffer_size, m);
+00130       if (result)
+00131          m_residual_buffer.erase(0, res_buffer_size);
+00132       }
+00133    return result;
+00134    }
+00135 
+00136 bool can_uvccm_win32::open_rs232(int port, int baud_rate)
+00137    {
+00138    if (m_port != INVALID_HANDLE_VALUE)
+00139       return true;
+00140 
+00141    std::ostringstream device_name;
+00142    device_name << "COM" << port;
+00143 
+00144    m_port = ::CreateFile(device_name.str().c_str(),
+00145                          GENERIC_READ | GENERIC_WRITE,
+00146                          0,   // exclusive access
+00147                          NULL,   // no security
+00148                          OPEN_EXISTING,
+00149                          FILE_FLAG_OVERLAPPED,   // overlapped I/O
+00150                          NULL); // null template
+00151 
+00152    // Check the returned handle for INVALID_HANDLE_VALUE and then set the buffer sizes.
+00153    if (m_port == INVALID_HANDLE_VALUE)
+00154       return false;
+00155 
+00156    //  SetCommMask(m_hCom,EV_RXCHAR|EV_TXEMPTY|EV_CTS|EV_DSR|EV_RLSD|EV_BREAK|EV_ERR|EV_RING); //
+00157    ::SetCommMask(m_port, EV_RXFLAG);
+00158 
+00159    COMMTIMEOUTS timeouts;
+00160    ::memset(&timeouts, 0, sizeof (timeouts));
+00161    timeouts.ReadIntervalTimeout = -1;
+00162    timeouts.ReadTotalTimeoutConstant = 0;
+00163    timeouts.ReadTotalTimeoutMultiplier = 0;
+00164    timeouts.WriteTotalTimeoutConstant = 5000;
+00165    timeouts.WriteTotalTimeoutMultiplier = 0;
+00166    SetCommTimeouts(m_port, &timeouts); //
+00167 
+00168    ::SetupComm(m_port, 1024, 512); // set buffer sizes
+00169 
+00170    // 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.
+00171    DCB dcb;
+00172    ::memset(&dcb, 0, sizeof (dcb));
+00173    ::GetCommState(m_port, &dcb);
+00174    dcb.BaudRate = baud_rate;
+00175    dcb.ByteSize = 8;
+00176    dcb.Parity = NOPARITY;
+00177    dcb.StopBits = ONESTOPBIT;
+00178    dcb.fAbortOnError = TRUE;
+00179    dcb.EvtChar = 0x0A; // '\n' character
+00180    ::SetCommState(m_port, &dcb);
+00181 
+00182    ::PurgeComm(m_port, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR);
+00183 
+00184    m_read_event = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+00185    m_write_event = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+00186 
+00187    return true;
+00188    }
+00189 
+00190 bool can_uvccm_win32::close_rs232()
+00191    {
+00192    if (m_port != INVALID_HANDLE_VALUE)
+00193       {
+00194       ::PurgeComm(m_port, PURGE_RXABORT | PURGE_RXCLEAR | PURGE_TXABORT | PURGE_TXCLEAR);
+00195       ::CloseHandle(m_port);
+00196       m_port = INVALID_HANDLE_VALUE;
+00197       ::CloseHandle(m_read_event);
+00198       m_read_event = 0;
+00199       ::CloseHandle(m_write_event);
+00200       m_write_event = 0;
+00201       m_residual_buffer.clear();
+00202       }
+00203    return true;
+00204    }
+00205 
+00206 bool can_uvccm_win32::get_can_data(const char* can_cmd_buf, long& bufsize, Message* m)
+00207    {
+00208    if (bufsize < 5)
+00209       {
+00210       bufsize = 0;
+00211       return false;
+00212       }
+00213 
+00214    Message msg;
+00215    ::memset(&msg, 0 , sizeof (msg));
+00216    char colon = 0, type = 0, request = 0;
+00217    std::istringstream buf(std::string(can_cmd_buf, bufsize));
+00218    buf >> colon >> type >> std::hex >> msg.cob_id.w >> request;
+00219    if (colon != ':' || (type != 'S' && type != 'X'))
+00220       {
+00221       bufsize = 0;
+00222       return false;
+00223       }
+00224    if (request == 'N')
+00225       {
+00226       msg.rtr = 0;
+00227       for (msg.len = 0; msg.len < 8; ++msg.len)
+00228          {
+00229          std::string data_byte_str;
+00230          buf >> std::setw(2) >> data_byte_str;
+00231          if (data_byte_str[0] == ';')
+00232             break;
+00233          long byte_val = -1;
+00234          std::istringstream(data_byte_str) >> std::hex >> byte_val;
+00235          if (byte_val == -1)
+00236             {
+00237             bufsize = 0;
+00238             return false;
+00239             }
+00240          msg.data[msg.len] = (UNS8)byte_val;
+00241          }
+00242       if (msg.len == 8)
+00243          {
+00244          char semicolon = 0;
+00245          buf >> semicolon;
+00246          if (semicolon != ';')
+00247             {
+00248             bufsize = 0;
+00249             return false;
+00250             }
+00251          }
+00252 
+00253       }
+00254    else if (request == 'R')
+00255       {
+00256       msg.rtr = 1;
+00257       buf >> msg.len;
+00258       }
+00259    else
+00260       {
+00261       bufsize = 0;
+00262       return false;
+00263       }
+00264 
+00265    bufsize = buf.tellg();
+00266 
+00267    *m = msg;
+00268    return true;
+00269    }
+00270 
+00271 bool can_uvccm_win32::set_can_data(const Message& m, std::string& can_cmd)
+00272    {
+00273    // build can_uvccm_win32 command string
+00274    std::ostringstream can_cmd_str;
+00275    can_cmd_str << ":S" << std::hex << m.cob_id.w;
+00276    if (m.rtr == 1)
+00277       {
+00278       can_cmd_str << 'R' << (long)m.len;
+00279       }
+00280    else
+00281       {
+00282       can_cmd_str << 'N';
+00283       for (int i = 0; i < m.len; ++i)
+00284          can_cmd_str << std::hex << std::setfill('0') << std::setw(2) << (long)m.data[i];
+00285       }
+00286    can_cmd_str << ';';
+00287    can_cmd = can_cmd_str.str();
+00288 #ifdef BOOST_VERSION
+00289    boost::to_upper(can_cmd);
+00290 #else
+00291    std::transform(can_cmd.begin(),can_cmd.end(),can_cmd.begin(),::toupper);
+00292 #endif
+00293    return true;
+00294    }
+00295 
+00296 
+00297 //------------------------------------------------------------------------
+00298 extern "C"
+00299    UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)
+00300    {
+00301    return (UNS8)(!(reinterpret_cast<can_uvccm_win32*>(fd0)->receive(m)));
+00302    }
+00303 
+00304 extern "C"
+00305    UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)
+00306    {
+00307    return (UNS8)reinterpret_cast<can_uvccm_win32*>(fd0)->send(m);
+00308    }
+00309 
+00310 extern "C"
+00311    CAN_HANDLE canOpen_driver(s_BOARD *board)
+00312    {
+00313    try
+00314       {
+00315       return (CAN_HANDLE) new can_uvccm_win32(board);
+00316       }
+00317    catch (can_uvccm_win32::error&)
+00318       {
+00319       return NULL;
+00320       }
+00321    }
+00322 
+00323 extern "C"
+00324    int canClose_driver(CAN_HANDLE inst)
+00325    {
+00326    delete reinterpret_cast<can_uvccm_win32*>(inst);
+00327    return 1;
+00328    }
+00329 
+00330 
+00331    
+
can_uvccm_win32.cpp
