1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack. 

     3

     4

CanFestival Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

CanFestival Win32 port Copyright (C) 2007 Leonid Tochinski, ChattenAssociates, Inc.

     6

     7

See COPYING file for copyrights details.

     8

     9

This library is free software; you can redistribute it and/or

    10

modify it under the terms of the GNU Lesser General Public

    11

License as published by the Free Software Foundation; either

    12

version 2.1 of the License, or (at your option) any later version.

    13

    14

This library is distributed in the hope that it will be useful,

    15

but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17

Lesser General Public License for more details.

    18

    19

You should have received a copy of the GNU Lesser General Public

    20

License along with this library; if not, write to the Free Software

    21

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    22

*/

    23

    24

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

    25

// driver for CanFestival-3 Win32 port

    26

    27

#include <sstream>

    28

#include <iomanip>

    29

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

    30

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

    31

#else

    32

#include <algorithm>

    33

#endif

    34

    35

extern "C" {

    36

#include "can_driver.h"

    37

}

    38

class can_uvccm_win32

    39

   {

    40

   public:

    41

      class error

    42

        {

    43

        };

    44

      can_uvccm_win32(s_BOARD *board);

    45

      ~can_uvccm_win32();

    46

      bool send(const Message *m);

    47

      bool receive(Message *m);

    48

   private:

    49

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

    50

      bool close_rs232();

    51

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

    52

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

    53

   private:

    54

      HANDLE m_port;

    55

      HANDLE m_read_event;

    56

      HANDLE m_write_event;

    57

      std::string m_residual_buffer;

    58

   };

    59

    60

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

    61

      m_read_event(0),

    62

      m_write_event(0)

    63

   {

    64

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

    65

      throw error();

    66

   }

    67

    68

can_uvccm_win32::~can_uvccm_win32()

    69

   {

    70

   close_rs232();

    71

   }

    72

    73

bool can_uvccm_win32::send(const Message *m)

    74

   {

    75

   if (m_port == INVALID_HANDLE_VALUE)

    76

      return true;

    77

    78

   // build can_uvccm_win32 command string

    79

   std::string can_cmd;

    80

   set_can_data(*m, can_cmd);

    81

    82

   OVERLAPPED overlapped;

    83

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

    84

   overlapped.hEvent = m_write_event;

    85

   ::ResetEvent(overlapped.hEvent);

    86

    87

   unsigned long bytes_written = 0;

    88

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

    89

   // wait for write operation completion

    90

   enum { WRITE_TIMEOUT = 1000 };

    91

   ::WaitForSingleObject(overlapped.hEvent, WRITE_TIMEOUT);

    92

   // get number of bytes written

    93

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

    94

    95

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

    96

    97

   return false;

    98

   }

    99

   100

   101

bool can_uvccm_win32::receive(Message *m)

   102

   {

   103

   if (m_port == INVALID_HANDLE_VALUE)

   104

      return false;

   105

   106

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

   107

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

   108

   if (result)

   109

      {

   110

      m_residual_buffer.erase(0, res_buffer_size);

   111

      return true;

   112

      }

   113

   114

   enum { READ_TIMEOUT = 500 };

   115

   116

   OVERLAPPED overlapped;

   117

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

   118

   overlapped.hEvent = m_read_event;

   119

   ::ResetEvent(overlapped.hEvent);

   120

   unsigned long event_mask = 0;

   121

   122

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

   123

      {

   124

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

   125

         return false;

   126

      }

   127

   128

   // get number of bytes in the input que

   129

   COMSTAT stat;

   130

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

   131

   unsigned long errors = 0;

   132

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

   133

   if (stat.cbInQue == 0)

   134

      return false;

   135

   char buffer[3000];

   136

   137

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

   138

   139

   unsigned long bytes_read = 0;

   140

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

   141

   // wait for read operation completion

   142

   ::WaitForSingleObject(overlapped.hEvent, READ_TIMEOUT);

   143

   // get number of bytes read

   144

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

   145

   result = false;

   146

   if (bytes_read > 0)

   147

      {

   148

      m_residual_buffer.append(buffer, bytes_read);

   149

      res_buffer_size = (long)m_residual_buffer.size();

   150

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

   151

      if (result)

   152

         m_residual_buffer.erase(0, res_buffer_size);

   153

      }

   154

   return result;

   155

   }

   156

   157

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

   158

   {

   159

   if (m_port != INVALID_HANDLE_VALUE)

   160

      return true;

   161

   162

   std::ostringstream device_name;

   163

   device_name << "COM" << port;

   164

   165

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

   166

                         GENERIC_READ | GENERIC_WRITE,

   167

                         0,   // exclusive access

   168

                         NULL,   // no security

   169

                         OPEN_EXISTING,

   170

                         FILE_FLAG_OVERLAPPED,   // overlapped I/O

   171

                         NULL); // null template

   172

   173

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

   174

   if (m_port == INVALID_HANDLE_VALUE)

   175

      return false;

   176

   177

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

   178

   ::SetCommMask(m_port, EV_RXFLAG);

   179

   180

   COMMTIMEOUTS timeouts;

   181

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

   182

   timeouts.ReadIntervalTimeout = -1;

   183

   timeouts.ReadTotalTimeoutConstant = 0;

   184

   timeouts.ReadTotalTimeoutMultiplier = 0;

   185

   timeouts.WriteTotalTimeoutConstant = 5000;

   186

   timeouts.WriteTotalTimeoutMultiplier = 0;

   187

   SetCommTimeouts(m_port, &timeouts); //

   188

   189

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

   190

   191

   // 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.

   192

   DCB dcb;

   193

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

   194

   ::GetCommState(m_port, &dcb);

   195

   dcb.BaudRate = baud_rate;

   196

   dcb.ByteSize = 8;

   197

   dcb.Parity = NOPARITY;

   198

   dcb.StopBits = ONESTOPBIT;

   199

   dcb.fAbortOnError = TRUE;

   200

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

   201

   ::SetCommState(m_port, &dcb);

   202

   203

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

   204

   205

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

   206

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

   207

   208

   return true;

   209

   }

   210

   211

