cl_modbus_tcp_relay::CpModbusRelay Class Reference

Component that handles Modbus coil read/write operations for 8-channel relay. More...

#include <cp_modbus_relay.hpp>

Inheritance diagram for cl_modbus_tcp_relay::CpModbusRelay:

Collaboration diagram for cl_modbus_tcp_relay::CpModbusRelay:

Public Member Functions
	CpModbusRelay ()
virtual	~CpModbusRelay ()
void	onInitialize () override
template<typename TOrthogonal , typename TClient >
void	onStateOrthogonalAllocation ()
	Configure component for event posting during orthogonal allocation.
bool	writeCoil (int channel, bool state)
bool	readCoil (int channel, bool &state)
bool	writeAllCoils (bool state)
bool	writeAllCoils (uint8_t mask)
bool	readAllCoils (uint8_t &states)
template<typename T >
smacc2::SmaccSignalConnection	onWriteSuccess (void(T::*callback)(int, bool), T *object)
template<typename T >
smacc2::SmaccSignalConnection	onWriteFailure (void(T::*callback)(int, const std::string &), T *object)
template<typename T >
smacc2::SmaccSignalConnection	onReadComplete (void(T::*callback)(uint8_t), T *object)
Public Member Functions inherited from smacc2::ISmaccComponent
	ISmaccComponent ()
virtual	~ISmaccComponent ()
virtual std::string	getName () const

Public Attributes
smacc2::SmaccSignal< void(int channel, bool state)>	onWriteSuccess_
smacc2::SmaccSignal< void(int channel, const std::string &error)>	onWriteFailure_
smacc2::SmaccSignal< void(uint8_t states)>	onReadComplete_

Static Public Attributes
static constexpr int	NUM_CHANNELS = 8
static constexpr int	COIL_BASE_ADDRESS = 0x0000

Private Member Functions
int	channelToAddress (int channel) const
bool	isValidChannel (int channel) const

Private Attributes
CpModbusConnection *	connectionComponent_
std::function< void()>	postWriteSuccessEvent_
std::function< void()>	postWriteFailureEvent_

Additional Inherited Members
Protected Member Functions inherited from smacc2::ISmaccComponent
template<typename TOrthogonal , typename TClient >
void	onComponentInitialization ()
template<typename EventType >
void	postEvent (const EventType &ev)
template<typename EventType >
void	postEvent ()
template<typename TOrthogonal , typename TSourceObject >
void	onStateOrthogonalAllocation ()
template<typename TComponent >
void	requiresComponent (TComponent *&requiredComponentStorage, ComponentRequirement requirementType=ComponentRequirement::SOFT)
template<typename TComponent >
void	requiresComponent (std::string name, TComponent *&requiredComponentStorage, ComponentRequirement requirementType=ComponentRequirement::SOFT)
template<typename TClient >
void	requiresClient (TClient *&requiredClientStorage)
template<typename SmaccComponentType , typename TOrthogonal , typename TClient , typename... TArgs>
SmaccComponentType *	createSiblingComponent (TArgs... targs)
template<typename SmaccComponentType , typename TOrthogonal , typename TClient , typename... TArgs>
SmaccComponentType *	createSiblingNamedComponent (std::string name, TArgs... targs)
rclcpp::Node::SharedPtr	getNode ()
rclcpp::Logger	getLogger () const
ISmaccStateMachine *	getStateMachine ()
Protected Attributes inherited from smacc2::ISmaccComponent
ISmaccStateMachine *	stateMachine_
ISmaccClient *	owner_

Detailed Description

Component that handles Modbus coil read/write operations for 8-channel relay.

Responsibilities:

• Write single coil (channel on/off)
• Write all coils simultaneously
• Read single coil status
• Read all coil statuses
• Emit operation result signals

Channel numbering: 1-8 (user-friendly) Coil addresses: 0x0000-0x0007 (0-indexed internally)

Definition at line 51 of file cp_modbus_relay.hpp.

