YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
SimulatedWorld_nws_ros2.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2026 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
7
9#include <yarp/os/LogStream.h>
10#include <Ros2Utils.h>
11
12#include <yarp/sig/Pose6D.h>
13#include <yarp/sig/ColorRGB.h>
14
15#include <string>
16#include <vector>
17
18using namespace yarp::dev;
19using namespace yarp::os;
20using namespace std::placeholders;
21
22namespace {
23YARP_LOG_COMPONENT(SIMULATEDWORLD_NWS_ROS2, "yarp.device.simulatedWorld_nws_ros2")
24
26{
28 pose.x = msg.x;
29 pose.y = msg.y;
30 pose.z = msg.z;
31 pose.roll = msg.roll;
32 pose.pitch = msg.pitch;
33 pose.yaw = msg.yaw;
34 return pose;
35}
36
37inline simulated_world_nws_ros2_msgs::msg::Pose6D toRosPose(const yarp::sig::Pose6D& pose)
38{
39 simulated_world_nws_ros2_msgs::msg::Pose6D msg;
40 msg.x = pose.x;
41 msg.y = pose.y;
42 msg.z = pose.z;
43 msg.roll = pose.roll;
44 msg.pitch = pose.pitch;
45 msg.yaw = pose.yaw;
46 return msg;
47}
48
49inline yarp::sig::ColorRGB toYarpColor(const simulated_world_nws_ros2_msgs::msg::ColorRGB& msg)
50{
52 color.r = static_cast<unsigned char>(msg.r);
53 color.g = static_cast<unsigned char>(msg.g);
54 color.b = static_cast<unsigned char>(msg.b);
55 return color;
56}
57} // namespace
58
60
62{
63 yCInfo(SIMULATEDWORLD_NWS_ROS2, "Attaching to driver");
64 if (driver && driver->isValid())
65 {
66 driver->view(m_iSim);
67 }
68
69 if (m_iSim == nullptr)
70 {
71 yCError(SIMULATEDWORLD_NWS_ROS2, "Subdevice passed to attach method is invalid");
72 return false;
73 }
74
75 return true;
76}
77
79{
80 m_iSim = nullptr;
81 return true;
82}
83
85{
86 yCInfo(SIMULATEDWORLD_NWS_ROS2, "Opening SimulatedWorld_nws_ros2");
87 parseParams(config);
88
89 if (!m_node_name.empty() && m_node_name[0] == '/')
90 {
91 yCError(SIMULATEDWORLD_NWS_ROS2) << "node_name cannot begin with an initial /";
92 return false;
93 }
94
95 rclcpp::NodeOptions node_options;
96 node_options.allow_undeclared_parameters(true);
97 node_options.automatically_declare_parameters_from_overrides(true);
98 if (m_namespace.empty()) {
100 } else {
102 }
103 if (m_node == nullptr) {
104 yCError(SIMULATEDWORLD_NWS_ROS2) << " opening " << m_node_name << " Node, check your yarp-ROS2 network configuration\n";
105 return false;
106 }
107
108 m_srv_makeSphere = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeSphere>(
110 m_srv_makeBox = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeBox>(
112 m_srv_makeCylinder = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeCylinder>(
114 m_srv_makeFrame = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeFrame>(
116 m_srv_makeModel = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeModel>(
118 m_srv_makeActor = m_node->create_service<simulated_world_nws_ros2_msgs::srv::MakeActor>(
120 m_srv_changeColor = m_node->create_service<simulated_world_nws_ros2_msgs::srv::ChangeColor>(
122 m_srv_setPose = m_node->create_service<simulated_world_nws_ros2_msgs::srv::SetPose>(
124 m_srv_enableGravity = m_node->create_service<simulated_world_nws_ros2_msgs::srv::EnableGravity>(
126 m_srv_enableCollision = m_node->create_service<simulated_world_nws_ros2_msgs::srv::EnableCollision>(
128 m_srv_getPose = m_node->create_service<simulated_world_nws_ros2_msgs::srv::GetPose>(
130 m_srv_deleteObject = m_node->create_service<simulated_world_nws_ros2_msgs::srv::DeleteObject>(
132 m_srv_deleteAll = m_node->create_service<simulated_world_nws_ros2_msgs::srv::DeleteAll>(
134 m_srv_getList = m_node->create_service<simulated_world_nws_ros2_msgs::srv::GetList>(
136 m_srv_attach = m_node->create_service<simulated_world_nws_ros2_msgs::srv::Attach>(
138 m_srv_detach = m_node->create_service<simulated_world_nws_ros2_msgs::srv::Detach>(
140 m_srv_rename = m_node->create_service<simulated_world_nws_ros2_msgs::srv::Rename>(
142
143 // Start the spinner
144 m_spinner = new Ros2Spinner(m_node);
145 m_spinner->start();
146
147 yCInfo(SIMULATEDWORLD_NWS_ROS2) << "Waiting for device to attach";
148 return true;
149}
150
152{
154
155 // Stop and delete the spinner
156 rclcpp::shutdown();
157 if (m_spinner) {
158 m_spinner->stop();
159 delete m_spinner;
160 m_spinner = nullptr;
161 }
162
163 detach();
164 return true;
165}
166
168 const std::shared_ptr<rmw_request_id_t> request_header,
169 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeSphere::Request> request,
170 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeSphere::Response> response)
171{
173 std::lock_guard<std::mutex> lock(m_mutex);
174 if (!m_iSim)
175 {
176 response->success = false;
177 return;
178 }
179 if (request->frame_name == "None")
180 {
181 request->frame_name = "";
182 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
183 }
184
185 if (request->id == "None" || request->id.empty())
186 {
187 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
188 response->success = false;
189 return;
190 }
191
192 auto ret = m_iSim->makeSphere(request->id, request->radius, toYarpPose(request->pose),
193 toYarpColor(request->color), request->frame_name,
194 request->gravity_enable, request->collision_enable);
195 response->success = static_cast<bool>(ret);
196}
197
199 const std::shared_ptr<rmw_request_id_t> request_header,
200 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeBox::Request> request,
201 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeBox::Response> response)
202{
203
205 std::lock_guard<std::mutex> lock(m_mutex);
206 if (!m_iSim)
207 {
208 response->success = false;
209 return;
210 }
211
212 if (request->frame_name == "None")
213 {
214 request->frame_name = "";
215 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
216 }
217
218 if (request->id == "None" || request->id.empty())
219 {
220 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
221 response->success = false;
222 }
223 else
224 {
225 auto ret = m_iSim->makeBox(request->id, request->width, request->height, request->thickness,
226 toYarpPose(request->pose), toYarpColor(request->color),
227 request->frame_name, request->gravity_enable, request->collision_enable);
228 response->success = static_cast<bool>(ret);
229 }
230
231}
232
234 const std::shared_ptr<rmw_request_id_t> request_header,
235 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeCylinder::Request> request,
236 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeCylinder::Response> response)
237{
239 std::lock_guard<std::mutex> lock(m_mutex);
240 if (!m_iSim)
241 {
242 response->success = false;
243 return;
244 }
245
246 if (request->frame_name == "None")
247 {
248 request->frame_name = "";
249 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
250 }
251
252 if (request->id == "None" || request->id.empty())
253 {
254 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
255 response->success = false;
256 return;
257 }
258
259 auto ret = m_iSim->makeCylinder(request->id, request->radius, request->length,
260 toYarpPose(request->pose), toYarpColor(request->color),
261 request->frame_name, request->gravity_enable, request->collision_enable);
262 response->success = static_cast<bool>(ret);
263}
264
266 const std::shared_ptr<rmw_request_id_t> request_header,
267 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeFrame::Request> request,
268 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeFrame::Response> response)
269{
271 std::lock_guard<std::mutex> lock(m_mutex);
272 if (!m_iSim)
273 {
274 response->success = false;
275 return;
276 }
277
278 if (request->frame_name == "None")
279 {
280 request->frame_name = "";
281 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
282 }
283
284 if (request->id == "None" || request->id.empty())
285 {
286 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
287 response->success = false;
288 return;
289 }
290
291 auto ret = m_iSim->makeFrame(request->id, request->size, toYarpPose(request->pose),
292 toYarpColor(request->color), request->frame_name,
293 request->gravity_enable, request->collision_enable);
294 response->success = static_cast<bool>(ret);
295}
296
298 const std::shared_ptr<rmw_request_id_t> request_header,
299 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeModel::Request> request,
300 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeModel::Response> response)
301{
303 std::lock_guard<std::mutex> lock(m_mutex);
304 if (!m_iSim)
305 {
306 response->success = false;
307 return;
308 }
309 if (request->frame_name == "None")
310 {
311 request->frame_name = "";
312 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
313 }
314
315 if (request->id == "None" || request->id.empty())
316 {
317 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
318 response->success = false;
319 return;
320 }
321
322 auto ret = m_iSim->makeModel(request->id, request->filename, toYarpPose(request->pose),
323 request->frame_name, request->gravity_enable, request->collision_enable);
324 response->success = static_cast<bool>(ret);
325}
326
328 const std::shared_ptr<rmw_request_id_t> request_header,
329 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeActor::Request> request,
330 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::MakeActor::Response> response)
331{
333 std::lock_guard<std::mutex> lock(m_mutex);
334 if (!m_iSim)
335 {
336 response->success = false;
337 return;
338 }
339
340 auto ret = m_iSim->makeActor(request->id, request->filename_skin, request->filename_animation, toYarpPose(request->pose));
341 response->success = static_cast<bool>(ret);
342}
343
345 const std::shared_ptr<rmw_request_id_t> request_header,
346 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::ChangeColor::Request> request,
347 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::ChangeColor::Response> response)
348{
350 std::lock_guard<std::mutex> lock(m_mutex);
351 if (!m_iSim)
352 {
353 response->success = false;
354 return;
355 }
356
357 if (request->id == "None" || request->id.empty())
358 {
359 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
360 response->success = false;
361 return;
362 }
363
364 auto ret = m_iSim->changeColor(request->id, toYarpColor(request->color));
365 response->success = static_cast<bool>(ret);
366}
367
369 const std::shared_ptr<rmw_request_id_t> request_header,
370 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::SetPose::Request> request,
371 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::SetPose::Response> response)
372{
374 std::lock_guard<std::mutex> lock(m_mutex);
375 if (!m_iSim)
376 {
377 response->success = false;
378 return;
379 }
380
381 if (request->frame_name == "None")
382 {
383 request->frame_name = "";
384 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
385 }
386
387 if (request->id == "None" || request->id.empty())
388 {
389 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
390 response->success = false;
391 return;
392 }
393
394 auto ret = m_iSim->setPose(request->id, toYarpPose(request->pose), request->frame_name);
395 response->success = static_cast<bool>(ret);
396}
397
399 const std::shared_ptr<rmw_request_id_t> request_header,
400 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::EnableGravity::Request> request,
401 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::EnableGravity::Response> response)
402{
404 std::lock_guard<std::mutex> lock(m_mutex);
405 if (!m_iSim)
406 {
407 response->success = false;
408 return;
409 }
410
411 if (request->id == "None" || request->id.empty())
412 {
413 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
414 response->success = false;
415 return;
416 }
417 auto ret = m_iSim->enableGravity(request->id, request->enable);
418 response->success = static_cast<bool>(ret);
419}
420
422 const std::shared_ptr<rmw_request_id_t> request_header,
423 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::EnableCollision::Request> request,
424 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::EnableCollision::Response> response)
425{
427 std::lock_guard<std::mutex> lock(m_mutex);
428 if (!m_iSim)
429 {
430 response->success = false;
431 return;
432 }
433 if (request->id == "None" || request->id.empty())
434 {
435 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
436 response->success = false;
437 return;
438 }
439
440 auto ret = m_iSim->enableCollision(request->id, request->enable);
441 response->success = static_cast<bool>(ret);
442}
443
445 const std::shared_ptr<rmw_request_id_t> request_header,
446 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::GetPose::Request> request,
447 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::GetPose::Response> response)
448{
450 std::lock_guard<std::mutex> lock(m_mutex);
451 if (!m_iSim)
452 {
453 response->success = false;
454 return;
455 }
456
457 if (request->frame_name == "None")
458 {
459 request->frame_name = "";
460 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Frame name was 'None', setting to empty string";
461 }
462
463 if (request->id == "None" || request->id.empty())
464 {
465 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
466 response->success = false;
467 return;
468 }
469
471 auto ret = m_iSim->getPose(request->id, pose, request->frame_name);
472 response->success = static_cast<bool>(ret);
473 if (ret)
474 {
475 response->pose = toRosPose(pose);
476 }
477}
478
480 const std::shared_ptr<rmw_request_id_t> request_header,
481 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::DeleteObject::Request> request,
482 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::DeleteObject::Response> response)
483{
485 std::lock_guard<std::mutex> lock(m_mutex);
486 if (!m_iSim)
487 {
488 response->success = false;
489 return;
490 }
491 if (request->id == "None" || request->id.empty())
492 {
493 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
494 response->success = false;
495 return;
496 }
497
498 auto ret = m_iSim->deleteObject(request->id);
499 response->success = static_cast<bool>(ret);
500}
501
503 const std::shared_ptr<rmw_request_id_t> request_header,
504 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::DeleteAll::Request> request,
505 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::DeleteAll::Response> response)
506{
508 (void)request;
509 std::lock_guard<std::mutex> lock(m_mutex);
510 if (!m_iSim)
511 {
512 response->success = false;
513 return;
514 }
515
516 auto ret = m_iSim->deleteAll();
517 response->success = static_cast<bool>(ret);
518}
519
521 const std::shared_ptr<rmw_request_id_t> request_header,
522 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::GetList::Request> request,
523 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::GetList::Response> response)
524{
526 (void)request;
527 std::lock_guard<std::mutex> lock(m_mutex);
528 if (!m_iSim)
529 {
530 response->success = false;
531 return;
532 }
533
534 std::vector<std::string> names;
535 auto ret = m_iSim->getList(names);
536 response->success = static_cast<bool>(ret);
537 if (ret)
538 {
539 response->names = names;
540 }
541}
542
544 const std::shared_ptr<rmw_request_id_t> request_header,
545 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Attach::Request> request,
546 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Attach::Response> response)
547{
549 std::lock_guard<std::mutex> lock(m_mutex);
550 if (!m_iSim)
551 {
552 response->success = false;
553 return;
554 }
555
556 if (request->link_name == "None")
557 {
558 request->link_name = "";
559 yCWarning(SIMULATEDWORLD_NWS_ROS2) << "Link name was 'None', setting to empty string";
560 }
561
562 if (request->id == "None" || request->id.empty())
563 {
564 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
565 response->success = false;
566 }
567 else
568 {
569 auto ret = m_iSim->attach(request->id, request->link_name);
570 response->success = static_cast<bool>(ret);
571 }
572
573}
574
576 const std::shared_ptr<rmw_request_id_t> request_header,
577 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Detach::Request> request,
578 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Detach::Response> response)
579{
581 std::lock_guard<std::mutex> lock(m_mutex);
582 if (!m_iSim)
583 {
584 response->success = false;
585 return;
586 }
587
588 if (request->id == "None" || request->id.empty())
589 {
590 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid request ID";
591 response->success = false;
592 return;
593 }
594
595 auto ret = m_iSim->detach(request->id);
596 response->success = static_cast<bool>(ret);
597}
598
600 const std::shared_ptr<rmw_request_id_t> request_header,
601 const std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Rename::Request> request,
602 std::shared_ptr<simulated_world_nws_ros2_msgs::srv::Rename::Response> response)
603{
605 std::lock_guard<std::mutex> lock(m_mutex);
606 if (!m_iSim)
607 {
608 response->success = false;
609 return;
610 }
611 if (request->old_name=="None" || request->old_name.empty() || request->new_name == "None" || request->new_name.empty())
612 {
613 yCError(SIMULATEDWORLD_NWS_ROS2) << "Invalid input parameters";
614 response->success = false;
615 return;
616 }
617
618 auto ret = m_iSim->rename(request->old_name, request->new_name);
619 response->success = static_cast<bool>(ret);
620}
static rclcpp::Node::SharedPtr createNode(std::string name)
Definition Ros2Utils.cpp:9
bool parseParams(const yarp::os::Searchable &config) override
Parse the DeviceDriver parameters.
void getListCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::GetList::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::GetList::Response > response)
void attachCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Attach::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Attach::Response > response)
void deleteAllCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::DeleteAll::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::DeleteAll::Response > response)
void deleteObjectCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::DeleteObject::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::DeleteObject::Response > response)
void getPoseCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::GetPose::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::GetPose::Response > response)
void makeSphereCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeSphere::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeSphere::Response > response)
void makeModelCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeModel::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeModel::Response > response)
void makeActorCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeActor::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeActor::Response > response)
void setPoseCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::SetPose::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::SetPose::Response > response)
bool detach() override
Detach the object (you must have first called attach).
void renameCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Rename::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Rename::Response > response)
void makeBoxCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeBox::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeBox::Response > response)
void makeCylinderCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeCylinder::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeCylinder::Response > response)
void changeColorCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::ChangeColor::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::ChangeColor::Response > response)
void enableGravityCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::EnableGravity::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::EnableGravity::Response > response)
void makeFrameCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeFrame::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::MakeFrame::Response > response)
void detachCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Detach::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::Detach::Response > response)
void enableCollisionCallback(const std::shared_ptr< rmw_request_id_t > request_header, const std::shared_ptr< simulated_world_nws_ros2_msgs::srv::EnableCollision::Request > request, std::shared_ptr< simulated_world_nws_ros2_msgs::srv::EnableCollision::Response > response)
bool open(yarp::os::Searchable &config) override
Open the DeviceDriver.
bool attach(yarp::dev::PolyDriver *driver) override
Attach to another object.
bool close() override
Close the DeviceDriver.
bool view(T *&x)
Get an interface to the device driver.
virtual yarp::dev::ReturnValue getPose(std::string id, yarp::sig::Pose6D &pose, std::string frame_name="")=0
Get object pose.
virtual yarp::dev::ReturnValue enableGravity(std::string id, bool enable)=0
Enable/disables gravity for an object.
virtual yarp::dev::ReturnValue enableCollision(std::string id, bool enable)=0
Enable/disables collision detection for an object.
virtual yarp::dev::ReturnValue getList(std::vector< std::string > &names)=0
List id of all objects that have been added to the world.
virtual yarp::dev::ReturnValue setPose(std::string id, yarp::sig::Pose6D pose, std::string frame_name="")=0
Set new object pose.
virtual yarp::dev::ReturnValue attach(std::string id, std::string link_name)=0
Attach an object to a link of another object.
virtual yarp::dev::ReturnValue makeCylinder(std::string id, double radius, double length, yarp::sig::Pose6D pose, yarp::sig::ColorRGB color, std::string frame_name="", bool gravity_enable=0, bool collision_enable=1)=0
Make a cylinder.
virtual yarp::dev::ReturnValue changeColor(std::string id, yarp::sig::ColorRGB color)=0
Change the color of an object.
virtual yarp::dev::ReturnValue makeFrame(std::string id, double size, yarp::sig::Pose6D pose, yarp::sig::ColorRGB color, std::string frame_name="", bool gravity_enable=0, bool collision_enable=1)=0
Make a reference frame (a 3D model with 3 arrows representing the axes)
virtual yarp::dev::ReturnValue deleteObject(std::string id)=0
Delete an object.
virtual yarp::dev::ReturnValue makeActor(std::string id, std::string skin_filename, std::string animation_filename, yarp::sig::Pose6D pose)=0
Create an actor.
virtual yarp::dev::ReturnValue makeModel(std::string id, std::string filename, yarp::sig::Pose6D pose, std::string frame_name="", bool gravity_enable=0, bool collision_enable=1)=0
Create a model from a file.
virtual yarp::dev::ReturnValue makeSphere(std::string id, double radius, yarp::sig::Pose6D pose, yarp::sig::ColorRGB color, std::string frame_name="", bool gravity_enable=0, bool collision_enable=1)=0
Make a sphere.
virtual yarp::dev::ReturnValue rename(std::string old_name, std::string new_name)=0
Change the names of an object.
virtual yarp::dev::ReturnValue makeBox(std::string id, double width, double height, double thickness, yarp::sig::Pose6D pose, yarp::sig::ColorRGB color, std::string frame_name="", bool gravity_enable=0, bool collision_enable=1)=0
Make a box.
virtual yarp::dev::ReturnValue deleteAll()=0
Delete all objects in the world.
virtual yarp::dev::ReturnValue detach(std::string id)=0
Detach a previously attached object.
A container for a device driver.
Definition PolyDriver.h:23
bool isValid() const
Check if device is valid.
A mini-server for performing network communication in the background.
A base class for nested structures that can be searched.
Definition Searchable.h:31
bool stop()
Stop the thread.
Definition Thread.cpp:81
std::int16_t r
Definition ColorRGB.h:26
std::int16_t b
Definition ColorRGB.h:28
std::int16_t g
Definition ColorRGB.h:27
#define yCInfo(component,...)
#define yCError(component,...)
#define yCTrace(component,...)
#define yCWarning(component,...)
#define YARP_LOG_COMPONENT(name,...)
For streams capable of holding different kinds of content, check what they actually have.
An interface to the operating system, including Port based communication.
Definition OSTestMsg.cpp:13
The main, catch-all namespace for YARP.
Definition dirs.h:16