bool can_uvccm_win32::close_rs232()

   212

   {

   213

   if (m_port != INVALID_HANDLE_VALUE)

   214

      {

   215

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

   216

      ::CloseHandle(m_port);

   217

      m_port = INVALID_HANDLE_VALUE;

   218

      ::CloseHandle(m_read_event);

   219

      m_read_event = 0;

   220

      ::CloseHandle(m_write_event);

   221

      m_write_event = 0;

   222

      m_residual_buffer.clear();

   223

      }

   224

   return true;

   225

   }

   226

   227

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

   228

   {

   229

   if (bufsize < 5)

   230

      {

   231

      bufsize = 0;

   232

      return false;

   233

      }

   234

   235

   Message msg;

   236

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

   237

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

   238

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

   239

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

   240

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

   241

      {

   242

      bufsize = 0;

   243

      return false;

   244

      }

   245

   if (request == 'N')

   246

      {

   247

      msg.rtr = 0;

   248

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

   249

         {

   250

         std::string data_byte_str;

   251

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

   252

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

   253

            break;

   254

         long byte_val = -1;

   255

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

   256

         if (byte_val == -1)

   257

            {

   258

            bufsize = 0;

   259

            return false;

   260

            }

   261

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

   262

         }

   263

      if (msg.len == 8)

   264

         {

   265

         char semicolon = 0;

   266

         buf >> semicolon;

   267

         if (semicolon != ';')

   268

            {

   269

            bufsize = 0;

   270

            return false;

   271

            }

   272

         }

   273

   274

      }

   275

   else if (request == 'R')

   276

      {

   277

      msg.rtr = 1;

   278

      buf >> msg.len;

   279

      }

   280

   else

   281

      {

   282

      bufsize = 0;

   283

      return false;

   284

      }

   285

   286

   bufsize = buf.tellg();

   287

   288

   *m = msg;

   289

   return true;

   290

   }

   291

   292

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

   293

   {

   294

   // build can_uvccm_win32 command string

   295

   std::ostringstream can_cmd_str;

   296

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

   297

   if (m.rtr == 1)

   298

      {

   299

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

   300

      }

   301

   else

   302

      {

   303

      can_cmd_str << 'N';

   304

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

   305

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

   306

      }

   307

   can_cmd_str << ';';

   308

   can_cmd = can_cmd_str.str();

   309

#ifdef BOOST_VERSION

   310

   boost::to_upper(can_cmd);

   311

#else

   312

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

   313

#endif

   314

   return true;

   315

   }

   316

   317

   318

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

   319

extern "C"

   320

   UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)

   321

   {

   322

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

   323

   }

   324

   325

extern "C"

   326

   UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)

   327

   {

   328

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

   329

   }

   330

   331

extern "C"

   332

   CAN_HANDLE canOpen_driver(s_BOARD *board)

   333

   {

   334

   try

   335

      {

   336

      return (CAN_HANDLE) new can_uvccm_win32(board);

   337

      }

   338

   catch (can_uvccm_win32::error&)

   339

      {

   340

      return NULL;

   341

      }

   342

   }

   343

   344

extern "C"

   345

   int canClose_driver(CAN_HANDLE inst)

   346

   {

   347

   delete reinterpret_cast<can_uvccm_win32*>(inst);

   348

   return 1;

   349

   }

   350

   351

   352