Constructor & Destructor Documentation

CpModbusRelay()

cl_modbus_tcp_relay::CpModbusRelay::CpModbusRelay

(

)

Definition at line 26 of file cp_modbus_relay.cpp.

: connectionComponent_(nullptr) {}

~CpModbusRelay()

cl_modbus_tcp_relay::CpModbusRelay::~CpModbusRelay ( )

virtual

Definition at line 28 of file cp_modbus_relay.cpp.

{}

Member Function Documentation

channelToAddress()

int cl_modbus_tcp_relay::CpModbusRelay::channelToAddress ( int channel ) const

inlineprivate

Definition at line 116 of file cp_modbus_relay.hpp.

{ return COIL_BASE_ADDRESS + (channel - 1); }

References COIL_BASE_ADDRESS.

Referenced by readCoil(), and writeCoil().

Here is the caller graph for this function:

isValidChannel()

bool cl_modbus_tcp_relay::CpModbusRelay::isValidChannel ( int channel ) const

inlineprivate

Definition at line 119 of file cp_modbus_relay.hpp.

{ return channel >= 1 && channel <= NUM_CHANNELS; }

References NUM_CHANNELS.

Referenced by readCoil(), and writeCoil().

Here is the caller graph for this function:

onInitialize()

void cl_modbus_tcp_relay::CpModbusRelay::onInitialize ( )

overridevirtual

Reimplemented from smacc2::ISmaccComponent.

Definition at line 30 of file cp_modbus_relay.cpp.

{
  RCLCPP_INFO(getLogger(), "[CpModbusRelay] Initializing...");
 
  // Require the connection component
  this->requiresComponent(connectionComponent_);
 
  if (!connectionComponent_)
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Failed to get CpModbusConnection component");
  }
  else
  {
    RCLCPP_INFO(getLogger(), "[CpModbusRelay] Initialized with connection component");
  }
}

References connectionComponent_, smacc2::ISmaccComponent::getLogger(), and smacc2::ISmaccComponent::requiresComponent().

Here is the call graph for this function:

onReadComplete()

template<typename T >

smacc2::SmaccSignalConnection cl_modbus_tcp_relay::CpModbusRelay::onReadComplete ( void(T::* callback )(uint8_t), T * object )

inline

Definition at line 104 of file cp_modbus_relay.hpp.

  {
    return this->getStateMachine()->createSignalConnection(onReadComplete_, callback, object);
  }

References smacc2::ISmaccStateMachine::createSignalConnection(), and smacc2::ISmaccComponent::getStateMachine().

Here is the call graph for this function:

onStateOrthogonalAllocation()

template<typename TOrthogonal , typename TClient >

void cl_modbus_tcp_relay::CpModbusRelay::onStateOrthogonalAllocation ( )

inline

Configure component for event posting during orthogonal allocation.

Definition at line 66 of file cp_modbus_relay.hpp.

  {
    postWriteSuccessEvent_ = [this]()
    { this->template postEvent<EvRelayWriteSuccess<CpModbusRelay, TOrthogonal>>(); };
 
    postWriteFailureEvent_ = [this]()
    { this->template postEvent<EvRelayWriteFailure<CpModbusRelay, TOrthogonal>>(); };
  }

References smacc2::ISmaccComponent::postEvent(), postWriteFailureEvent_, and postWriteSuccessEvent_.

Here is the call graph for this function:

onWriteFailure()

template<typename T >

smacc2::SmaccSignalConnection cl_modbus_tcp_relay::CpModbusRelay::onWriteFailure ( void(T::* callback )(int, const std::string &), T * object )

inline

Definition at line 97 of file cp_modbus_relay.hpp.

  {
    return this->getStateMachine()->createSignalConnection(onWriteFailure_, callback, object);
  }

References smacc2::ISmaccStateMachine::createSignalConnection(), and smacc2::ISmaccComponent::getStateMachine().

Here is the call graph for this function:

onWriteSuccess()

