pilz_modbus_server_mock.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Pilz GmbH & Co. KG
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef PRBT_HARDWARE_SUPPORT_PILZ_MODBUS_SERVER_MOCK_H
#define PRBT_HARDWARE_SUPPORT_PILZ_MODBUS_SERVER_MOCK_H

#include <mutex>
#include <atomic>
#include <cstdint>
#include <vector>
#include <thread>
#include <condition_variable>

#include <modbus/modbus.h>

#include <ros/console.h>

#include "prbt_hardware_support/register_container.h"

namespace prbt_hardware_support
{

class PilzModbusServerMock
{
public:
  PilzModbusServerMock(const unsigned int& holding_register_size);

  ~PilzModbusServerMock();

  void start(const char* ip, const unsigned int port);

  void startAsync(const char* ip, const unsigned int port);

  void setHoldingRegister(std::initializer_list< std::pair<unsigned int, uint16_t> > reg_list);

  void setHoldingRegister(const RegCont& data, unsigned int start_index);

  RegCont readHoldingRegister(const RegCont::size_type start_index,
                              const RegCont::size_type num_reg_to_read);

  void terminate();

  void setTerminateFlag();

  bool init(const char* ip, unsigned int port);

  void run();

private:
  bool shutdownSignalReceived();

private:
  const unsigned int holding_register_size_;
  const unsigned int terminate_register_idx_;

private:

  int socket_ {-1};
  modbus_t *modbus_connection_ {nullptr};
  modbus_mapping_t *mb_mapping_ {nullptr};

  std::atomic_bool terminate_ {false};

  std::mutex modbus_register_access_mutex;

  std::mutex running_mutex_;
  std::condition_variable running_cv_;

  std::thread thread_;

private:
  static constexpr uint32_t DISCONNECT_TIMEOUT_IN_SEC     {1};
  static constexpr uint32_t DISCONNECT_TIMEOUT_IN_USEC    {0};

  static constexpr uint32_t RESPONSE_TIMEOUT_IN_SEC       {0};
  static constexpr uint32_t RESPONSE_TIMEOUT_IN_USEC      {10000};

  static constexpr uint16_t TERMINATE_SIGNAL {1};

};

inline void PilzModbusServerMock::setTerminateFlag()
{
  ROS_INFO_NAMED("ServerMock", "Set terminate to true.");
  terminate_ = true;
}

inline void PilzModbusServerMock::terminate()
{
  ROS_INFO_NAMED("ServerMock", "Terminate called on ServerMock.");
  setTerminateFlag();

  if(thread_.joinable())
  {
    ROS_DEBUG_NAMED("ServerMock", "Waiting for worker Thread of ServerMock to be joined.");
    thread_.join();
    ROS_DEBUG_NAMED("ServerMock", "Waiting for worker Thread of ServerMock joined.");
  }
}

inline bool PilzModbusServerMock::shutdownSignalReceived()
{
  return readHoldingRegister(terminate_register_idx_, 1).back() == TERMINATE_SIGNAL;
}

}
#endif // PRBT_HARDWARE_SUPPORT_PILZ_MODBUS_SERVER_MOCK_H