view/connection/SerialCtrl_win.cpp

/*!
  \file
  \brief シリアル接続 (Windows)

  \author Satofumi KAMIMURA
  \author Tomoaki YOSHIDA

  $Id$
*/

#include "SerialCtrl.h"
#include "RingBuffer.h"
#include <errno.h>
#include <windows.h>

using namespace beego;


/*!
  \brief SerialCtrl の内部クラス
*/
struct SerialCtrl::pImpl {
  std::string error_message;
  RingBuffer<char> ring_buffer;
  HANDLE hComm;

  pImpl(void) : error_message("Not connected."), hComm(INVALID_HANDLE_VALUE) {
  }

  ~pImpl(void) {
    disconnect();
  }

  void disconnect(void) {
    if (hComm != INVALID_HANDLE_VALUE) {
      CloseHandle(hComm);
      hComm = INVALID_HANDLE_VALUE;
    }
  }

  bool changeBaudrate(long baudrate) {

    DCB dcb;
    GetCommState(hComm, &dcb);
    dcb.BaudRate = baudrate;
    dcb.ByteSize = 8;
    dcb.Parity = NOPARITY;
    dcb.fParity = FALSE;
    dcb.StopBits = ONESTOPBIT;
    SetCommState(hComm, &dcb);

    return true;
  }

  void update(int timeout, int size = 0) {

    int filled = 0;
    int readable_size = 0;

    // 存在するデータの読み出し
    enum { BufferSize = 1024 };
    char data[BufferSize];

    do {
      DWORD dwErrors;
      COMSTAT ComStat;
      ClearCommError(hComm, &dwErrors, &ComStat);
      readable_size = (int)ComStat.cbInQue;
      int read_n = (readable_size > BufferSize) ? BufferSize : readable_size;

      DWORD n;
      ReadFile(hComm, data, read_n, &n, NULL);
      ring_buffer.put(data, n);

      filled += n;
      readable_size -= n;

      if (filled >= size) {
        return;
      }
    } while (readable_size > 0);

    if (timeout > 0) {
      // 受信タイムアウトを評価しつつ、データ受信を行う
      COMMTIMEOUTS pcto;
      GetCommTimeouts(hComm, &pcto);
      pcto.ReadIntervalTimeout = 0;
      pcto.ReadTotalTimeoutMultiplier = 0;
      pcto.ReadTotalTimeoutConstant = timeout;
      SetCommTimeouts(hComm, &pcto);

      // データの読み出しは、１文字ずつ行う
      DWORD n;
      while (1) {
        ReadFile(hComm, data, 1, &n, NULL);
        if (n < 1) {
          return;
        }
        ring_buffer.put(data, n);
        filled += n;
        if (filled >= size) {
          return;
        }
      }
    }
  }
};


SerialCtrl::SerialCtrl(void) : pimpl(new pImpl) {
}


SerialCtrl::~SerialCtrl(void) {
}


const char* SerialCtrl::what(void) {
  return pimpl->error_message.c_str();
}


bool SerialCtrl::connect(const char* device, long baudrate) {

  // 接続
  if (strlen(device) >= 6) {
    // 無効なデバイス名とみなす
    // !!! エラー状態を更新すべき
    return false;
  }
  char adjust_device[16];
  sprintf(adjust_device, "\\\\.\\%s", device);
  pimpl->hComm = CreateFileA(adjust_device, GENERIC_READ | GENERIC_WRITE, 0,
                            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

  if (pimpl->hComm == INVALID_HANDLE_VALUE) {
#if 0
    LPVOID lpMsg;
    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                  FORMAT_MESSAGE_FROM_SYSTEM |
                  FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL, GetLastError(),
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR)&lpMsg, 0, NULL);
#endif
    char buffer[256];

    //DWORD error = GetLastError();
    // !!! lpMsg の使い方を確認し、いずれ取り込む
    //sprintf(buffer, "port(%s) open failed: %s\n", device); //, lpMsg);
    sprintf(buffer, "port(%s) open failed\n", device); //, lpMsg);
    pimpl->error_message = buffer;
    //LocalFree(lpMsg);
    return false;
  }

  // ボーレート設定
  bool ret = pimpl->changeBaudrate(baudrate);
  if (ret == false) {
    return false;
  }
  pimpl->error_message = "no error";

  return true;
}


void SerialCtrl::disconnect(void) {
  pimpl->disconnect();
}


bool SerialCtrl::isConnected(void) {
  return (pimpl->hComm == INVALID_HANDLE_VALUE) ? false : true;
}


bool SerialCtrl::changeBaudrate(long baudrate) {
  return pimpl->changeBaudrate(baudrate);
}


int SerialCtrl::send(const char* data, int size) {
  if (isConnected() == false) {
    return 0;
  }

  DWORD n;
  WriteFile(pimpl->hComm, data, size, &n, NULL);
  return n;
}


int SerialCtrl::recv(char* data, int size, int timeout) {
  if ((isConnected() == false) || (size <= 0)) {
    return 0;
  }

  // 要求分だけ受信データがあれば、返す
  int filled = SerialCtrl::size();
  if (filled >= size) {
    pimpl->ring_buffer.get(data, size);
    return size;
  }

  // 受信できたデータを返す
  int left = size - filled;
  pimpl->update(timeout, left);

  // size() を呼ぶと update(0) が呼ばれるため
  filled = pimpl->ring_buffer.size();
  pimpl->ring_buffer.get(data, filled);

  return filled;
}


int SerialCtrl::size(int timeout) {
  pimpl->update(timeout);
  return pimpl->ring_buffer.size();
}


void SerialCtrl::clear(void) {
  pimpl->update(0);
  pimpl->ring_buffer.clear();
}


void SerialCtrl::skip(int timeout) {
  clear();

  char buffer[BUFSIZ];
  int total = 0;
  int n;

  enum { EachTimeout = 10 };
  do {
    n = recv(buffer, BUFSIZ, EachTimeout);
    total += EachTimeout;
  } while ((n > 0) && ((timeout > 0) && (total < timeout)));
}


void SerialCtrl::flush(void) {
  FlushFileBuffers(pimpl->hComm);
}