template<typename T >

smacc2::SmaccSignalConnection cl_modbus_tcp_relay::CpModbusRelay::onWriteSuccess ( void(T::* callback )(int, bool), T * object )

inline

Definition at line 91 of file cp_modbus_relay.hpp.

  {
    return this->getStateMachine()->createSignalConnection(onWriteSuccess_, callback, object);
  }

References smacc2::ISmaccStateMachine::createSignalConnection(), and smacc2::ISmaccComponent::getStateMachine().

Here is the call graph for this function:

readAllCoils()

bool cl_modbus_tcp_relay::CpModbusRelay::readAllCoils

(

uint8_t &

states

)

Definition at line 183 of file cp_modbus_relay.cpp.

{
  if (!connectionComponent_ || !connectionComponent_->isConnected())
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Not connected to Modbus device");
    return false;
  }
 
  std::lock_guard<std::mutex> lock(connectionComponent_->getMutex());
  modbus_t * ctx = connectionComponent_->getContext();
 
  uint8_t coils[NUM_CHANNELS];
 
  int rc = modbus_read_bits(ctx, COIL_BASE_ADDRESS, NUM_CHANNELS, coils);
 
  if (rc == -1)
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Read all failed: %s", modbus_strerror(errno));
    return false;
  }
 
  // Convert array to bitmask
  states = 0;
  for (int i = 0; i < NUM_CHANNELS; i++)
  {
    if (coils[i])
    {
      states |= (1 << i);
    }
  }
 
  RCLCPP_DEBUG(getLogger(), "[CpModbusRelay] Read all coils: 0x%02X", states);
  onReadComplete_(states);
  return true;
}

References COIL_BASE_ADDRESS, connectionComponent_, cl_modbus_tcp_relay::CpModbusConnection::getContext(), smacc2::ISmaccComponent::getLogger(), cl_modbus_tcp_relay::CpModbusConnection::getMutex(), cl_modbus_tcp_relay::CpModbusConnection::isConnected(), NUM_CHANNELS, and onReadComplete_.

Referenced by cl_modbus_tcp_relay::CbRelayStatus::readAllChannels().

Here is the call graph for this function:

Here is the caller graph for this function:

readCoil()

bool cl_modbus_tcp_relay::CpModbusRelay::readCoil	(	int	channel,
		bool &	state )

Definition at line 94 of file cp_modbus_relay.cpp.

{
  if (!isValidChannel(channel))
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Invalid channel: %d (must be 1-8)", channel);
    return false;
  }
 
  if (!connectionComponent_ || !connectionComponent_->isConnected())
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Not connected to Modbus device");
    return false;
  }
 
  std::lock_guard<std::mutex> lock(connectionComponent_->getMutex());
  modbus_t * ctx = connectionComponent_->getContext();
 
  int address = channelToAddress(channel);
  uint8_t status;
 
  int rc = modbus_read_bits(ctx, address, 1, &status);
 
  if (rc == -1)
  {
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Read failed: %s", modbus_strerror(errno));
    return false;
  }
 
  state = (status != 0);
  RCLCPP_DEBUG(
    getLogger(), "[CpModbusRelay] Read coil %d (channel %d) = %s", address, channel,
    state ? "ON" : "OFF");
  return true;
}

References channelToAddress(), connectionComponent_, cl_modbus_tcp_relay::CpModbusConnection::getContext(), smacc2::ISmaccComponent::getLogger(), cl_modbus_tcp_relay::CpModbusConnection::getMutex(), cl_modbus_tcp_relay::CpModbusConnection::isConnected(), and isValidChannel().

Referenced by cl_modbus_tcp_relay::CbRelayStatus::readSingleChannel().

Here is the call graph for this function:

Here is the caller graph for this function:

writeAllCoils() [1/2]

bool cl_modbus_tcp_relay::CpModbusRelay::writeAllCoils

(

bool

state

)

Definition at line 129 of file cp_modbus_relay.cpp.

