ros2_canopen  master
C++ ROS CANopen Library
node_canopen_402_driver_impl.hpp
Go to the documentation of this file.
1 // Copyright 2023 Christoph Hellmann Santos
2 // Vishnuprasad Prachandabhanu
3 // Lovro Ivanov
4 //
5 // This program is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program. If not, see <https://www.gnu.org/licenses/>.
17 //
18 
19 #ifndef NODE_CANOPEN_402_DRIVER_IMPL_HPP_
20 #define NODE_CANOPEN_402_DRIVER_IMPL_HPP_
21 
24 
25 #include <optional>
26 
27 using namespace ros2_canopen::node_interfaces;
28 using namespace std::placeholders;
29 
30 template <class NODETYPE>
32 : ros2_canopen::node_interfaces::NodeCanopenProxyDriver<NODETYPE>(node)
33 {
34 }
35 
36 template <class NODETYPE>
37 void NodeCanopen402Driver<NODETYPE>::init(bool called_from_base)
38 {
39  RCLCPP_ERROR(this->node_->get_logger(), "Not init implemented.");
40 }
41 
42 template <>
43 void NodeCanopen402Driver<rclcpp::Node>::init(bool called_from_base)
44 {
46  publish_joint_state =
47  this->node_->create_publisher<sensor_msgs::msg::JointState>("~/joint_states", 1);
48  handle_init_service = this->node_->create_service<std_srvs::srv::Trigger>(
49  std::string(this->node_->get_name()).append("/init").c_str(),
50  std::bind(
51  &NodeCanopen402Driver<rclcpp::Node>::handle_init, this, std::placeholders::_1,
52  std::placeholders::_2));
53 
54  handle_halt_service = this->node_->create_service<std_srvs::srv::Trigger>(
55  std::string(this->node_->get_name()).append("/halt").c_str(),
56  std::bind(
57  &NodeCanopen402Driver<rclcpp::Node>::handle_halt, this, std::placeholders::_1,
58  std::placeholders::_2));
59 
60  handle_recover_service = this->node_->create_service<std_srvs::srv::Trigger>(
61  std::string(this->node_->get_name()).append("/recover").c_str(),
62  std::bind(
63  &NodeCanopen402Driver<rclcpp::Node>::handle_recover, this, std::placeholders::_1,
64  std::placeholders::_2));
65 
66  handle_set_mode_position_service = this->node_->create_service<std_srvs::srv::Trigger>(
67  std::string(this->node_->get_name()).append("/position_mode").c_str(),
68  std::bind(
70  std::placeholders::_2));
71 
72  handle_set_mode_velocity_service = this->node_->create_service<std_srvs::srv::Trigger>(
73  std::string(this->node_->get_name()).append("/velocity_mode").c_str(),
74  std::bind(
76  std::placeholders::_2));
77 
78  handle_set_mode_cyclic_velocity_service = this->node_->create_service<std_srvs::srv::Trigger>(
79  std::string(this->node_->get_name()).append("/cyclic_velocity_mode").c_str(),
80  std::bind(
82  std::placeholders::_1, std::placeholders::_2));
83 
84  handle_set_mode_cyclic_position_service = this->node_->create_service<std_srvs::srv::Trigger>(
85  std::string(this->node_->get_name()).append("/cyclic_position_mode").c_str(),
86  std::bind(
88  std::placeholders::_1, std::placeholders::_2));
89 
90  handle_set_mode_interpolated_position_service =
91  this->node_->create_service<std_srvs::srv::Trigger>(
92  std::string(this->node_->get_name()).append("/interpolated_position_mode").c_str(),
93  std::bind(
95  std::placeholders::_1, std::placeholders::_2));
96 
97  handle_set_mode_torque_service = this->node_->create_service<std_srvs::srv::Trigger>(
98  std::string(this->node_->get_name()).append("/torque_mode").c_str(),
99  std::bind(
101  std::placeholders::_2));
102 
103  handle_set_target_service = this->node_->create_service<canopen_interfaces::srv::COTargetDouble>(
104  std::string(this->node_->get_name()).append("/target").c_str(),
105  std::bind(
106  &NodeCanopen402Driver<rclcpp::Node>::handle_set_target, this, std::placeholders::_1,
107  std::placeholders::_2));
108 }
109 
110 template <>
112 {
114  publish_joint_state =
115  this->node_->create_publisher<sensor_msgs::msg::JointState>("~/joint_states", 10);
116  handle_init_service = this->node_->create_service<std_srvs::srv::Trigger>(
117  std::string(this->node_->get_name()).append("/init").c_str(),
118  std::bind(
120  std::placeholders::_1, std::placeholders::_2));
121 
122  handle_halt_service = this->node_->create_service<std_srvs::srv::Trigger>(
123  std::string(this->node_->get_name()).append("/halt").c_str(),
124  std::bind(
126  std::placeholders::_1, std::placeholders::_2));
127 
128  handle_recover_service = this->node_->create_service<std_srvs::srv::Trigger>(
129  std::string(this->node_->get_name()).append("/recover").c_str(),
130  std::bind(
132  std::placeholders::_1, std::placeholders::_2));
133 
134  handle_set_mode_position_service = this->node_->create_service<std_srvs::srv::Trigger>(
135  std::string(this->node_->get_name()).append("/position_mode").c_str(),
136  std::bind(
138  std::placeholders::_1, std::placeholders::_2));
139 
140  handle_set_mode_velocity_service = this->node_->create_service<std_srvs::srv::Trigger>(
141  std::string(this->node_->get_name()).append("/velocity_mode").c_str(),
142  std::bind(
144  std::placeholders::_1, std::placeholders::_2));
145 
146  handle_set_mode_cyclic_velocity_service = this->node_->create_service<std_srvs::srv::Trigger>(
147  std::string(this->node_->get_name()).append("/cyclic_velocity_mode").c_str(),
148  std::bind(
150  std::placeholders::_1, std::placeholders::_2));
151 
152  handle_set_mode_cyclic_position_service = this->node_->create_service<std_srvs::srv::Trigger>(
153  std::string(this->node_->get_name()).append("/cyclic_position_mode").c_str(),
154  std::bind(
156  std::placeholders::_1, std::placeholders::_2));
157 
158  handle_set_mode_interpolated_position_service = this->node_->create_service<
159  std_srvs::srv::Trigger>(
160  std::string(this->node_->get_name()).append("/interpolated_position_mode").c_str(),
161  std::bind(
163  this, std::placeholders::_1, std::placeholders::_2));
164 
165  handle_set_mode_torque_service = this->node_->create_service<std_srvs::srv::Trigger>(
166  std::string(this->node_->get_name()).append("/torque_mode").c_str(),
167  std::bind(
169  std::placeholders::_1, std::placeholders::_2));
170 
171  handle_set_target_service = this->node_->create_service<canopen_interfaces::srv::COTargetDouble>(
172  std::string(this->node_->get_name()).append("/target").c_str(),
173  std::bind(
175  std::placeholders::_1, std::placeholders::_2));
176 }
177 
178 template <>
180 {
182  std::optional<double> scale_pos_to_dev;
183  std::optional<double> scale_pos_from_dev;
184  std::optional<double> scale_vel_to_dev;
185  std::optional<double> scale_vel_from_dev;
186  std::optional<int> switching_state;
187  try
188  {
189  scale_pos_to_dev = std::optional(this->config_["scale_pos_to_dev"].as<double>());
190  }
191  catch (...)
192  {
193  }
194  try
195  {
196  scale_pos_from_dev = std::optional(this->config_["scale_pos_from_dev"].as<double>());
197  }
198  catch (...)
199  {
200  }
201  try
202  {
203  scale_vel_to_dev = std::optional(this->config_["scale_vel_to_dev"].as<double>());
204  }
205  catch (...)
206  {
207  }
208  try
209  {
210  scale_vel_from_dev = std::optional(this->config_["scale_vel_from_dev"].as<double>());
211  }
212  catch (...)
213  {
214  }
215  try
216  {
217  switching_state = std::optional(this->config_["switching_state"].as<int>());
218  }
219  catch (...)
220  {
221  }
222 
223  // auto period = this->config_["scale_eff_to_dev"].as<double>();
224  // auto period = this->config_["scale_eff_from_dev"].as<double>();
225  scale_pos_to_dev_ = scale_pos_to_dev.value_or(1000.0);
226  scale_pos_from_dev_ = scale_pos_from_dev.value_or(0.001);
227  scale_vel_to_dev_ = scale_vel_to_dev.value_or(1000.0);
228  scale_vel_from_dev_ = scale_vel_from_dev.value_or(0.001);
229  switching_state_ = (ros2_canopen::State402::InternalState)switching_state.value_or(
230  (int)ros2_canopen::State402::InternalState::Operation_Enable);
231  RCLCPP_INFO(
232  this->node_->get_logger(),
233  "scale_pos_to_dev_ %f\nscale_pos_from_dev_ %f\nscale_vel_to_dev_ %f\nscale_vel_from_dev_ %f\n",
234  scale_pos_to_dev_, scale_pos_from_dev_, scale_vel_to_dev_, scale_vel_from_dev_);
235 }
236 
237 template <>
238 void NodeCanopen402Driver<rclcpp::Node>::configure(bool called_from_base)
239 {
241  std::optional<double> scale_pos_to_dev;
242  std::optional<double> scale_pos_from_dev;
243  std::optional<double> scale_vel_to_dev;
244  std::optional<double> scale_vel_from_dev;
245  std::optional<int> switching_state;
246  try
247  {
248  scale_pos_to_dev = std::optional(this->config_["scale_pos_to_dev"].as<double>());
249  }
250  catch (...)
251  {
252  }
253  try
254  {
255  scale_pos_from_dev = std::optional(this->config_["scale_pos_from_dev"].as<double>());
256  }
257  catch (...)
258  {
259  }
260  try
261  {
262  scale_vel_to_dev = std::optional(this->config_["scale_vel_to_dev"].as<double>());
263  }
264  catch (...)
265  {
266  }
267  try
268  {
269  scale_vel_from_dev = std::optional(this->config_["scale_vel_from_dev"].as<double>());
270  }
271  catch (...)
272  {
273  }
274  try
275  {
276  switching_state = std::optional(this->config_["switching_state"].as<int>());
277  }
278  catch (...)
279  {
280  }
281 
282  // auto period = this->config_["scale_eff_to_dev"].as<double>();
283  // auto period = this->config_["scale_eff_from_dev"].as<double>();
284  scale_pos_to_dev_ = scale_pos_to_dev.value_or(1000.0);
285  scale_pos_from_dev_ = scale_pos_from_dev.value_or(0.001);
286  scale_vel_to_dev_ = scale_vel_to_dev.value_or(1000.0);
287  scale_vel_from_dev_ = scale_vel_from_dev.value_or(0.001);
288  switching_state_ = (ros2_canopen::State402::InternalState)switching_state.value_or(
289  (int)ros2_canopen::State402::InternalState::Operation_Enable);
290  RCLCPP_INFO(
291  this->node_->get_logger(),
292  "scale_pos_to_dev_ %f\nscale_pos_from_dev_ %f\nscale_vel_to_dev_ %f\nscale_vel_from_dev_ %f\n",
293  scale_pos_to_dev_, scale_pos_from_dev_, scale_vel_to_dev_, scale_vel_from_dev_);
294 }
295 
296 template <class NODETYPE>
297 void NodeCanopen402Driver<NODETYPE>::activate(bool called_from_base)
298 {
300  motor_->registerDefaultModes();
301  motor_->set_diagnostic_status_msgs(this->diagnostic_collector_, this->diagnostic_enabled_);
302 }
303 
304 template <class NODETYPE>
306 {
308  timer_->cancel();
309 }
310 
311 template <class NODETYPE>
313 {
315  motor_->handleRead();
316  motor_->handleWrite();
317  publish();
318 }
319 
320 template <class NODETYPE>
322 {
323  sensor_msgs::msg::JointState js_msg;
324  js_msg.name.push_back(this->node_->get_name());
325  js_msg.position.push_back(motor_->get_position() * scale_pos_from_dev_);
326  js_msg.velocity.push_back(motor_->get_speed() * scale_vel_from_dev_);
327  js_msg.effort.push_back(0.0);
328  publish_joint_state->publish(js_msg);
329 }
330 
331 template <class NODETYPE>
333 {
335  motor_ = std::make_shared<Motor402>(this->lely_driver_, switching_state_);
336 }
337 
338 template <class NODETYPE>
340  const std_srvs::srv::Trigger::Request::SharedPtr request,
341  std_srvs::srv::Trigger::Response::SharedPtr response)
342 {
343  if (this->activated_.load())
344  {
345  bool temp = motor_->handleInit();
346  response->success = temp;
347  }
348 }
349 template <class NODETYPE>
351  const std_srvs::srv::Trigger::Request::SharedPtr request,
352  std_srvs::srv::Trigger::Response::SharedPtr response)
353 {
354  if (this->activated_.load())
355  {
356  response->success = motor_->handleRecover();
357  }
358 }
359 template <class NODETYPE>
361  const std_srvs::srv::Trigger::Request::SharedPtr request,
362  std_srvs::srv::Trigger::Response::SharedPtr response)
363 {
364  if (this->activated_.load())
365  {
366  response->success = motor_->handleHalt();
367  }
368 }
369 template <class NODETYPE>
371  const std_srvs::srv::Trigger::Request::SharedPtr request,
372  std_srvs::srv::Trigger::Response::SharedPtr response)
373 {
374  response->success = set_mode_position();
375 }
376 
377 template <class NODETYPE>
379  const std_srvs::srv::Trigger::Request::SharedPtr request,
380  std_srvs::srv::Trigger::Response::SharedPtr response)
381 {
382  response->success = set_mode_velocity();
383 }
384 
385 template <class NODETYPE>
387  const std_srvs::srv::Trigger::Request::SharedPtr request,
388  std_srvs::srv::Trigger::Response::SharedPtr response)
389 {
390  response->success = set_mode_cyclic_position();
391 }
392 
393 template <class NODETYPE>
395  const std_srvs::srv::Trigger::Request::SharedPtr request,
396  std_srvs::srv::Trigger::Response::SharedPtr response)
397 {
398  response->success = set_mode_interpolated_position();
399 }
400 
401 template <class NODETYPE>
403  const std_srvs::srv::Trigger::Request::SharedPtr request,
404  std_srvs::srv::Trigger::Response::SharedPtr response)
405 {
406  response->success = set_mode_cyclic_velocity();
407 }
408 template <class NODETYPE>
410  const std_srvs::srv::Trigger::Request::SharedPtr request,
411  std_srvs::srv::Trigger::Response::SharedPtr response)
412 {
413  response->success = set_mode_torque();
414 }
415 
416 template <class NODETYPE>
418  const canopen_interfaces::srv::COTargetDouble::Request::SharedPtr request,
419  canopen_interfaces::srv::COTargetDouble::Response::SharedPtr response)
420 {
421  if (this->activated_.load())
422  {
423  auto mode = motor_->getMode();
424  double target;
425  if (
428  {
429  target = request->target * scale_pos_to_dev_;
430  }
431  else if (
432  (mode == MotorBase::Velocity) or (mode == MotorBase::Profiled_Velocity) or
434  {
435  target = request->target * scale_vel_to_dev_;
436  }
437  else
438  {
439  target = request->target;
440  }
441 
442  response->success = motor_->setTarget(target);
443  }
444 }
445 
446 template <class NODETYPE>
448 {
449  if (this->activated_.load())
450  {
451  bool temp = motor_->handleInit();
452  return temp;
453  }
454  else
455  {
456  RCLCPP_INFO(this->node_->get_logger(), "Initialisation failed.");
457  return false;
458  }
459 }
460 
461 template <class NODETYPE>
463 {
464  if (this->activated_.load())
465  {
466  return motor_->handleRecover();
467  }
468  else
469  {
470  return false;
471  }
472 }
473 
474 template <class NODETYPE>
476 {
477  if (this->activated_.load())
478  {
479  return motor_->handleHalt();
480  }
481  else
482  {
483  return false;
484  }
485 }
486 
487 template <class NODETYPE>
489 {
490  if (this->activated_.load())
491  {
492  return motor_->enterModeAndWait(mode);
493  }
494  return false;
495 }
496 
497 template <class NODETYPE>
499 {
500  if (this->activated_.load())
501  {
502  if (motor_->getMode() != MotorBase::Profiled_Position)
503  {
504  return motor_->enterModeAndWait(MotorBase::Profiled_Position);
505  }
506  else
507  {
508  return false;
509  }
510  }
511  else
512  {
513  return false;
514  }
515 }
516 
517 template <class NODETYPE>
519 {
520  if (this->activated_.load())
521  {
522  if (motor_->getMode() != MotorBase::Interpolated_Position)
523  {
524  return motor_->enterModeAndWait(MotorBase::Interpolated_Position);
525  }
526  else
527  {
528  return false;
529  }
530  }
531  else
532  {
533  return false;
534  }
535 }
536 
537 template <class NODETYPE>
539 {
540  if (this->activated_.load())
541  {
542  if (motor_->getMode() != MotorBase::Profiled_Velocity)
543  {
544  return motor_->enterModeAndWait(MotorBase::Profiled_Velocity);
545  }
546  else
547  {
548  return false;
549  }
550  }
551  else
552  {
553  return false;
554  }
555 }
556 
557 template <class NODETYPE>
559 {
560  if (this->activated_.load())
561  {
562  if (motor_->getMode() != MotorBase::Cyclic_Synchronous_Position)
563  {
564  return motor_->enterModeAndWait(MotorBase::Cyclic_Synchronous_Position);
565  }
566  else
567  {
568  return false;
569  }
570  }
571  else
572  {
573  return false;
574  }
575 }
576 
577 template <class NODETYPE>
579 {
580  if (this->activated_.load())
581  {
582  if (motor_->getMode() != MotorBase::Cyclic_Synchronous_Velocity)
583  {
584  return motor_->enterModeAndWait(MotorBase::Cyclic_Synchronous_Velocity);
585  }
586  else
587  {
588  return false;
589  }
590  }
591  else
592  {
593  return false;
594  }
595 }
596 
597 template <class NODETYPE>
599 {
600  if (this->activated_.load())
601  {
602  if (motor_->getMode() != MotorBase::Profiled_Torque)
603  {
604  return motor_->enterModeAndWait(MotorBase::Profiled_Torque);
605  }
606  else
607  {
608  return false;
609  }
610  }
611  else
612  {
613  return false;
614  }
615 }
616 
617 template <class NODETYPE>
619 {
620  if (this->activated_.load())
621  {
622  auto mode = motor_->getMode();
623  double scaled_target;
624  if (
627  {
628  scaled_target = target * scale_pos_to_dev_;
629  }
630  else if (
631  (mode == MotorBase::Velocity) or (mode == MotorBase::Profiled_Velocity) or
633  {
634  scaled_target = target * scale_vel_to_dev_;
635  }
636  else
637  {
638  scaled_target = target;
639  }
640  // RCLCPP_INFO(this->node_->get_logger(), "Scaled target %f", scaled_target);
641  return motor_->setTarget(scaled_target);
642  }
643  else
644  {
645  return false;
646  }
647 }
648 
649 template <class NODETYPE>
651  diagnostic_updater::DiagnosticStatusWrapper & stat)
652 {
653  this->motor_->handleDiag();
654 
655  stat.summary(this->diagnostic_collector_->getLevel(), this->diagnostic_collector_->getMessage());
656  stat.add("device_state", this->diagnostic_collector_->getValue("DEVICE"));
657  stat.add("nmt_state", this->diagnostic_collector_->getValue("NMT"));
658  stat.add("emcy_state", this->diagnostic_collector_->getValue("EMCY"));
659  stat.add("cia402_mode", this->diagnostic_collector_->getValue("cia402_mode"));
660  stat.add("cia402_state", this->diagnostic_collector_->getValue("cia402_state"));
661 }
662 
663 #endif
@ Profiled_Velocity
Definition: base.hpp:42
@ Cyclic_Synchronous_Velocity
Definition: base.hpp:48
@ Cyclic_Synchronous_Position
Definition: base.hpp:47
@ Profiled_Position
Definition: base.hpp:40
@ Profiled_Torque
Definition: base.hpp:43
@ Interpolated_Position
Definition: base.hpp:46
@ Velocity
Definition: base.hpp:41
InternalState
Definition: state.hpp:50
Definition: node_canopen_402_driver.hpp:35
void handle_set_mode_cyclic_velocity(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set cyclic velocity mode.
Definition: node_canopen_402_driver_impl.hpp:402
void handle_halt(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to halt device.
Definition: node_canopen_402_driver_impl.hpp:360
void handle_init(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to initialise device.
Definition: node_canopen_402_driver_impl.hpp:339
bool set_target(double target)
Method to set target.
Definition: node_canopen_402_driver_impl.hpp:618
bool set_mode_velocity()
Method to set profiled velocity mode.
Definition: node_canopen_402_driver_impl.hpp:538
bool set_mode_torque()
Method to set profiled torque mode.
Definition: node_canopen_402_driver_impl.hpp:598
void handle_set_target(const canopen_interfaces::srv::COTargetDouble::Request::SharedPtr request, canopen_interfaces::srv::COTargetDouble::Response::SharedPtr response)
Service Callback to set target.
Definition: node_canopen_402_driver_impl.hpp:417
void handle_set_mode_velocity(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set profiled velocity mode.
Definition: node_canopen_402_driver_impl.hpp:378
void handle_set_mode_interpolated_position(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set interpolated position mode.
Definition: node_canopen_402_driver_impl.hpp:394
void handle_set_mode_torque(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set profiled torque mode.
Definition: node_canopen_402_driver_impl.hpp:409
void handle_set_mode_cyclic_position(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set cyclic position mode.
Definition: node_canopen_402_driver_impl.hpp:386
virtual void poll_timer_callback() override
Definition: node_canopen_402_driver_impl.hpp:312
bool set_mode_interpolated_position()
Method to set interpolated position mode.
Definition: node_canopen_402_driver_impl.hpp:518
void handle_set_mode_position(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to set profiled position mode.
Definition: node_canopen_402_driver_impl.hpp:370
void handle_recover(const std_srvs::srv::Trigger::Request::SharedPtr request, std_srvs::srv::Trigger::Response::SharedPtr response)
Service Callback to recover device.
Definition: node_canopen_402_driver_impl.hpp:350
void diagnostic_callback(diagnostic_updater::DiagnosticStatusWrapper &stat) override
Definition: node_canopen_402_driver_impl.hpp:650
bool halt_motor()
Method to halt device.
Definition: node_canopen_402_driver_impl.hpp:475
bool set_mode_position()
Method to set profiled position mode.
Definition: node_canopen_402_driver_impl.hpp:498
bool init_motor()
Method to initialise device.
Definition: node_canopen_402_driver_impl.hpp:447
bool recover_motor()
Method to recover device.
Definition: node_canopen_402_driver_impl.hpp:462
NodeCanopen402Driver(NODETYPE *node)
Definition: node_canopen_402_driver_impl.hpp:31
void publish()
Definition: node_canopen_402_driver_impl.hpp:321
bool set_operation_mode(uint16_t mode)
Definition: node_canopen_402_driver_impl.hpp:488
bool set_mode_cyclic_velocity()
Method to set cyclic velocity mode.
Definition: node_canopen_402_driver_impl.hpp:578
bool set_mode_cyclic_position()
Method to set cyclic position mode.
Definition: node_canopen_402_driver_impl.hpp:558
virtual void add_to_master() override
Add the driver to master.
Definition: node_canopen_402_driver_impl.hpp:332
virtual void add_to_master()
Add the driver to master.
Definition: node_canopen_base_driver_impl.hpp:245
virtual void poll_timer_callback()
Definition: node_canopen_base_driver_impl.hpp:403
void deactivate()
Deactivate the driver.
Definition: node_canopen_driver.hpp:265
void activate()
Activate the driver.
Definition: node_canopen_driver.hpp:223
void init()
Initialise the driver.
Definition: node_canopen_driver.hpp:127
void configure()
Configure the driver.
Definition: node_canopen_driver.hpp:175
Definition: node_canopen_proxy_driver.hpp:26
Definition: node_canopen_driver.hpp:46
Definition: configuration_manager.hpp:28