serial_communication_thread.cpp

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#include "serial_communication_thread.h"
 
#include "cmdio_util.h"
#include "string_util.h"
 
namespace {
// 無名名前空間.このファイル内でのみ有効.
 
static constexpr int kBaudRate = 9600;  // ボーレート.Arduino側と合わせる.
 
// COMポートの名前.
const std::string kComName[] = {"",
                                "COM1",
                                "COM2",
                                "COM3",
                                "COM4",
                                "COM5",
                                "COM6",
                                "\\\\.\\COM7",
                                "COM8",
                                "COM9",
                                "\\\\.\\COM10",
                                "\\\\.\\COM11",
                                "\\\\.\\COM12",
                                "\\\\.\\COM13"};
}  // namespace
 
namespace designlab {
 
void SerialCommunicationThread::Loop() {
  if (!Initialize()) {
    end_flag_ = true;
 
    // 通信の初期化に失敗した場合は,即座に終了する.
    return;
  }
 
  while (true) {
    Sleep(static_cast<int>(
        1000 * kThreadPeriod));  // 指定した時間だけスリープする.(ミリ秒単位)
 
    // 読み込みを行う.
    if (!Read()) {
      EndThread();
 
      // 読み込みに失敗した場合は,即座に終了する.
      return;
    }
 
    // 書き込みを行う.
    if (!Write()) {
      EndThread();
 
      // 書き込みに失敗した場合は,即座に終了する.
      return;
    }
 
    // スレッドの終了フラグが立っている場合は,即座に終了する.
    if (IsEnd()) {
      return;
    }
  }
}
 
void SerialCommunicationThread::SetWriteData(const std::string& str) {
  // 通信が開始されていない場合は,即座に終了する.
  if (serial_handle_ == INVALID_HANDLE_VALUE) {
    return;
  }
 
  // 書き込みデータを送信する.
  boost::mutex::scoped_lock lock(mutex_);
 
  write_data_ = str;
}
 
std::string SerialCommunicationThread::GetTopReadData() const {
  // スレッドの排他制御を行う.
  boost::mutex::scoped_lock lock(mutex_);
 
  // 読み込みデータが空の場合は,空文字を返す.
  if (read_data_.empty()) {
    return "";
  }
 
  return read_data_.back();
}
 
std::vector<std::string> SerialCommunicationThread::GetAllReadData() const {
  // スレッドの排他制御を行う.
  boost::mutex::scoped_lock lock(mutex_);
 
  return read_data_;
}
 
std::vector<std::string> SerialCommunicationThread::GetReadData(
    const int num) const {
  // スレッドの排他制御を行う.
  boost::mutex::scoped_lock lock(mutex_);
 
  std::vector<std::string> ret;
 
  // 読み込みデータが空の場合は,空の配列を返す.
  if (read_data_.empty()) {
    return ret;
  }
 
  // 読み込みデータが指定した数よりも少ない場合は,全てのデータを返す.
  if (read_data_.size() <= num) {
    return read_data_;
  }
 
  // 読み込みデータが指定した数よりも多い場合は,最新のデータを返す.
  for (int i = 0; i < num; ++i) {
    ret.push_back(read_data_[read_data_.size() - 1 - i]);
  }
 
  return ret;
}
 
bool SerialCommunicationThread::Initialize() {
  // 通信を開始する.Windowsでは CreateFile で COMポートを開く.
  serial_handle_ =
      CreateFile(kComName[kComPortNumber].c_str(), GENERIC_READ | GENERIC_WRITE,
                 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
  if (serial_handle_ == INVALID_HANDLE_VALUE) {
    return false;
  }
 
  // 通信の設定を行う.
  SetupComm(serial_handle_, kBufferSize, kBufferSize);  // バッファーを作る.
  PurgeComm(serial_handle_, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR |
                                PURGE_RXCLEAR);  // バッファーのクリア.
 
  // シリアルポートの設定を行う.
  DCB dcb;
  GetCommState(serial_handle_, &dcb);  // 現在の設定を取得.
 
  dcb.ByteSize = 8;
  dcb.XonChar = 0;
  dcb.XoffChar = 0;
  dcb.EofChar = 4;
  dcb.EvtChar = 10;
  dcb.BaudRate = kBaudRate;
 
  SetCommState(serial_handle_, &dcb);  // 設定を反映.
 
  // タイムアウトの設定を行う.
  COMMTIMEOUTS timeouts;
  GetCommTimeouts(serial_handle_, &timeouts);  // 現在の設定を取得.
 
  timeouts.ReadIntervalTimeout = 100;
  timeouts.ReadTotalTimeoutMultiplier = 100;
  timeouts.ReadTotalTimeoutConstant = 100;
  timeouts.WriteTotalTimeoutMultiplier = 0;
  timeouts.WriteTotalTimeoutConstant = 0;
 
  SetCommTimeouts(serial_handle_, &timeouts);  // 設定を反映.
 
  return true;
}
 
bool SerialCommunicationThread::Read() {
  // 通信が開始されていない場合は,即座に終了する.
  if (serial_handle_ == INVALID_HANDLE_VALUE) {
    return false;
  }
 
  DWORD read_size = 0;
  char read_buffer[kBufferSize] = {0};
 
  if (!ReadFile(serial_handle_, read_buffer, kBufferSize, &read_size, NULL)) {
    // 読み込みに失敗した場合は終了する.
    return false;
  }
 
  if (read_size == 0) {
    // 読み込みデータがない場合は終了する.
    // 読み込み自体は成功しているため,trueを返す.
    return true;
  }
 
  // 読み込んだデータを格納する.
  std::string read_data(read_buffer, read_size);
 
  // 読み込んだデータを改行コードで分割する.
  std::vector<std::string> split_data = string_util::Split(read_data, "\n");
 
  // 分割したデータを読み込みデータに追加する.
  {
    // スレッドの排他制御を行う.
    boost::mutex::scoped_lock lock(mutex_);
 
    for (const auto& data : split_data) {
      // 空文字の場合は追加しない.
      if (data.empty()) {
        continue;
      }
 
      // 読み込みデータに追加する.
      read_data_.push_back(data);
    }
  }
 
  return true;
}
 
bool SerialCommunicationThread::Write() {
  // 通信が開始されていない場合は,即座に終了する.
  if (serial_handle_ == INVALID_HANDLE_VALUE) {
    return false;
  }
 
  // 書き込みデータがない場合は,即座に終了する.
  if (write_data_ == "") {
    return true;
  }
 
  DWORD write_size = 0;
 
  if (!WriteFile(serial_handle_, write_data_.c_str(),
                 static_cast<DWORD>(write_data_.size()), &write_size, NULL)) {
    // 書き込みに失敗した場合は終了する.
    return false;
  }
 
  if (write_size == 0) {
    // 書き込みデータがない場合は終了する.
    // 書き込み自体は成功しているため,trueを返す.
    return true;
  }
 
  // 書き込みデータをクリアする.
  write_data_ = "";
 
  return true;
}
 
}  // namespace designlab