{
  // Create a mask with all bits set or cleared
  uint8_t mask = state ? 0xFF : 0x00;
  return writeAllCoils(mask);
}

References writeAllCoils().

Referenced by cl_modbus_tcp_relay::CbAllRelaysOff::onEntry(), cl_modbus_tcp_relay::CbAllRelaysOn::onEntry(), and writeAllCoils().

Here is the call graph for this function:

Here is the caller graph for this function:

writeAllCoils() [2/2]

bool cl_modbus_tcp_relay::CpModbusRelay::writeAllCoils

(

uint8_t

mask

)

Definition at line 136 of file cp_modbus_relay.cpp.

{
  if (!connectionComponent_ || !connectionComponent_->isConnected())
  {
    std::string error = "Not connected to Modbus device";
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] %s", error.c_str());
    onWriteFailure_(0, error);
    if (postWriteFailureEvent_) postWriteFailureEvent_();
    return false;
  }
 
  std::lock_guard<std::mutex> lock(connectionComponent_->getMutex());
  modbus_t * ctx = connectionComponent_->getContext();
 
  // Convert bitmask to array of coil states
  uint8_t coils[NUM_CHANNELS];
  for (int i = 0; i < NUM_CHANNELS; i++)
  {
    coils[i] = (mask & (1 << i)) ? TRUE : FALSE;
  }
 
  RCLCPP_INFO(
    getLogger(), "[CpModbusRelay] Writing all %d coils with mask 0x%02X", NUM_CHANNELS, mask);
 
  int rc = modbus_write_bits(ctx, COIL_BASE_ADDRESS, NUM_CHANNELS, coils);
 
  if (rc == -1)
  {
    std::string error = modbus_strerror(errno);
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Write all failed: %s", error.c_str());
    onWriteFailure_(0, error);
    if (postWriteFailureEvent_) postWriteFailureEvent_();
    return false;
  }
 
  RCLCPP_INFO(getLogger(), "[CpModbusRelay] Write all successful");
 
  // Emit success for each channel that was turned on
  for (int i = 0; i < NUM_CHANNELS; i++)
  {
    bool state = (mask & (1 << i)) != 0;
    onWriteSuccess_(i + 1, state);
  }
  if (postWriteSuccessEvent_) postWriteSuccessEvent_();
  return true;
}

References COIL_BASE_ADDRESS, connectionComponent_, cl_modbus_tcp_relay::CpModbusConnection::getContext(), smacc2::ISmaccComponent::getLogger(), cl_modbus_tcp_relay::CpModbusConnection::getMutex(), cl_modbus_tcp_relay::CpModbusConnection::isConnected(), NUM_CHANNELS, onWriteFailure_, onWriteSuccess_, postWriteFailureEvent_, and postWriteSuccessEvent_.

Here is the call graph for this function:

writeCoil()

bool cl_modbus_tcp_relay::CpModbusRelay::writeCoil	(	int	channel,
		bool	state )

Definition at line 47 of file cp_modbus_relay.cpp.

{
  if (!isValidChannel(channel))
  {
    std::string error = "Invalid channel: " + std::to_string(channel) + " (must be 1-8)";
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] %s", error.c_str());
    onWriteFailure_(channel, error);
    if (postWriteFailureEvent_) postWriteFailureEvent_();
    return false;
  }
 
  if (!connectionComponent_ || !connectionComponent_->isConnected())
  {
    std::string error = "Not connected to Modbus device";
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] %s", error.c_str());
    onWriteFailure_(channel, error);
    if (postWriteFailureEvent_) postWriteFailureEvent_();
    return false;
  }
 
  std::lock_guard<std::mutex> lock(connectionComponent_->getMutex());
  modbus_t * ctx = connectionComponent_->getContext();
 
  int address = channelToAddress(channel);
  int value = state ? TRUE : FALSE;
 
  RCLCPP_INFO(
    getLogger(), "[CpModbusRelay] Writing coil %d (channel %d) = %s", address, channel,
    state ? "ON" : "OFF");
 
  int rc = modbus_write_bit(ctx, address, value);
 
  if (rc == -1)
  {
    std::string error = modbus_strerror(errno);
    RCLCPP_ERROR(getLogger(), "[CpModbusRelay] Write failed: %s", error.c_str());
    onWriteFailure_(channel, error);
    if (postWriteFailureEvent_) postWriteFailureEvent_();
    return false;
  }
 
  RCLCPP_INFO(getLogger(), "[CpModbusRelay] Write successful");
  onWriteSuccess_(channel, state);
  if (postWriteSuccessEvent_) postWriteSuccessEvent_();
  return true;
}

References channelToAddress(), connectionComponent_, cl_modbus_tcp_relay::CpModbusConnection::getContext(), smacc2::ISmaccComponent::getLogger(), cl_modbus_tcp_relay::CpModbusConnection::getMutex(), cl_modbus_tcp_relay::CpModbusConnection::isConnected(), isValidChannel(), onWriteFailure_, onWriteSuccess_, postWriteFailureEvent_, and postWriteSuccessEvent_.

Referenced by cl_modbus_tcp_relay::CbRelayOff::onEntry(), and cl_modbus_tcp_relay::CbRelayOn::onEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

COIL_BASE_ADDRESS

int cl_modbus_tcp_relay::CpModbusRelay::COIL_BASE_ADDRESS = 0x0000

staticconstexpr

Definition at line 55 of file cp_modbus_relay.hpp.

Referenced by channelToAddress(), readAllCoils(), and writeAllCoils().

connectionComponent_

CpModbusConnection* cl_modbus_tcp_relay::CpModbusRelay::connectionComponent_

private

Definition at line 110 of file cp_modbus_relay.hpp.

Referenced by onInitialize(), readAllCoils(), readCoil(), writeAllCoils(), and writeCoil().

NUM_CHANNELS

int cl_modbus_tcp_relay::CpModbusRelay::NUM_CHANNELS = 8

staticconstexpr

Definition at line 54 of file cp_modbus_relay.hpp.

Referenced by isValidChannel(), readAllCoils(), and writeAllCoils().

onReadComplete_

smacc2::SmaccSignal<void(uint8_t states)> cl_modbus_tcp_relay::CpModbusRelay::onReadComplete_

Definition at line 87 of file cp_modbus_relay.hpp.

Referenced by readAllCoils().

onWriteFailure_

smacc2::SmaccSignal<void(int channel, const std::string & error)> cl_modbus_tcp_relay::CpModbusRelay::onWriteFailure_

Definition at line 86 of file cp_modbus_relay.hpp.

Referenced by writeAllCoils(), and writeCoil().

onWriteSuccess_

smacc2::SmaccSignal<void(int channel, bool state)> cl_modbus_tcp_relay::CpModbusRelay::onWriteSuccess_

Definition at line 85 of file cp_modbus_relay.hpp.

Referenced by writeAllCoils(), and writeCoil().

postWriteFailureEvent_

std::function<void()> cl_modbus_tcp_relay::CpModbusRelay::postWriteFailureEvent_

private

Definition at line 113 of file cp_modbus_relay.hpp.

Referenced by onStateOrthogonalAllocation(), writeAllCoils(), and writeCoil().

postWriteSuccessEvent_

std::function<void()> cl_modbus_tcp_relay::CpModbusRelay::postWriteSuccessEvent_

private

Definition at line 112 of file cp_modbus_relay.hpp.

Referenced by onStateOrthogonalAllocation(), writeAllCoils(), and writeCoil().

---

The documentation for this class was generated from the following files:

• smacc2_client_library/cl_modbus_tcp_relay/include/cl_modbus_tcp_relay/components/cp_modbus_relay.hpp
• smacc2_client_library/cl_modbus_tcp_relay/src/cl_modbus_tcp_relay/components/cp_modbus_relay.cpp