Fawkes API  Fawkes Development Version
NavigatorInterface.cpp
1 
2 /***************************************************************************
3  * NavigatorInterface.cpp - Fawkes BlackBoard Interface - NavigatorInterface
4  *
5  * Templated created: Thu Oct 12 10:49:19 2006
6  * Copyright 2007-2009 Martin Liebenberg, Daniel Beck, Tim Niemueller
7  *
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version. A runtime exception applies to
14  * this software (see LICENSE.GPL_WRE file mentioned below for details).
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Library General Public License for more details.
20  *
21  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22  */
23 
24 #include <interfaces/NavigatorInterface.h>
25 
26 #include <core/exceptions/software.h>
27 
28 #include <map>
29 #include <string>
30 #include <cstring>
31 #include <cstdlib>
32 
33 namespace fawkes {
34 
35 /** @class NavigatorInterface <interfaces/NavigatorInterface.h>
36  * NavigatorInterface Fawkes BlackBoard Interface.
37  *
38  The navigator interface is used by the navigator to export information about
39  the current status of the navigator and to define all messages by which the navigator
40  can be instructed.
41 
42  There are three coordinate systems, the robot system which is a right-handed cartesian
43  coordinate system with the robot in its origin, X axis pointing forward, Y pointing to
44  the left and Z pointing upwards. The second coordinate system is the so-called
45  navigator system. It is a coordinate system similar to the robot system, but the
46  origin is defined on the initialization of the navigator. The last system is the
47  odometry system. It is again a similar system, but the origin is reset from time
48  to time and the robot's position in this system gives the odometry deltas.
49 
50  * @ingroup FawkesInterfaces
51  */
52 
53 
54 /** ERROR_NONE constant */
55 const uint32_t NavigatorInterface::ERROR_NONE = 0u;
56 /** ERROR_MOTOR constant */
57 const uint32_t NavigatorInterface::ERROR_MOTOR = 1u;
58 /** ERROR_OBSTRUCTION constant */
59 const uint32_t NavigatorInterface::ERROR_OBSTRUCTION = 2u;
60 /** ERROR_UNKNOWN_PLACE constant */
61 const uint32_t NavigatorInterface::ERROR_UNKNOWN_PLACE = 4u;
62 /** ERROR_PATH_GEN_FAIL constant */
63 const uint32_t NavigatorInterface::ERROR_PATH_GEN_FAIL = 8u;
64 /** FLAG_NONE constant */
65 const uint32_t NavigatorInterface::FLAG_NONE = 0u;
66 /** FLAG_CART_GOTO constant */
67 const uint32_t NavigatorInterface::FLAG_CART_GOTO = 1u;
68 /** FLAG_POLAR_GOTO constant */
69 const uint32_t NavigatorInterface::FLAG_POLAR_GOTO = 2u;
70 /** FLAG_PLACE_GOTO constant */
71 const uint32_t NavigatorInterface::FLAG_PLACE_GOTO = 4u;
72 /** FLAG_UPDATES_DEST_DIST constant */
74 /** FLAG_SECURITY_DISTANCE constant */
76 /** FLAG_ESCAPING constant */
77 const uint32_t NavigatorInterface::FLAG_ESCAPING = 32u;
78 
79 /** Constructor */
80 NavigatorInterface::NavigatorInterface() : Interface()
81 {
82  data_size = sizeof(NavigatorInterface_data_t);
83  data_ptr = malloc(data_size);
84  data = (NavigatorInterface_data_t *)data_ptr;
85  data_ts = (interface_data_ts_t *)data_ptr;
86  memset(data_ptr, 0, data_size);
87  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
88  enum_map_DriveMode[(int)Forward] = "Forward";
89  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
90  enum_map_DriveMode[(int)Backward] = "Backward";
91  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
92  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
93  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
94  add_fieldinfo(IFT_UINT32, "flags", 1, &data->flags);
95  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
96  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
97  add_fieldinfo(IFT_FLOAT, "dest_x", 1, &data->dest_x);
98  add_fieldinfo(IFT_FLOAT, "dest_y", 1, &data->dest_y);
99  add_fieldinfo(IFT_FLOAT, "dest_ori", 1, &data->dest_ori);
100  add_fieldinfo(IFT_FLOAT, "dest_dist", 1, &data->dest_dist);
101  add_fieldinfo(IFT_UINT32, "msgid", 1, &data->msgid);
102  add_fieldinfo(IFT_BOOL, "final", 1, &data->final);
103  add_fieldinfo(IFT_UINT32, "error_code", 1, &data->error_code);
104  add_fieldinfo(IFT_FLOAT, "max_velocity", 1, &data->max_velocity);
105  add_fieldinfo(IFT_FLOAT, "max_rotation", 1, &data->max_rotation);
106  add_fieldinfo(IFT_FLOAT, "security_distance", 1, &data->security_distance);
107  add_fieldinfo(IFT_BOOL, "escaping_enabled", 1, &data->escaping_enabled);
108  add_fieldinfo(IFT_ENUM, "drive_mode", 1, &data->drive_mode, "DriveMode", &enum_map_DriveMode);
109  add_fieldinfo(IFT_BOOL, "auto_drive_mode", 1, &data->auto_drive_mode);
110  add_fieldinfo(IFT_BOOL, "stop_at_target", 1, &data->stop_at_target);
111  add_fieldinfo(IFT_ENUM, "orientation_mode", 1, &data->orientation_mode, "OrientationMode", &enum_map_OrientationMode);
112  add_fieldinfo(IFT_STRING, "target_frame", 64, data->target_frame);
113  add_messageinfo("StopMessage");
114  add_messageinfo("TurnMessage");
115  add_messageinfo("CartesianGotoMessage");
116  add_messageinfo("CartesianGotoWithToleranceMessage");
117  add_messageinfo("CartesianGotoWithFrameMessage");
118  add_messageinfo("CartesianGotoWithFrameWithToleranceMessage");
119  add_messageinfo("PolarGotoMessage");
120  add_messageinfo("PlaceGotoMessage");
121  add_messageinfo("PlaceWithOriGotoMessage");
122  add_messageinfo("ObstacleMessage");
123  add_messageinfo("ResetOdometryMessage");
124  add_messageinfo("SetMaxVelocityMessage");
125  add_messageinfo("SetMaxRotationMessage");
126  add_messageinfo("SetEscapingMessage");
127  add_messageinfo("SetSecurityDistanceMessage");
128  add_messageinfo("SetDriveModeMessage");
129  add_messageinfo("SetStopAtTargetMessage");
130  add_messageinfo("SetOrientationModeMessage");
131  add_messageinfo("ResetParametersMessage");
132  unsigned char tmp_hash[] = {0x5f, 0xf9, 0xaa, 0x1e, 0xb4, 0x6a, 0x4a, 0xa3, 0xe5, 0xe0, 0x2b, 0xbd, 0x73, 0x17, 0x66, 0xea};
133  set_hash(tmp_hash);
134 }
135 
136 /** Destructor */
137 NavigatorInterface::~NavigatorInterface()
138 {
139  free(data_ptr);
140 }
141 /** Convert DriveMode constant to string.
142  * @param value value to convert to string
143  * @return constant value as string.
144  */
145 const char *
146 NavigatorInterface::tostring_DriveMode(DriveMode value) const
147 {
148  switch (value) {
149  case MovingNotAllowed: return "MovingNotAllowed";
150  case Forward: return "Forward";
151  case AllowBackward: return "AllowBackward";
152  case Backward: return "Backward";
153  case ESCAPE: return "ESCAPE";
154  default: return "UNKNOWN";
155  }
156 }
157 /** Convert OrientationMode constant to string.
158  * @param value value to convert to string
159  * @return constant value as string.
160  */
161 const char *
162 NavigatorInterface::tostring_OrientationMode(OrientationMode value) const
163 {
164  switch (value) {
165  case OrientAtTarget: return "OrientAtTarget";
166  case OrientDuringTravel: return "OrientDuringTravel";
167  default: return "UNKNOWN";
168  }
169 }
170 /* Methods */
171 /** Get flags value.
172  * Bit-wise combination of
173  FLAG_* constants denoting navigator component features.
174  * @return flags value
175  */
176 uint32_t
178 {
179  return data->flags;
180 }
181 
182 /** Get maximum length of flags value.
183  * @return length of flags value, can be length of the array or number of
184  * maximum number of characters for a string
185  */
186 size_t
188 {
189  return 1;
190 }
191 
192 /** Set flags value.
193  * Bit-wise combination of
194  FLAG_* constants denoting navigator component features.
195  * @param new_flags new flags value
196  */
197 void
198 NavigatorInterface::set_flags(const uint32_t new_flags)
199 {
200  data->flags = new_flags;
201  data_changed = true;
202 }
203 
204 /** Get x value.
205  * Current X-coordinate in the navigator coordinate system.
206  * @return x value
207  */
208 float
209 NavigatorInterface::x() const
210 {
211  return data->x;
212 }
213 
214 /** Get maximum length of x value.
215  * @return length of x value, can be length of the array or number of
216  * maximum number of characters for a string
217  */
218 size_t
220 {
221  return 1;
222 }
223 
224 /** Set x value.
225  * Current X-coordinate in the navigator coordinate system.
226  * @param new_x new x value
227  */
228 void
229 NavigatorInterface::set_x(const float new_x)
230 {
231  data->x = new_x;
232  data_changed = true;
233 }
234 
235 /** Get y value.
236  * Current Y-coordinate in the navigator coordinate system.
237  * @return y value
238  */
239 float
240 NavigatorInterface::y() const
241 {
242  return data->y;
243 }
244 
245 /** Get maximum length of y value.
246  * @return length of y value, can be length of the array or number of
247  * maximum number of characters for a string
248  */
249 size_t
251 {
252  return 1;
253 }
254 
255 /** Set y value.
256  * Current Y-coordinate in the navigator coordinate system.
257  * @param new_y new y value
258  */
259 void
260 NavigatorInterface::set_y(const float new_y)
261 {
262  data->y = new_y;
263  data_changed = true;
264 }
265 
266 /** Get dest_x value.
267  * X-coordinate of the current destination, or 0.0 if no target has been set.
268  * @return dest_x value
269  */
270 float
272 {
273  return data->dest_x;
274 }
275 
276 /** Get maximum length of dest_x value.
277  * @return length of dest_x value, can be length of the array or number of
278  * maximum number of characters for a string
279  */
280 size_t
282 {
283  return 1;
284 }
285 
286 /** Set dest_x value.
287  * X-coordinate of the current destination, or 0.0 if no target has been set.
288  * @param new_dest_x new dest_x value
289  */
290 void
291 NavigatorInterface::set_dest_x(const float new_dest_x)
292 {
293  data->dest_x = new_dest_x;
294  data_changed = true;
295 }
296 
297 /** Get dest_y value.
298  * Y-coordinate of the current destination, or 0.0 if no target has been set.
299  * @return dest_y value
300  */
301 float
303 {
304  return data->dest_y;
305 }
306 
307 /** Get maximum length of dest_y value.
308  * @return length of dest_y value, can be length of the array or number of
309  * maximum number of characters for a string
310  */
311 size_t
313 {
314  return 1;
315 }
316 
317 /** Set dest_y value.
318  * Y-coordinate of the current destination, or 0.0 if no target has been set.
319  * @param new_dest_y new dest_y value
320  */
321 void
322 NavigatorInterface::set_dest_y(const float new_dest_y)
323 {
324  data->dest_y = new_dest_y;
325  data_changed = true;
326 }
327 
328 /** Get dest_ori value.
329  * Orientation of the current destination, or 0.0 if no target has been set.
330  * @return dest_ori value
331  */
332 float
334 {
335  return data->dest_ori;
336 }
337 
338 /** Get maximum length of dest_ori value.
339  * @return length of dest_ori value, can be length of the array or number of
340  * maximum number of characters for a string
341  */
342 size_t
344 {
345  return 1;
346 }
347 
348 /** Set dest_ori value.
349  * Orientation of the current destination, or 0.0 if no target has been set.
350  * @param new_dest_ori new dest_ori value
351  */
352 void
353 NavigatorInterface::set_dest_ori(const float new_dest_ori)
354 {
355  data->dest_ori = new_dest_ori;
356  data_changed = true;
357 }
358 
359 /** Get dest_dist value.
360  * Distance to destination in m.
361  * @return dest_dist value
362  */
363 float
365 {
366  return data->dest_dist;
367 }
368 
369 /** Get maximum length of dest_dist value.
370  * @return length of dest_dist value, can be length of the array or number of
371  * maximum number of characters for a string
372  */
373 size_t
375 {
376  return 1;
377 }
378 
379 /** Set dest_dist value.
380  * Distance to destination in m.
381  * @param new_dest_dist new dest_dist value
382  */
383 void
384 NavigatorInterface::set_dest_dist(const float new_dest_dist)
385 {
386  data->dest_dist = new_dest_dist;
387  data_changed = true;
388 }
389 
390 /** Get msgid value.
391  * The ID of the message that is currently being
392  processed, or 0 if no message is being processed.
393  * @return msgid value
394  */
395 uint32_t
397 {
398  return data->msgid;
399 }
400 
401 /** Get maximum length of msgid value.
402  * @return length of msgid value, can be length of the array or number of
403  * maximum number of characters for a string
404  */
405 size_t
407 {
408  return 1;
409 }
410 
411 /** Set msgid value.
412  * The ID of the message that is currently being
413  processed, or 0 if no message is being processed.
414  * @param new_msgid new msgid value
415  */
416 void
417 NavigatorInterface::set_msgid(const uint32_t new_msgid)
418 {
419  data->msgid = new_msgid;
420  data_changed = true;
421 }
422 
423 /** Get final value.
424  * True, if the last goto command has been finished,
425  false if it is still running
426  * @return final value
427  */
428 bool
430 {
431  return data->final;
432 }
433 
434 /** Get maximum length of final value.
435  * @return length of final value, can be length of the array or number of
436  * maximum number of characters for a string
437  */
438 size_t
440 {
441  return 1;
442 }
443 
444 /** Set final value.
445  * True, if the last goto command has been finished,
446  false if it is still running
447  * @param new_final new final value
448  */
449 void
450 NavigatorInterface::set_final(const bool new_final)
451 {
452  data->final = new_final;
453  data_changed = true;
454 }
455 
456 /** Get error_code value.
457  * Failure code set if
458  final is true. 0 if no error occured, an error code from ERROR_*
459  constants otherwise (or a bit-wise combination).
460  * @return error_code value
461  */
462 uint32_t
464 {
465  return data->error_code;
466 }
467 
468 /** Get maximum length of error_code value.
469  * @return length of error_code value, can be length of the array or number of
470  * maximum number of characters for a string
471  */
472 size_t
474 {
475  return 1;
476 }
477 
478 /** Set error_code value.
479  * Failure code set if
480  final is true. 0 if no error occured, an error code from ERROR_*
481  constants otherwise (or a bit-wise combination).
482  * @param new_error_code new error_code value
483  */
484 void
485 NavigatorInterface::set_error_code(const uint32_t new_error_code)
486 {
487  data->error_code = new_error_code;
488  data_changed = true;
489 }
490 
491 /** Get max_velocity value.
492  * Maximum velocity
493  * @return max_velocity value
494  */
495 float
497 {
498  return data->max_velocity;
499 }
500 
501 /** Get maximum length of max_velocity value.
502  * @return length of max_velocity value, can be length of the array or number of
503  * maximum number of characters for a string
504  */
505 size_t
507 {
508  return 1;
509 }
510 
511 /** Set max_velocity value.
512  * Maximum velocity
513  * @param new_max_velocity new max_velocity value
514  */
515 void
516 NavigatorInterface::set_max_velocity(const float new_max_velocity)
517 {
518  data->max_velocity = new_max_velocity;
519  data_changed = true;
520 }
521 
522 /** Get max_rotation value.
523  * Maximum rotation velocity
524  * @return max_rotation value
525  */
526 float
528 {
529  return data->max_rotation;
530 }
531 
532 /** Get maximum length of max_rotation value.
533  * @return length of max_rotation value, can be length of the array or number of
534  * maximum number of characters for a string
535  */
536 size_t
538 {
539  return 1;
540 }
541 
542 /** Set max_rotation value.
543  * Maximum rotation velocity
544  * @param new_max_rotation new max_rotation value
545  */
546 void
547 NavigatorInterface::set_max_rotation(const float new_max_rotation)
548 {
549  data->max_rotation = new_max_rotation;
550  data_changed = true;
551 }
552 
553 /** Get security_distance value.
554  * Security distance to keep to obstacles
555  * @return security_distance value
556  */
557 float
559 {
560  return data->security_distance;
561 }
562 
563 /** Get maximum length of security_distance value.
564  * @return length of security_distance value, can be length of the array or number of
565  * maximum number of characters for a string
566  */
567 size_t
569 {
570  return 1;
571 }
572 
573 /** Set security_distance value.
574  * Security distance to keep to obstacles
575  * @param new_security_distance new security_distance value
576  */
577 void
578 NavigatorInterface::set_security_distance(const float new_security_distance)
579 {
580  data->security_distance = new_security_distance;
581  data_changed = true;
582 }
583 
584 /** Get escaping_enabled value.
585  * This is used for navigation components with integrated collision avoidance,
586  to check whether the navigator should stop when an obstacle obstructs the path, or if it should escape.
587  * @return escaping_enabled value
588  */
589 bool
591 {
592  return data->escaping_enabled;
593 }
594 
595 /** Get maximum length of escaping_enabled value.
596  * @return length of escaping_enabled value, can be length of the array or number of
597  * maximum number of characters for a string
598  */
599 size_t
601 {
602  return 1;
603 }
604 
605 /** Set escaping_enabled value.
606  * This is used for navigation components with integrated collision avoidance,
607  to check whether the navigator should stop when an obstacle obstructs the path, or if it should escape.
608  * @param new_escaping_enabled new escaping_enabled value
609  */
610 void
611 NavigatorInterface::set_escaping_enabled(const bool new_escaping_enabled)
612 {
613  data->escaping_enabled = new_escaping_enabled;
614  data_changed = true;
615 }
616 
617 /** Get drive_mode value.
618  * Current drive mode
619  * @return drive_mode value
620  */
623 {
624  return (NavigatorInterface::DriveMode)data->drive_mode;
625 }
626 
627 /** Get maximum length of drive_mode value.
628  * @return length of drive_mode value, can be length of the array or number of
629  * maximum number of characters for a string
630  */
631 size_t
633 {
634  return 1;
635 }
636 
637 /** Set drive_mode value.
638  * Current drive mode
639  * @param new_drive_mode new drive_mode value
640  */
641 void
642 NavigatorInterface::set_drive_mode(const DriveMode new_drive_mode)
643 {
644  data->drive_mode = new_drive_mode;
645  data_changed = true;
646 }
647 
648 /** Get auto_drive_mode value.
649  * True, if the drive mode should be automatically decided each time.
650  False, if the drive mode should not automatically change, which is the case when sending
651  a SetAutoDriveMode-message (otherwise the navigator might ignore that value).
652  * @return auto_drive_mode value
653  */
654 bool
656 {
657  return data->auto_drive_mode;
658 }
659 
660 /** Get maximum length of auto_drive_mode value.
661  * @return length of auto_drive_mode value, can be length of the array or number of
662  * maximum number of characters for a string
663  */
664 size_t
666 {
667  return 1;
668 }
669 
670 /** Set auto_drive_mode value.
671  * True, if the drive mode should be automatically decided each time.
672  False, if the drive mode should not automatically change, which is the case when sending
673  a SetAutoDriveMode-message (otherwise the navigator might ignore that value).
674  * @param new_auto_drive_mode new auto_drive_mode value
675  */
676 void
677 NavigatorInterface::set_auto_drive_mode(const bool new_auto_drive_mode)
678 {
679  data->auto_drive_mode = new_auto_drive_mode;
680  data_changed = true;
681 }
682 
683 /** Get stop_at_target value.
684  * Stop when target is reached?
685  * @return stop_at_target value
686  */
687 bool
689 {
690  return data->stop_at_target;
691 }
692 
693 /** Get maximum length of stop_at_target value.
694  * @return length of stop_at_target value, can be length of the array or number of
695  * maximum number of characters for a string
696  */
697 size_t
699 {
700  return 1;
701 }
702 
703 /** Set stop_at_target value.
704  * Stop when target is reached?
705  * @param new_stop_at_target new stop_at_target value
706  */
707 void
708 NavigatorInterface::set_stop_at_target(const bool new_stop_at_target)
709 {
710  data->stop_at_target = new_stop_at_target;
711  data_changed = true;
712 }
713 
714 /** Get orientation_mode value.
715  * Mode how/when to orientate if orientation is given
716  * @return orientation_mode value
717  */
720 {
721  return (NavigatorInterface::OrientationMode)data->orientation_mode;
722 }
723 
724 /** Get maximum length of orientation_mode value.
725  * @return length of orientation_mode value, can be length of the array or number of
726  * maximum number of characters for a string
727  */
728 size_t
730 {
731  return 1;
732 }
733 
734 /** Set orientation_mode value.
735  * Mode how/when to orientate if orientation is given
736  * @param new_orientation_mode new orientation_mode value
737  */
738 void
740 {
741  data->orientation_mode = new_orientation_mode;
742  data_changed = true;
743 }
744 
745 /** Get target_frame value.
746  * The target frame to plan into
747  * @return target_frame value
748  */
749 char *
751 {
752  return data->target_frame;
753 }
754 
755 /** Get maximum length of target_frame value.
756  * @return length of target_frame value, can be length of the array or number of
757  * maximum number of characters for a string
758  */
759 size_t
761 {
762  return 64;
763 }
764 
765 /** Set target_frame value.
766  * The target frame to plan into
767  * @param new_target_frame new target_frame value
768  */
769 void
770 NavigatorInterface::set_target_frame(const char * new_target_frame)
771 {
772  strncpy(data->target_frame, new_target_frame, sizeof(data->target_frame)-1);
773  data->target_frame[sizeof(data->target_frame)-1] = 0;
774  data_changed = true;
775 }
776 
777 /* =========== message create =========== */
778 Message *
779 NavigatorInterface::create_message(const char *type) const
780 {
781  if ( strncmp("StopMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
782  return new StopMessage();
783  } else if ( strncmp("TurnMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
784  return new TurnMessage();
785  } else if ( strncmp("CartesianGotoMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
786  return new CartesianGotoMessage();
787  } else if ( strncmp("CartesianGotoWithToleranceMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
788  return new CartesianGotoWithToleranceMessage();
789  } else if ( strncmp("CartesianGotoWithFrameMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
790  return new CartesianGotoWithFrameMessage();
791  } else if ( strncmp("CartesianGotoWithFrameWithToleranceMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
792  return new CartesianGotoWithFrameWithToleranceMessage();
793  } else if ( strncmp("PolarGotoMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
794  return new PolarGotoMessage();
795  } else if ( strncmp("PlaceGotoMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
796  return new PlaceGotoMessage();
797  } else if ( strncmp("PlaceWithOriGotoMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
798  return new PlaceWithOriGotoMessage();
799  } else if ( strncmp("ObstacleMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
800  return new ObstacleMessage();
801  } else if ( strncmp("ResetOdometryMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
802  return new ResetOdometryMessage();
803  } else if ( strncmp("SetMaxVelocityMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
804  return new SetMaxVelocityMessage();
805  } else if ( strncmp("SetMaxRotationMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
806  return new SetMaxRotationMessage();
807  } else if ( strncmp("SetEscapingMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
808  return new SetEscapingMessage();
809  } else if ( strncmp("SetSecurityDistanceMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
810  return new SetSecurityDistanceMessage();
811  } else if ( strncmp("SetDriveModeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
812  return new SetDriveModeMessage();
813  } else if ( strncmp("SetStopAtTargetMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
814  return new SetStopAtTargetMessage();
815  } else if ( strncmp("SetOrientationModeMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
816  return new SetOrientationModeMessage();
817  } else if ( strncmp("ResetParametersMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
818  return new ResetParametersMessage();
819  } else {
820  throw UnknownTypeException("The given type '%s' does not match any known "
821  "message type for this interface type.", type);
822  }
823 }
824 
825 
826 /** Copy values from other interface.
827  * @param other other interface to copy values from
828  */
829 void
831 {
832  const NavigatorInterface *oi = dynamic_cast<const NavigatorInterface *>(other);
833  if (oi == NULL) {
834  throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
835  type(), other->type());
836  }
837  memcpy(data, oi->data, sizeof(NavigatorInterface_data_t));
838 }
839 
840 const char *
841 NavigatorInterface::enum_tostring(const char *enumtype, int val) const
842 {
843  if (strcmp(enumtype, "DriveMode") == 0) {
844  return tostring_DriveMode((DriveMode)val);
845  }
846  if (strcmp(enumtype, "OrientationMode") == 0) {
847  return tostring_OrientationMode((OrientationMode)val);
848  }
849  throw UnknownTypeException("Unknown enum type %s", enumtype);
850 }
851 
852 /* =========== messages =========== */
853 /** @class NavigatorInterface::StopMessage <interfaces/NavigatorInterface.h>
854  * StopMessage Fawkes BlackBoard Interface Message.
855  *
856 
857  */
858 
859 
860 /** Constructor with initial values.
861  * @param ini_msgid initial value for msgid
862  */
863 NavigatorInterface::StopMessage::StopMessage(const uint32_t ini_msgid) : Message("StopMessage")
864 {
865  data_size = sizeof(StopMessage_data_t);
866  data_ptr = malloc(data_size);
867  memset(data_ptr, 0, data_size);
868  data = (StopMessage_data_t *)data_ptr;
870  data->msgid = ini_msgid;
871  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
872  enum_map_DriveMode[(int)Forward] = "Forward";
873  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
874  enum_map_DriveMode[(int)Backward] = "Backward";
875  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
876  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
877  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
878  add_fieldinfo(IFT_UINT32, "msgid", 1, &data->msgid);
879 }
880 /** Constructor */
882 {
883  data_size = sizeof(StopMessage_data_t);
884  data_ptr = malloc(data_size);
885  memset(data_ptr, 0, data_size);
886  data = (StopMessage_data_t *)data_ptr;
888  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
889  enum_map_DriveMode[(int)Forward] = "Forward";
890  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
891  enum_map_DriveMode[(int)Backward] = "Backward";
892  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
893  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
894  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
895  add_fieldinfo(IFT_UINT32, "msgid", 1, &data->msgid);
896 }
897 
898 /** Destructor */
900 {
901  free(data_ptr);
902 }
903 
904 /** Copy constructor.
905  * @param m message to copy from
906  */
908 {
909  data_size = m->data_size;
910  data_ptr = malloc(data_size);
912  data = (StopMessage_data_t *)data_ptr;
914 }
915 
916 /* Methods */
917 /** Get msgid value.
918  *
919  If zero, stops any motion. If non-zero, the component shall only
920  stop the motion if the currently executed command was received
921  through a message with that specific ID.
922 
923  Use the specific version whenever possible. It avoids a race
924  condition if one intstructing component sends a stop, and
925  another a new drive command at the same time.
926 
927  * @return msgid value
928  */
929 uint32_t
931 {
932  return data->msgid;
933 }
934 
935 /** Get maximum length of msgid value.
936  * @return length of msgid value, can be length of the array or number of
937  * maximum number of characters for a string
938  */
939 size_t
941 {
942  return 1;
943 }
944 
945 /** Set msgid value.
946  *
947  If zero, stops any motion. If non-zero, the component shall only
948  stop the motion if the currently executed command was received
949  through a message with that specific ID.
950 
951  Use the specific version whenever possible. It avoids a race
952  condition if one intstructing component sends a stop, and
953  another a new drive command at the same time.
954 
955  * @param new_msgid new msgid value
956  */
957 void
958 NavigatorInterface::StopMessage::set_msgid(const uint32_t new_msgid)
959 {
960  data->msgid = new_msgid;
961 }
962 
963 /** Clone this message.
964  * Produces a message of the same type as this message and copies the
965  * data to the new message.
966  * @return clone of this message
967  */
968 Message *
970 {
971  return new NavigatorInterface::StopMessage(this);
972 }
973 /** @class NavigatorInterface::TurnMessage <interfaces/NavigatorInterface.h>
974  * TurnMessage Fawkes BlackBoard Interface Message.
975  *
976 
977  */
978 
979 
980 /** Constructor with initial values.
981  * @param ini_angle initial value for angle
982  * @param ini_velocity initial value for velocity
983  */
984 NavigatorInterface::TurnMessage::TurnMessage(const float ini_angle, const float ini_velocity) : Message("TurnMessage")
985 {
986  data_size = sizeof(TurnMessage_data_t);
987  data_ptr = malloc(data_size);
988  memset(data_ptr, 0, data_size);
989  data = (TurnMessage_data_t *)data_ptr;
991  data->angle = ini_angle;
992  data->velocity = ini_velocity;
993  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
994  enum_map_DriveMode[(int)Forward] = "Forward";
995  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
996  enum_map_DriveMode[(int)Backward] = "Backward";
997  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
998  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
999  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1000  add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
1001  add_fieldinfo(IFT_FLOAT, "velocity", 1, &data->velocity);
1002 }
1003 /** Constructor */
1005 {
1006  data_size = sizeof(TurnMessage_data_t);
1007  data_ptr = malloc(data_size);
1008  memset(data_ptr, 0, data_size);
1009  data = (TurnMessage_data_t *)data_ptr;
1011  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1012  enum_map_DriveMode[(int)Forward] = "Forward";
1013  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1014  enum_map_DriveMode[(int)Backward] = "Backward";
1015  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1016  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1017  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1018  add_fieldinfo(IFT_FLOAT, "angle", 1, &data->angle);
1019  add_fieldinfo(IFT_FLOAT, "velocity", 1, &data->velocity);
1020 }
1021 
1022 /** Destructor */
1024 {
1025  free(data_ptr);
1026 }
1028 /** Copy constructor.
1029  * @param m message to copy from
1030  */
1032 {
1033  data_size = m->data_size;
1034  data_ptr = malloc(data_size);
1036  data = (TurnMessage_data_t *)data_ptr;
1038 }
1039 
1040 /* Methods */
1041 /** Get angle value.
1042  * Angle of the turn.
1043  * @return angle value
1044  */
1045 float
1047 {
1048  return data->angle;
1049 }
1051 /** Get maximum length of angle value.
1052  * @return length of angle value, can be length of the array or number of
1053  * maximum number of characters for a string
1054  */
1055 size_t
1057 {
1058  return 1;
1059 }
1061 /** Set angle value.
1062  * Angle of the turn.
1063  * @param new_angle new angle value
1064  */
1065 void
1066 NavigatorInterface::TurnMessage::set_angle(const float new_angle)
1067 {
1068  data->angle = new_angle;
1069 }
1071 /** Get velocity value.
1072  * The desired turning velocity in rad/s,
1073  set to zero to use default value.
1074  * @return velocity value
1075  */
1076 float
1078 {
1079  return data->velocity;
1080 }
1082 /** Get maximum length of velocity value.
1083  * @return length of velocity value, can be length of the array or number of
1084  * maximum number of characters for a string
1085  */
1086 size_t
1088 {
1089  return 1;
1090 }
1092 /** Set velocity value.
1093  * The desired turning velocity in rad/s,
1094  set to zero to use default value.
1095  * @param new_velocity new velocity value
1096  */
1097 void
1098 NavigatorInterface::TurnMessage::set_velocity(const float new_velocity)
1099 {
1100  data->velocity = new_velocity;
1101 }
1103 /** Clone this message.
1104  * Produces a message of the same type as this message and copies the
1105  * data to the new message.
1106  * @return clone of this message
1107  */
1108 Message *
1110 {
1111  return new NavigatorInterface::TurnMessage(this);
1112 }
1113 /** @class NavigatorInterface::CartesianGotoMessage <interfaces/NavigatorInterface.h>
1114  * CartesianGotoMessage Fawkes BlackBoard Interface Message.
1115  *
1116 
1117  */
1118 
1119 
1120 /** Constructor with initial values.
1121  * @param ini_x initial value for x
1122  * @param ini_y initial value for y
1123  * @param ini_orientation initial value for orientation
1124  */
1125 NavigatorInterface::CartesianGotoMessage::CartesianGotoMessage(const float ini_x, const float ini_y, const float ini_orientation) : Message("CartesianGotoMessage")
1126 {
1127  data_size = sizeof(CartesianGotoMessage_data_t);
1128  data_ptr = malloc(data_size);
1129  memset(data_ptr, 0, data_size);
1130  data = (CartesianGotoMessage_data_t *)data_ptr;
1132  data->x = ini_x;
1133  data->y = ini_y;
1134  data->orientation = ini_orientation;
1135  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1136  enum_map_DriveMode[(int)Forward] = "Forward";
1137  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1138  enum_map_DriveMode[(int)Backward] = "Backward";
1139  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1140  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1141  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1142  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1143  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1144  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1145 }
1146 /** Constructor */
1148 {
1149  data_size = sizeof(CartesianGotoMessage_data_t);
1150  data_ptr = malloc(data_size);
1151  memset(data_ptr, 0, data_size);
1152  data = (CartesianGotoMessage_data_t *)data_ptr;
1154  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1155  enum_map_DriveMode[(int)Forward] = "Forward";
1156  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1157  enum_map_DriveMode[(int)Backward] = "Backward";
1158  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1159  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1160  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1161  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1162  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1163  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1164 }
1165 
1166 /** Destructor */
1168 {
1169  free(data_ptr);
1170 }
1172 /** Copy constructor.
1173  * @param m message to copy from
1174  */
1176 {
1177  data_size = m->data_size;
1178  data_ptr = malloc(data_size);
1180  data = (CartesianGotoMessage_data_t *)data_ptr;
1182 }
1183 
1184 /* Methods */
1185 /** Get x value.
1186  * X-coordinate of the target, in the robot's coordinate system.
1187  * @return x value
1188  */
1189 float
1191 {
1192  return data->x;
1193 }
1195 /** Get maximum length of x value.
1196  * @return length of x value, can be length of the array or number of
1197  * maximum number of characters for a string
1198  */
1199 size_t
1201 {
1202  return 1;
1203 }
1205 /** Set x value.
1206  * X-coordinate of the target, in the robot's coordinate system.
1207  * @param new_x new x value
1208  */
1209 void
1211 {
1212  data->x = new_x;
1213 }
1215 /** Get y value.
1216  * Y-coordinate of the target, in the robot's coordinate system.
1217  * @return y value
1218  */
1219 float
1221 {
1222  return data->y;
1223 }
1225 /** Get maximum length of y value.
1226  * @return length of y value, can be length of the array or number of
1227  * maximum number of characters for a string
1228  */
1229 size_t
1231 {
1232  return 1;
1233 }
1235 /** Set y value.
1236  * Y-coordinate of the target, in the robot's coordinate system.
1237  * @param new_y new y value
1238  */
1239 void
1241 {
1242  data->y = new_y;
1243 }
1245 /** Get orientation value.
1246  * The desired orientation of the robot at the target.
1247  * @return orientation value
1248  */
1249 float
1251 {
1252  return data->orientation;
1253 }
1255 /** Get maximum length of orientation value.
1256  * @return length of orientation value, can be length of the array or number of
1257  * maximum number of characters for a string
1258  */
1259 size_t
1261 {
1262  return 1;
1263 }
1265 /** Set orientation value.
1266  * The desired orientation of the robot at the target.
1267  * @param new_orientation new orientation value
1268  */
1269 void
1271 {
1272  data->orientation = new_orientation;
1273 }
1275 /** Clone this message.
1276  * Produces a message of the same type as this message and copies the
1277  * data to the new message.
1278  * @return clone of this message
1279  */
1280 Message *
1282 {
1284 }
1285 /** @class NavigatorInterface::CartesianGotoWithToleranceMessage <interfaces/NavigatorInterface.h>
1286  * CartesianGotoWithToleranceMessage Fawkes BlackBoard Interface Message.
1287  *
1288 
1289  */
1290 
1291 
1292 /** Constructor with initial values.
1293  * @param ini_x initial value for x
1294  * @param ini_y initial value for y
1295  * @param ini_orientation initial value for orientation
1296  * @param ini_translation_tolerance initial value for translation_tolerance
1297  * @param ini_orientation_tolerance initial value for orientation_tolerance
1298  */
1299 NavigatorInterface::CartesianGotoWithToleranceMessage::CartesianGotoWithToleranceMessage(const float ini_x, const float ini_y, const float ini_orientation, const float ini_translation_tolerance, const float ini_orientation_tolerance) : Message("CartesianGotoWithToleranceMessage")
1300 {
1301  data_size = sizeof(CartesianGotoWithToleranceMessage_data_t);
1302  data_ptr = malloc(data_size);
1303  memset(data_ptr, 0, data_size);
1304  data = (CartesianGotoWithToleranceMessage_data_t *)data_ptr;
1306  data->x = ini_x;
1307  data->y = ini_y;
1308  data->orientation = ini_orientation;
1309  data->translation_tolerance = ini_translation_tolerance;
1310  data->orientation_tolerance = ini_orientation_tolerance;
1311  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1312  enum_map_DriveMode[(int)Forward] = "Forward";
1313  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1314  enum_map_DriveMode[(int)Backward] = "Backward";
1315  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1316  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1317  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1318  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1319  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1320  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1321  add_fieldinfo(IFT_FLOAT, "translation_tolerance", 1, &data->translation_tolerance);
1322  add_fieldinfo(IFT_FLOAT, "orientation_tolerance", 1, &data->orientation_tolerance);
1323 }
1324 /** Constructor */
1326 {
1327  data_size = sizeof(CartesianGotoWithToleranceMessage_data_t);
1328  data_ptr = malloc(data_size);
1329  memset(data_ptr, 0, data_size);
1330  data = (CartesianGotoWithToleranceMessage_data_t *)data_ptr;
1332  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1333  enum_map_DriveMode[(int)Forward] = "Forward";
1334  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1335  enum_map_DriveMode[(int)Backward] = "Backward";
1336  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1337  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1338  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1339  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1340  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1341  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1342  add_fieldinfo(IFT_FLOAT, "translation_tolerance", 1, &data->translation_tolerance);
1343  add_fieldinfo(IFT_FLOAT, "orientation_tolerance", 1, &data->orientation_tolerance);
1344 }
1345 
1346 /** Destructor */
1348 {
1349  free(data_ptr);
1350 }
1352 /** Copy constructor.
1353  * @param m message to copy from
1354  */
1356 {
1357  data_size = m->data_size;
1358  data_ptr = malloc(data_size);
1360  data = (CartesianGotoWithToleranceMessage_data_t *)data_ptr;
1362 }
1363 
1364 /* Methods */
1365 /** Get x value.
1366  * X-coordinate of the target, in the robot's coordinate system.
1367  * @return x value
1368  */
1369 float
1371 {
1372  return data->x;
1373 }
1375 /** Get maximum length of x value.
1376  * @return length of x value, can be length of the array or number of
1377  * maximum number of characters for a string
1378  */
1379 size_t
1381 {
1382  return 1;
1383 }
1385 /** Set x value.
1386  * X-coordinate of the target, in the robot's coordinate system.
1387  * @param new_x new x value
1388  */
1389 void
1391 {
1392  data->x = new_x;
1393 }
1395 /** Get y value.
1396  * Y-coordinate of the target, in the robot's coordinate system.
1397  * @return y value
1398  */
1399 float
1401 {
1402  return data->y;
1403 }
1405 /** Get maximum length of y value.
1406  * @return length of y value, can be length of the array or number of
1407  * maximum number of characters for a string
1408  */
1409 size_t
1411 {
1412  return 1;
1413 }
1415 /** Set y value.
1416  * Y-coordinate of the target, in the robot's coordinate system.
1417  * @param new_y new y value
1418  */
1419 void
1421 {
1422  data->y = new_y;
1423 }
1425 /** Get orientation value.
1426  * The desired orientation of the robot at the target.
1427  * @return orientation value
1428  */
1429 float
1431 {
1432  return data->orientation;
1433 }
1435 /** Get maximum length of orientation value.
1436  * @return length of orientation value, can be length of the array or number of
1437  * maximum number of characters for a string
1438  */
1439 size_t
1441 {
1442  return 1;
1443 }
1445 /** Set orientation value.
1446  * The desired orientation of the robot at the target.
1447  * @param new_orientation new orientation value
1448  */
1449 void
1451 {
1452  data->orientation = new_orientation;
1453 }
1455 /** Get translation_tolerance value.
1456  * The translation tolerance of the target, in meters.
1457  * @return translation_tolerance value
1458  */
1459 float
1461 {
1462  return data->translation_tolerance;
1463 }
1465 /** Get maximum length of translation_tolerance value.
1466  * @return length of translation_tolerance value, can be length of the array or number of
1467  * maximum number of characters for a string
1468  */
1469 size_t
1471 {
1472  return 1;
1473 }
1475 /** Set translation_tolerance value.
1476  * The translation tolerance of the target, in meters.
1477  * @param new_translation_tolerance new translation_tolerance value
1478  */
1479 void
1481 {
1482  data->translation_tolerance = new_translation_tolerance;
1483 }
1485 /** Get orientation_tolerance value.
1486  * The orientation tolerance of the target, in radians.
1487  * @return orientation_tolerance value
1488  */
1489 float
1491 {
1492  return data->orientation_tolerance;
1493 }
1495 /** Get maximum length of orientation_tolerance value.
1496  * @return length of orientation_tolerance value, can be length of the array or number of
1497  * maximum number of characters for a string
1498  */
1499 size_t
1501 {
1502  return 1;
1503 }
1505 /** Set orientation_tolerance value.
1506  * The orientation tolerance of the target, in radians.
1507  * @param new_orientation_tolerance new orientation_tolerance value
1508  */
1509 void
1511 {
1512  data->orientation_tolerance = new_orientation_tolerance;
1513 }
1515 /** Clone this message.
1516  * Produces a message of the same type as this message and copies the
1517  * data to the new message.
1518  * @return clone of this message
1519  */
1520 Message *
1522 {
1524 }
1525 /** @class NavigatorInterface::CartesianGotoWithFrameMessage <interfaces/NavigatorInterface.h>
1526  * CartesianGotoWithFrameMessage Fawkes BlackBoard Interface Message.
1527  *
1528 
1529  */
1530 
1531 
1532 /** Constructor with initial values.
1533  * @param ini_x initial value for x
1534  * @param ini_y initial value for y
1535  * @param ini_orientation initial value for orientation
1536  * @param ini_target_frame initial value for target_frame
1537  */
1538 NavigatorInterface::CartesianGotoWithFrameMessage::CartesianGotoWithFrameMessage(const float ini_x, const float ini_y, const float ini_orientation, const char * ini_target_frame) : Message("CartesianGotoWithFrameMessage")
1539 {
1540  data_size = sizeof(CartesianGotoWithFrameMessage_data_t);
1541  data_ptr = malloc(data_size);
1542  memset(data_ptr, 0, data_size);
1543  data = (CartesianGotoWithFrameMessage_data_t *)data_ptr;
1545  data->x = ini_x;
1546  data->y = ini_y;
1547  data->orientation = ini_orientation;
1548  strncpy(data->target_frame, ini_target_frame, 64-1);
1549  data->target_frame[64-1] = 0;
1550  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1551  enum_map_DriveMode[(int)Forward] = "Forward";
1552  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1553  enum_map_DriveMode[(int)Backward] = "Backward";
1554  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1555  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1556  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1557  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1558  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1559  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1560  add_fieldinfo(IFT_STRING, "target_frame", 64, data->target_frame);
1561 }
1562 /** Constructor */
1564 {
1565  data_size = sizeof(CartesianGotoWithFrameMessage_data_t);
1566  data_ptr = malloc(data_size);
1567  memset(data_ptr, 0, data_size);
1568  data = (CartesianGotoWithFrameMessage_data_t *)data_ptr;
1570  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1571  enum_map_DriveMode[(int)Forward] = "Forward";
1572  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1573  enum_map_DriveMode[(int)Backward] = "Backward";
1574  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1575  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1576  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1577  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1578  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1579  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1580  add_fieldinfo(IFT_STRING, "target_frame", 64, data->target_frame);
1581 }
1582 
1583 /** Destructor */
1585 {
1586  free(data_ptr);
1587 }
1589 /** Copy constructor.
1590  * @param m message to copy from
1591  */
1593 {
1594  data_size = m->data_size;
1595  data_ptr = malloc(data_size);
1597  data = (CartesianGotoWithFrameMessage_data_t *)data_ptr;
1599 }
1600 
1601 /* Methods */
1602 /** Get x value.
1603  * X-coordinate of the target, in the robot's coordinate system.
1604  * @return x value
1605  */
1606 float
1608 {
1609  return data->x;
1610 }
1612 /** Get maximum length of x value.
1613  * @return length of x value, can be length of the array or number of
1614  * maximum number of characters for a string
1615  */
1616 size_t
1618 {
1619  return 1;
1620 }
1622 /** Set x value.
1623  * X-coordinate of the target, in the robot's coordinate system.
1624  * @param new_x new x value
1625  */
1626 void
1628 {
1629  data->x = new_x;
1630 }
1632 /** Get y value.
1633  * Y-coordinate of the target, in the robot's coordinate system.
1634  * @return y value
1635  */
1636 float
1638 {
1639  return data->y;
1640 }
1642 /** Get maximum length of y value.
1643  * @return length of y value, can be length of the array or number of
1644  * maximum number of characters for a string
1645  */
1646 size_t
1648 {
1649  return 1;
1650 }
1652 /** Set y value.
1653  * Y-coordinate of the target, in the robot's coordinate system.
1654  * @param new_y new y value
1655  */
1656 void
1658 {
1659  data->y = new_y;
1660 }
1662 /** Get orientation value.
1663  * The desired orientation of the robot at the target.
1664  * @return orientation value
1665  */
1666 float
1668 {
1669  return data->orientation;
1670 }
1672 /** Get maximum length of orientation value.
1673  * @return length of orientation value, can be length of the array or number of
1674  * maximum number of characters for a string
1675  */
1676 size_t
1678 {
1679  return 1;
1680 }
1682 /** Set orientation value.
1683  * The desired orientation of the robot at the target.
1684  * @param new_orientation new orientation value
1685  */
1686 void
1688 {
1689  data->orientation = new_orientation;
1690 }
1692 /** Get target_frame value.
1693  * The target frame to plan in.
1694  * @return target_frame value
1695  */
1696 char *
1698 {
1699  return data->target_frame;
1700 }
1702 /** Get maximum length of target_frame value.
1703  * @return length of target_frame value, can be length of the array or number of
1704  * maximum number of characters for a string
1705  */
1706 size_t
1708 {
1709  return 64;
1710 }
1712 /** Set target_frame value.
1713  * The target frame to plan in.
1714  * @param new_target_frame new target_frame value
1715  */
1716 void
1718 {
1719  strncpy(data->target_frame, new_target_frame, sizeof(data->target_frame)-1);
1720  data->target_frame[sizeof(data->target_frame)-1] = 0;
1722 
1723 /** Clone this message.
1724  * Produces a message of the same type as this message and copies the
1725  * data to the new message.
1726  * @return clone of this message
1727  */
1728 Message *
1730 {
1732 }
1733 /** @class NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage <interfaces/NavigatorInterface.h>
1734  * CartesianGotoWithFrameWithToleranceMessage Fawkes BlackBoard Interface Message.
1735  *
1736 
1737  */
1738 
1739 
1740 /** Constructor with initial values.
1741  * @param ini_x initial value for x
1742  * @param ini_y initial value for y
1743  * @param ini_orientation initial value for orientation
1744  * @param ini_target_frame initial value for target_frame
1745  * @param ini_translation_tolerance initial value for translation_tolerance
1746  * @param ini_orientation_tolerance initial value for orientation_tolerance
1747  */
1748 NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::CartesianGotoWithFrameWithToleranceMessage(const float ini_x, const float ini_y, const float ini_orientation, const char * ini_target_frame, const float ini_translation_tolerance, const float ini_orientation_tolerance) : Message("CartesianGotoWithFrameWithToleranceMessage")
1749 {
1750  data_size = sizeof(CartesianGotoWithFrameWithToleranceMessage_data_t);
1751  data_ptr = malloc(data_size);
1752  memset(data_ptr, 0, data_size);
1753  data = (CartesianGotoWithFrameWithToleranceMessage_data_t *)data_ptr;
1755  data->x = ini_x;
1756  data->y = ini_y;
1757  data->orientation = ini_orientation;
1758  strncpy(data->target_frame, ini_target_frame, 64-1);
1759  data->target_frame[64-1] = 0;
1760  data->translation_tolerance = ini_translation_tolerance;
1761  data->orientation_tolerance = ini_orientation_tolerance;
1762  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1763  enum_map_DriveMode[(int)Forward] = "Forward";
1764  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1765  enum_map_DriveMode[(int)Backward] = "Backward";
1766  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1767  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1768  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1769  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1770  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1771  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1772  add_fieldinfo(IFT_STRING, "target_frame", 64, data->target_frame);
1773  add_fieldinfo(IFT_FLOAT, "translation_tolerance", 1, &data->translation_tolerance);
1774  add_fieldinfo(IFT_FLOAT, "orientation_tolerance", 1, &data->orientation_tolerance);
1775 }
1776 /** Constructor */
1778 {
1779  data_size = sizeof(CartesianGotoWithFrameWithToleranceMessage_data_t);
1780  data_ptr = malloc(data_size);
1781  memset(data_ptr, 0, data_size);
1782  data = (CartesianGotoWithFrameWithToleranceMessage_data_t *)data_ptr;
1784  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
1785  enum_map_DriveMode[(int)Forward] = "Forward";
1786  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
1787  enum_map_DriveMode[(int)Backward] = "Backward";
1788  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
1789  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
1790  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
1791  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
1792  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
1793  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
1794  add_fieldinfo(IFT_STRING, "target_frame", 64, data->target_frame);
1795  add_fieldinfo(IFT_FLOAT, "translation_tolerance", 1, &data->translation_tolerance);
1796  add_fieldinfo(IFT_FLOAT, "orientation_tolerance", 1, &data->orientation_tolerance);
1797 }
1798 
1799 /** Destructor */
1801 {
1802  free(data_ptr);
1803 }
1805 /** Copy constructor.
1806  * @param m message to copy from
1807  */
1809 {
1810  data_size = m->data_size;
1811  data_ptr = malloc(data_size);
1813  data = (CartesianGotoWithFrameWithToleranceMessage_data_t *)data_ptr;
1815 }
1816 
1817 /* Methods */
1818 /** Get x value.
1819  * X-coordinate of the target, in the robot's coordinate system.
1820  * @return x value
1821  */
1822 float
1824 {
1825  return data->x;
1826 }
1828 /** Get maximum length of x value.
1829  * @return length of x value, can be length of the array or number of
1830  * maximum number of characters for a string
1831  */
1832 size_t
1834 {
1835  return 1;
1836 }
1838 /** Set x value.
1839  * X-coordinate of the target, in the robot's coordinate system.
1840  * @param new_x new x value
1841  */
1842 void
1844 {
1845  data->x = new_x;
1846 }
1848 /** Get y value.
1849  * Y-coordinate of the target, in the robot's coordinate system.
1850  * @return y value
1851  */
1852 float
1854 {
1855  return data->y;
1856 }
1858 /** Get maximum length of y value.
1859  * @return length of y value, can be length of the array or number of
1860  * maximum number of characters for a string
1861  */
1862 size_t
1864 {
1865  return 1;
1866 }
1868 /** Set y value.
1869  * Y-coordinate of the target, in the robot's coordinate system.
1870  * @param new_y new y value
1871  */
1872 void
1874 {
1875  data->y = new_y;
1876 }
1878 /** Get orientation value.
1879  * The desired orientation of the robot at the target.
1880  * @return orientation value
1881  */
1882 float
1884 {
1885  return data->orientation;
1886 }
1888 /** Get maximum length of orientation value.
1889  * @return length of orientation value, can be length of the array or number of
1890  * maximum number of characters for a string
1891  */
1892 size_t
1894 {
1895  return 1;
1896 }
1898 /** Set orientation value.
1899  * The desired orientation of the robot at the target.
1900  * @param new_orientation new orientation value
1901  */
1902 void
1904 {
1905  data->orientation = new_orientation;
1906 }
1908 /** Get target_frame value.
1909  * The target frame to plan in.
1910  * @return target_frame value
1911  */
1912 char *
1914 {
1915  return data->target_frame;
1916 }
1918 /** Get maximum length of target_frame value.
1919  * @return length of target_frame value, can be length of the array or number of
1920  * maximum number of characters for a string
1921  */
1922 size_t
1924 {
1925  return 64;
1926 }
1928 /** Set target_frame value.
1929  * The target frame to plan in.
1930  * @param new_target_frame new target_frame value
1931  */
1932 void
1934 {
1935  strncpy(data->target_frame, new_target_frame, sizeof(data->target_frame)-1);
1936  data->target_frame[sizeof(data->target_frame)-1] = 0;
1938 
1939 /** Get translation_tolerance value.
1940  * The translation tolerance of the target, in meters.
1941  * @return translation_tolerance value
1942  */
1943 float
1945 {
1946  return data->translation_tolerance;
1947 }
1949 /** Get maximum length of translation_tolerance value.
1950  * @return length of translation_tolerance value, can be length of the array or number of
1951  * maximum number of characters for a string
1952  */
1953 size_t
1955 {
1956  return 1;
1957 }
1959 /** Set translation_tolerance value.
1960  * The translation tolerance of the target, in meters.
1961  * @param new_translation_tolerance new translation_tolerance value
1962  */
1963 void
1965 {
1966  data->translation_tolerance = new_translation_tolerance;
1967 }
1969 /** Get orientation_tolerance value.
1970  * The orientation tolerance of the target, in radians.
1971  * @return orientation_tolerance value
1972  */
1973 float
1975 {
1976  return data->orientation_tolerance;
1977 }
1979 /** Get maximum length of orientation_tolerance value.
1980  * @return length of orientation_tolerance value, can be length of the array or number of
1981  * maximum number of characters for a string
1982  */
1983 size_t
1985 {
1986  return 1;
1987 }
1989 /** Set orientation_tolerance value.
1990  * The orientation tolerance of the target, in radians.
1991  * @param new_orientation_tolerance new orientation_tolerance value
1992  */
1993 void
1995 {
1996  data->orientation_tolerance = new_orientation_tolerance;
1997 }
1999 /** Clone this message.
2000  * Produces a message of the same type as this message and copies the
2001  * data to the new message.
2002  * @return clone of this message
2003  */
2004 Message *
2006 {
2008 }
2009 /** @class NavigatorInterface::PolarGotoMessage <interfaces/NavigatorInterface.h>
2010  * PolarGotoMessage Fawkes BlackBoard Interface Message.
2011  *
2012 
2013  */
2014 
2015 
2016 /** Constructor with initial values.
2017  * @param ini_phi initial value for phi
2018  * @param ini_dist initial value for dist
2019  * @param ini_orientation initial value for orientation
2020  */
2021 NavigatorInterface::PolarGotoMessage::PolarGotoMessage(const float ini_phi, const float ini_dist, const float ini_orientation) : Message("PolarGotoMessage")
2022 {
2023  data_size = sizeof(PolarGotoMessage_data_t);
2024  data_ptr = malloc(data_size);
2025  memset(data_ptr, 0, data_size);
2026  data = (PolarGotoMessage_data_t *)data_ptr;
2028  data->phi = ini_phi;
2029  data->dist = ini_dist;
2030  data->orientation = ini_orientation;
2031  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2032  enum_map_DriveMode[(int)Forward] = "Forward";
2033  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2034  enum_map_DriveMode[(int)Backward] = "Backward";
2035  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2036  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2037  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2038  add_fieldinfo(IFT_FLOAT, "phi", 1, &data->phi);
2039  add_fieldinfo(IFT_FLOAT, "dist", 1, &data->dist);
2040  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
2041 }
2042 /** Constructor */
2044 {
2045  data_size = sizeof(PolarGotoMessage_data_t);
2046  data_ptr = malloc(data_size);
2047  memset(data_ptr, 0, data_size);
2048  data = (PolarGotoMessage_data_t *)data_ptr;
2050  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2051  enum_map_DriveMode[(int)Forward] = "Forward";
2052  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2053  enum_map_DriveMode[(int)Backward] = "Backward";
2054  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2055  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2056  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2057  add_fieldinfo(IFT_FLOAT, "phi", 1, &data->phi);
2058  add_fieldinfo(IFT_FLOAT, "dist", 1, &data->dist);
2059  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
2060 }
2061 
2062 /** Destructor */
2064 {
2065  free(data_ptr);
2066 }
2068 /** Copy constructor.
2069  * @param m message to copy from
2070  */
2072 {
2073  data_size = m->data_size;
2074  data_ptr = malloc(data_size);
2076  data = (PolarGotoMessage_data_t *)data_ptr;
2078 }
2079 
2080 /* Methods */
2081 /** Get phi value.
2082  * Angle between the robot's front and the target.
2083  * @return phi value
2084  */
2085 float
2087 {
2088  return data->phi;
2089 }
2091 /** Get maximum length of phi value.
2092  * @return length of phi value, can be length of the array or number of
2093  * maximum number of characters for a string
2094  */
2095 size_t
2097 {
2098  return 1;
2099 }
2101 /** Set phi value.
2102  * Angle between the robot's front and the target.
2103  * @param new_phi new phi value
2104  */
2105 void
2107 {
2108  data->phi = new_phi;
2109 }
2111 /** Get dist value.
2112  * Distance to the target.
2113  * @return dist value
2114  */
2115 float
2117 {
2118  return data->dist;
2119 }
2121 /** Get maximum length of dist value.
2122  * @return length of dist value, can be length of the array or number of
2123  * maximum number of characters for a string
2124  */
2125 size_t
2127 {
2128  return 1;
2129 }
2131 /** Set dist value.
2132  * Distance to the target.
2133  * @param new_dist new dist value
2134  */
2135 void
2137 {
2138  data->dist = new_dist;
2139 }
2141 /** Get orientation value.
2142  * The desired orientation of the robot at the target.
2143  * @return orientation value
2144  */
2145 float
2147 {
2148  return data->orientation;
2149 }
2151 /** Get maximum length of orientation value.
2152  * @return length of orientation value, can be length of the array or number of
2153  * maximum number of characters for a string
2154  */
2155 size_t
2157 {
2158  return 1;
2159 }
2161 /** Set orientation value.
2162  * The desired orientation of the robot at the target.
2163  * @param new_orientation new orientation value
2164  */
2165 void
2166 NavigatorInterface::PolarGotoMessage::set_orientation(const float new_orientation)
2167 {
2168  data->orientation = new_orientation;
2169 }
2171 /** Clone this message.
2172  * Produces a message of the same type as this message and copies the
2173  * data to the new message.
2174  * @return clone of this message
2175  */
2176 Message *
2178 {
2179  return new NavigatorInterface::PolarGotoMessage(this);
2180 }
2181 /** @class NavigatorInterface::PlaceGotoMessage <interfaces/NavigatorInterface.h>
2182  * PlaceGotoMessage Fawkes BlackBoard Interface Message.
2183  *
2184 
2185  */
2186 
2187 
2188 /** Constructor with initial values.
2189  * @param ini_place initial value for place
2190  */
2191 NavigatorInterface::PlaceGotoMessage::PlaceGotoMessage(const char * ini_place) : Message("PlaceGotoMessage")
2192 {
2193  data_size = sizeof(PlaceGotoMessage_data_t);
2194  data_ptr = malloc(data_size);
2195  memset(data_ptr, 0, data_size);
2196  data = (PlaceGotoMessage_data_t *)data_ptr;
2198  strncpy(data->place, ini_place, 64-1);
2199  data->place[64-1] = 0;
2200  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2201  enum_map_DriveMode[(int)Forward] = "Forward";
2202  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2203  enum_map_DriveMode[(int)Backward] = "Backward";
2204  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2205  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2206  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2207  add_fieldinfo(IFT_STRING, "place", 64, data->place);
2208 }
2209 /** Constructor */
2211 {
2212  data_size = sizeof(PlaceGotoMessage_data_t);
2213  data_ptr = malloc(data_size);
2214  memset(data_ptr, 0, data_size);
2215  data = (PlaceGotoMessage_data_t *)data_ptr;
2217  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2218  enum_map_DriveMode[(int)Forward] = "Forward";
2219  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2220  enum_map_DriveMode[(int)Backward] = "Backward";
2221  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2222  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2223  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2224  add_fieldinfo(IFT_STRING, "place", 64, data->place);
2225 }
2226 
2227 /** Destructor */
2229 {
2230  free(data_ptr);
2231 }
2233 /** Copy constructor.
2234  * @param m message to copy from
2235  */
2237 {
2238  data_size = m->data_size;
2239  data_ptr = malloc(data_size);
2241  data = (PlaceGotoMessage_data_t *)data_ptr;
2243 }
2244 
2245 /* Methods */
2246 /** Get place value.
2247  * Place to go to.
2248  * @return place value
2249  */
2250 char *
2252 {
2253  return data->place;
2254 }
2256 /** Get maximum length of place value.
2257  * @return length of place value, can be length of the array or number of
2258  * maximum number of characters for a string
2259  */
2260 size_t
2262 {
2263  return 64;
2264 }
2266 /** Set place value.
2267  * Place to go to.
2268  * @param new_place new place value
2269  */
2270 void
2272 {
2273  strncpy(data->place, new_place, sizeof(data->place)-1);
2274  data->place[sizeof(data->place)-1] = 0;
2276 
2277 /** Clone this message.
2278  * Produces a message of the same type as this message and copies the
2279  * data to the new message.
2280  * @return clone of this message
2281  */
2282 Message *
2284 {
2285  return new NavigatorInterface::PlaceGotoMessage(this);
2286 }
2287 /** @class NavigatorInterface::PlaceWithOriGotoMessage <interfaces/NavigatorInterface.h>
2288  * PlaceWithOriGotoMessage Fawkes BlackBoard Interface Message.
2289  *
2290 
2291  */
2292 
2293 
2294 /** Constructor with initial values.
2295  * @param ini_place initial value for place
2296  * @param ini_orientation initial value for orientation
2297  */
2298 NavigatorInterface::PlaceWithOriGotoMessage::PlaceWithOriGotoMessage(const char * ini_place, const float ini_orientation) : Message("PlaceWithOriGotoMessage")
2299 {
2300  data_size = sizeof(PlaceWithOriGotoMessage_data_t);
2301  data_ptr = malloc(data_size);
2302  memset(data_ptr, 0, data_size);
2303  data = (PlaceWithOriGotoMessage_data_t *)data_ptr;
2305  strncpy(data->place, ini_place, 64-1);
2306  data->place[64-1] = 0;
2307  data->orientation = ini_orientation;
2308  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2309  enum_map_DriveMode[(int)Forward] = "Forward";
2310  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2311  enum_map_DriveMode[(int)Backward] = "Backward";
2312  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2313  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2314  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2315  add_fieldinfo(IFT_STRING, "place", 64, data->place);
2316  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
2317 }
2318 /** Constructor */
2320 {
2321  data_size = sizeof(PlaceWithOriGotoMessage_data_t);
2322  data_ptr = malloc(data_size);
2323  memset(data_ptr, 0, data_size);
2324  data = (PlaceWithOriGotoMessage_data_t *)data_ptr;
2326  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2327  enum_map_DriveMode[(int)Forward] = "Forward";
2328  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2329  enum_map_DriveMode[(int)Backward] = "Backward";
2330  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2331  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2332  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2333  add_fieldinfo(IFT_STRING, "place", 64, data->place);
2334  add_fieldinfo(IFT_FLOAT, "orientation", 1, &data->orientation);
2335 }
2336 
2337 /** Destructor */
2339 {
2340  free(data_ptr);
2341 }
2343 /** Copy constructor.
2344  * @param m message to copy from
2345  */
2347 {
2348  data_size = m->data_size;
2349  data_ptr = malloc(data_size);
2351  data = (PlaceWithOriGotoMessage_data_t *)data_ptr;
2353 }
2354 
2355 /* Methods */
2356 /** Get place value.
2357  * Place to go to.
2358  * @return place value
2359  */
2360 char *
2362 {
2363  return data->place;
2364 }
2366 /** Get maximum length of place value.
2367  * @return length of place value, can be length of the array or number of
2368  * maximum number of characters for a string
2369  */
2370 size_t
2372 {
2373  return 64;
2374 }
2376 /** Set place value.
2377  * Place to go to.
2378  * @param new_place new place value
2379  */
2380 void
2382 {
2383  strncpy(data->place, new_place, sizeof(data->place)-1);
2384  data->place[sizeof(data->place)-1] = 0;
2386 
2387 /** Get orientation value.
2388  * The desired orientation of the robot at the target.
2389  * @return orientation value
2390  */
2391 float
2393 {
2394  return data->orientation;
2395 }
2397 /** Get maximum length of orientation value.
2398  * @return length of orientation value, can be length of the array or number of
2399  * maximum number of characters for a string
2400  */
2401 size_t
2403 {
2404  return 1;
2405 }
2407 /** Set orientation value.
2408  * The desired orientation of the robot at the target.
2409  * @param new_orientation new orientation value
2410  */
2411 void
2413 {
2414  data->orientation = new_orientation;
2415 }
2417 /** Clone this message.
2418  * Produces a message of the same type as this message and copies the
2419  * data to the new message.
2420  * @return clone of this message
2421  */
2422 Message *
2424 {
2426 }
2427 /** @class NavigatorInterface::ObstacleMessage <interfaces/NavigatorInterface.h>
2428  * ObstacleMessage Fawkes BlackBoard Interface Message.
2429  *
2430 
2431  */
2432 
2433 
2434 /** Constructor with initial values.
2435  * @param ini_x initial value for x
2436  * @param ini_y initial value for y
2437  * @param ini_width initial value for width
2438  */
2439 NavigatorInterface::ObstacleMessage::ObstacleMessage(const float ini_x, const float ini_y, const float ini_width) : Message("ObstacleMessage")
2440 {
2441  data_size = sizeof(ObstacleMessage_data_t);
2442  data_ptr = malloc(data_size);
2443  memset(data_ptr, 0, data_size);
2444  data = (ObstacleMessage_data_t *)data_ptr;
2446  data->x = ini_x;
2447  data->y = ini_y;
2448  data->width = ini_width;
2449  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2450  enum_map_DriveMode[(int)Forward] = "Forward";
2451  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2452  enum_map_DriveMode[(int)Backward] = "Backward";
2453  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2454  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2455  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2456  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
2457  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
2458  add_fieldinfo(IFT_FLOAT, "width", 1, &data->width);
2459 }
2460 /** Constructor */
2462 {
2463  data_size = sizeof(ObstacleMessage_data_t);
2464  data_ptr = malloc(data_size);
2465  memset(data_ptr, 0, data_size);
2466  data = (ObstacleMessage_data_t *)data_ptr;
2468  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2469  enum_map_DriveMode[(int)Forward] = "Forward";
2470  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2471  enum_map_DriveMode[(int)Backward] = "Backward";
2472  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2473  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2474  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2475  add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
2476  add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
2477  add_fieldinfo(IFT_FLOAT, "width", 1, &data->width);
2478 }
2479 
2480 /** Destructor */
2482 {
2483  free(data_ptr);
2484 }
2486 /** Copy constructor.
2487  * @param m message to copy from
2488  */
2490 {
2491  data_size = m->data_size;
2492  data_ptr = malloc(data_size);
2494  data = (ObstacleMessage_data_t *)data_ptr;
2496 }
2497 
2498 /* Methods */
2499 /** Get x value.
2500  * X-coordinate of the obstacle.
2501  * @return x value
2502  */
2503 float
2505 {
2506  return data->x;
2507 }
2509 /** Get maximum length of x value.
2510  * @return length of x value, can be length of the array or number of
2511  * maximum number of characters for a string
2512  */
2513 size_t
2515 {
2516  return 1;
2517 }
2519 /** Set x value.
2520  * X-coordinate of the obstacle.
2521  * @param new_x new x value
2522  */
2523 void
2525 {
2526  data->x = new_x;
2527 }
2529 /** Get y value.
2530  * Y-coordinate of the obstacle.
2531  * @return y value
2532  */
2533 float
2535 {
2536  return data->y;
2537 }
2539 /** Get maximum length of y value.
2540  * @return length of y value, can be length of the array or number of
2541  * maximum number of characters for a string
2542  */
2543 size_t
2545 {
2546  return 1;
2547 }
2549 /** Set y value.
2550  * Y-coordinate of the obstacle.
2551  * @param new_y new y value
2552  */
2553 void
2555 {
2556  data->y = new_y;
2557 }
2559 /** Get width value.
2560  * Width of the obstacle.
2561  * @return width value
2562  */
2563 float
2565 {
2566  return data->width;
2567 }
2569 /** Get maximum length of width value.
2570  * @return length of width value, can be length of the array or number of
2571  * maximum number of characters for a string
2572  */
2573 size_t
2575 {
2576  return 1;
2577 }
2579 /** Set width value.
2580  * Width of the obstacle.
2581  * @param new_width new width value
2582  */
2583 void
2585 {
2586  data->width = new_width;
2587 }
2589 /** Clone this message.
2590  * Produces a message of the same type as this message and copies the
2591  * data to the new message.
2592  * @return clone of this message
2593  */
2594 Message *
2596 {
2597  return new NavigatorInterface::ObstacleMessage(this);
2598 }
2599 /** @class NavigatorInterface::ResetOdometryMessage <interfaces/NavigatorInterface.h>
2600  * ResetOdometryMessage Fawkes BlackBoard Interface Message.
2601  *
2602 
2603  */
2604 
2605 
2606 /** Constructor */
2608 {
2609  data_size = sizeof(ResetOdometryMessage_data_t);
2610  data_ptr = malloc(data_size);
2611  memset(data_ptr, 0, data_size);
2612  data = (ResetOdometryMessage_data_t *)data_ptr;
2614  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2615  enum_map_DriveMode[(int)Forward] = "Forward";
2616  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2617  enum_map_DriveMode[(int)Backward] = "Backward";
2618  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2619  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2620  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2621 }
2622 
2623 /** Destructor */
2625 {
2626  free(data_ptr);
2627 }
2629 /** Copy constructor.
2630  * @param m message to copy from
2631  */
2633 {
2634  data_size = m->data_size;
2635  data_ptr = malloc(data_size);
2637  data = (ResetOdometryMessage_data_t *)data_ptr;
2639 }
2640 
2641 /* Methods */
2642 /** Clone this message.
2643  * Produces a message of the same type as this message and copies the
2644  * data to the new message.
2645  * @return clone of this message
2646  */
2647 Message *
2649 {
2651 }
2652 /** @class NavigatorInterface::SetMaxVelocityMessage <interfaces/NavigatorInterface.h>
2653  * SetMaxVelocityMessage Fawkes BlackBoard Interface Message.
2654  *
2655 
2656  */
2657 
2658 
2659 /** Constructor with initial values.
2660  * @param ini_max_velocity initial value for max_velocity
2661  */
2662 NavigatorInterface::SetMaxVelocityMessage::SetMaxVelocityMessage(const float ini_max_velocity) : Message("SetMaxVelocityMessage")
2663 {
2664  data_size = sizeof(SetMaxVelocityMessage_data_t);
2665  data_ptr = malloc(data_size);
2666  memset(data_ptr, 0, data_size);
2667  data = (SetMaxVelocityMessage_data_t *)data_ptr;
2669  data->max_velocity = ini_max_velocity;
2670  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2671  enum_map_DriveMode[(int)Forward] = "Forward";
2672  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2673  enum_map_DriveMode[(int)Backward] = "Backward";
2674  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2675  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2676  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2677  add_fieldinfo(IFT_FLOAT, "max_velocity", 1, &data->max_velocity);
2678 }
2679 /** Constructor */
2681 {
2682  data_size = sizeof(SetMaxVelocityMessage_data_t);
2683  data_ptr = malloc(data_size);
2684  memset(data_ptr, 0, data_size);
2685  data = (SetMaxVelocityMessage_data_t *)data_ptr;
2687  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2688  enum_map_DriveMode[(int)Forward] = "Forward";
2689  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2690  enum_map_DriveMode[(int)Backward] = "Backward";
2691  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2692  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2693  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2694  add_fieldinfo(IFT_FLOAT, "max_velocity", 1, &data->max_velocity);
2695 }
2696 
2697 /** Destructor */
2699 {
2700  free(data_ptr);
2701 }
2703 /** Copy constructor.
2704  * @param m message to copy from
2705  */
2707 {
2708  data_size = m->data_size;
2709  data_ptr = malloc(data_size);
2711  data = (SetMaxVelocityMessage_data_t *)data_ptr;
2713 }
2714 
2715 /* Methods */
2716 /** Get max_velocity value.
2717  * Maximum velocity
2718  * @return max_velocity value
2719  */
2720 float
2722 {
2723  return data->max_velocity;
2724 }
2726 /** Get maximum length of max_velocity value.
2727  * @return length of max_velocity value, can be length of the array or number of
2728  * maximum number of characters for a string
2729  */
2730 size_t
2732 {
2733  return 1;
2734 }
2736 /** Set max_velocity value.
2737  * Maximum velocity
2738  * @param new_max_velocity new max_velocity value
2739  */
2740 void
2742 {
2743  data->max_velocity = new_max_velocity;
2744 }
2746 /** Clone this message.
2747  * Produces a message of the same type as this message and copies the
2748  * data to the new message.
2749  * @return clone of this message
2750  */
2751 Message *
2753 {
2755 }
2756 /** @class NavigatorInterface::SetMaxRotationMessage <interfaces/NavigatorInterface.h>
2757  * SetMaxRotationMessage Fawkes BlackBoard Interface Message.
2758  *
2759 
2760  */
2761 
2762 
2763 /** Constructor with initial values.
2764  * @param ini_max_rotation initial value for max_rotation
2765  */
2766 NavigatorInterface::SetMaxRotationMessage::SetMaxRotationMessage(const float ini_max_rotation) : Message("SetMaxRotationMessage")
2767 {
2768  data_size = sizeof(SetMaxRotationMessage_data_t);
2769  data_ptr = malloc(data_size);
2770  memset(data_ptr, 0, data_size);
2771  data = (SetMaxRotationMessage_data_t *)data_ptr;
2773  data->max_rotation = ini_max_rotation;
2774  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2775  enum_map_DriveMode[(int)Forward] = "Forward";
2776  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2777  enum_map_DriveMode[(int)Backward] = "Backward";
2778  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2779  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2780  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2781  add_fieldinfo(IFT_FLOAT, "max_rotation", 1, &data->max_rotation);
2782 }
2783 /** Constructor */
2785 {
2786  data_size = sizeof(SetMaxRotationMessage_data_t);
2787  data_ptr = malloc(data_size);
2788  memset(data_ptr, 0, data_size);
2789  data = (SetMaxRotationMessage_data_t *)data_ptr;
2791  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2792  enum_map_DriveMode[(int)Forward] = "Forward";
2793  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2794  enum_map_DriveMode[(int)Backward] = "Backward";
2795  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2796  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2797  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2798  add_fieldinfo(IFT_FLOAT, "max_rotation", 1, &data->max_rotation);
2799 }
2800 
2801 /** Destructor */
2803 {
2804  free(data_ptr);
2805 }
2807 /** Copy constructor.
2808  * @param m message to copy from
2809  */
2811 {
2812  data_size = m->data_size;
2813  data_ptr = malloc(data_size);
2815  data = (SetMaxRotationMessage_data_t *)data_ptr;
2817 }
2818 
2819 /* Methods */
2820 /** Get max_rotation value.
2821  * Maximum rotation velocity
2822  * @return max_rotation value
2823  */
2824 float
2826 {
2827  return data->max_rotation;
2828 }
2830 /** Get maximum length of max_rotation value.
2831  * @return length of max_rotation value, can be length of the array or number of
2832  * maximum number of characters for a string
2833  */
2834 size_t
2836 {
2837  return 1;
2838 }
2840 /** Set max_rotation value.
2841  * Maximum rotation velocity
2842  * @param new_max_rotation new max_rotation value
2843  */
2844 void
2846 {
2847  data->max_rotation = new_max_rotation;
2848 }
2850 /** Clone this message.
2851  * Produces a message of the same type as this message and copies the
2852  * data to the new message.
2853  * @return clone of this message
2854  */
2855 Message *
2857 {
2859 }
2860 /** @class NavigatorInterface::SetEscapingMessage <interfaces/NavigatorInterface.h>
2861  * SetEscapingMessage Fawkes BlackBoard Interface Message.
2862  *
2863 
2864  */
2865 
2866 
2867 /** Constructor with initial values.
2868  * @param ini_escaping_enabled initial value for escaping_enabled
2869  */
2870 NavigatorInterface::SetEscapingMessage::SetEscapingMessage(const bool ini_escaping_enabled) : Message("SetEscapingMessage")
2871 {
2872  data_size = sizeof(SetEscapingMessage_data_t);
2873  data_ptr = malloc(data_size);
2874  memset(data_ptr, 0, data_size);
2875  data = (SetEscapingMessage_data_t *)data_ptr;
2877  data->escaping_enabled = ini_escaping_enabled;
2878  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2879  enum_map_DriveMode[(int)Forward] = "Forward";
2880  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2881  enum_map_DriveMode[(int)Backward] = "Backward";
2882  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2883  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2884  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2885  add_fieldinfo(IFT_BOOL, "escaping_enabled", 1, &data->escaping_enabled);
2886 }
2887 /** Constructor */
2889 {
2890  data_size = sizeof(SetEscapingMessage_data_t);
2891  data_ptr = malloc(data_size);
2892  memset(data_ptr, 0, data_size);
2893  data = (SetEscapingMessage_data_t *)data_ptr;
2895  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2896  enum_map_DriveMode[(int)Forward] = "Forward";
2897  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2898  enum_map_DriveMode[(int)Backward] = "Backward";
2899  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2900  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2901  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2902  add_fieldinfo(IFT_BOOL, "escaping_enabled", 1, &data->escaping_enabled);
2903 }
2904 
2905 /** Destructor */
2907 {
2908  free(data_ptr);
2909 }
2911 /** Copy constructor.
2912  * @param m message to copy from
2913  */
2915 {
2916  data_size = m->data_size;
2917  data_ptr = malloc(data_size);
2919  data = (SetEscapingMessage_data_t *)data_ptr;
2921 }
2922 
2923 /* Methods */
2924 /** Get escaping_enabled value.
2925  * This is used for navigation components with integrated collision avoidance,
2926  to check whether the navigator should stop when an obstacle obstructs the path, or if it should escape.
2927  * @return escaping_enabled value
2928  */
2929 bool
2931 {
2932  return data->escaping_enabled;
2933 }
2935 /** Get maximum length of escaping_enabled value.
2936  * @return length of escaping_enabled value, can be length of the array or number of
2937  * maximum number of characters for a string
2938  */
2939 size_t
2941 {
2942  return 1;
2943 }
2945 /** Set escaping_enabled value.
2946  * This is used for navigation components with integrated collision avoidance,
2947  to check whether the navigator should stop when an obstacle obstructs the path, or if it should escape.
2948  * @param new_escaping_enabled new escaping_enabled value
2949  */
2950 void
2951 NavigatorInterface::SetEscapingMessage::set_escaping_enabled(const bool new_escaping_enabled)
2952 {
2953  data->escaping_enabled = new_escaping_enabled;
2954 }
2956 /** Clone this message.
2957  * Produces a message of the same type as this message and copies the
2958  * data to the new message.
2959  * @return clone of this message
2960  */
2961 Message *
2963 {
2964  return new NavigatorInterface::SetEscapingMessage(this);
2965 }
2966 /** @class NavigatorInterface::SetSecurityDistanceMessage <interfaces/NavigatorInterface.h>
2967  * SetSecurityDistanceMessage Fawkes BlackBoard Interface Message.
2968  *
2969 
2970  */
2971 
2972 
2973 /** Constructor with initial values.
2974  * @param ini_security_distance initial value for security_distance
2975  */
2976 NavigatorInterface::SetSecurityDistanceMessage::SetSecurityDistanceMessage(const float ini_security_distance) : Message("SetSecurityDistanceMessage")
2977 {
2978  data_size = sizeof(SetSecurityDistanceMessage_data_t);
2979  data_ptr = malloc(data_size);
2980  memset(data_ptr, 0, data_size);
2981  data = (SetSecurityDistanceMessage_data_t *)data_ptr;
2983  data->security_distance = ini_security_distance;
2984  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
2985  enum_map_DriveMode[(int)Forward] = "Forward";
2986  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
2987  enum_map_DriveMode[(int)Backward] = "Backward";
2988  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
2989  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
2990  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
2991  add_fieldinfo(IFT_FLOAT, "security_distance", 1, &data->security_distance);
2992 }
2993 /** Constructor */
2995 {
2996  data_size = sizeof(SetSecurityDistanceMessage_data_t);
2997  data_ptr = malloc(data_size);
2998  memset(data_ptr, 0, data_size);
2999  data = (SetSecurityDistanceMessage_data_t *)data_ptr;
3001  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3002  enum_map_DriveMode[(int)Forward] = "Forward";
3003  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3004  enum_map_DriveMode[(int)Backward] = "Backward";
3005  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3006  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3007  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3008  add_fieldinfo(IFT_FLOAT, "security_distance", 1, &data->security_distance);
3009 }
3010 
3011 /** Destructor */
3013 {
3014  free(data_ptr);
3015 }
3017 /** Copy constructor.
3018  * @param m message to copy from
3019  */
3021 {
3022  data_size = m->data_size;
3023  data_ptr = malloc(data_size);
3025  data = (SetSecurityDistanceMessage_data_t *)data_ptr;
3027 }
3028 
3029 /* Methods */
3030 /** Get security_distance value.
3031  * Security distance to keep to obstacles
3032  * @return security_distance value
3033  */
3034 float
3036 {
3037  return data->security_distance;
3038 }
3040 /** Get maximum length of security_distance value.
3041  * @return length of security_distance value, can be length of the array or number of
3042  * maximum number of characters for a string
3043  */
3044 size_t
3046 {
3047  return 1;
3048 }
3050 /** Set security_distance value.
3051  * Security distance to keep to obstacles
3052  * @param new_security_distance new security_distance value
3053  */
3054 void
3056 {
3057  data->security_distance = new_security_distance;
3058 }
3060 /** Clone this message.
3061  * Produces a message of the same type as this message and copies the
3062  * data to the new message.
3063  * @return clone of this message
3064  */
3065 Message *
3067 {
3069 }
3070 /** @class NavigatorInterface::SetDriveModeMessage <interfaces/NavigatorInterface.h>
3071  * SetDriveModeMessage Fawkes BlackBoard Interface Message.
3072  *
3073 
3074  */
3075 
3076 
3077 /** Constructor with initial values.
3078  * @param ini_drive_mode initial value for drive_mode
3079  */
3080 NavigatorInterface::SetDriveModeMessage::SetDriveModeMessage(const DriveMode ini_drive_mode) : Message("SetDriveModeMessage")
3081 {
3082  data_size = sizeof(SetDriveModeMessage_data_t);
3083  data_ptr = malloc(data_size);
3084  memset(data_ptr, 0, data_size);
3085  data = (SetDriveModeMessage_data_t *)data_ptr;
3087  data->drive_mode = ini_drive_mode;
3088  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3089  enum_map_DriveMode[(int)Forward] = "Forward";
3090  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3091  enum_map_DriveMode[(int)Backward] = "Backward";
3092  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3093  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3094  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3095  add_fieldinfo(IFT_ENUM, "drive_mode", 1, &data->drive_mode, "DriveMode", &enum_map_DriveMode);
3096 }
3097 /** Constructor */
3099 {
3100  data_size = sizeof(SetDriveModeMessage_data_t);
3101  data_ptr = malloc(data_size);
3102  memset(data_ptr, 0, data_size);
3103  data = (SetDriveModeMessage_data_t *)data_ptr;
3105  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3106  enum_map_DriveMode[(int)Forward] = "Forward";
3107  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3108  enum_map_DriveMode[(int)Backward] = "Backward";
3109  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3110  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3111  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3112  add_fieldinfo(IFT_ENUM, "drive_mode", 1, &data->drive_mode, "DriveMode", &enum_map_DriveMode);
3113 }
3114 
3115 /** Destructor */
3117 {
3118  free(data_ptr);
3119 }
3121 /** Copy constructor.
3122  * @param m message to copy from
3123  */
3125 {
3126  data_size = m->data_size;
3127  data_ptr = malloc(data_size);
3129  data = (SetDriveModeMessage_data_t *)data_ptr;
3131 }
3132 
3133 /* Methods */
3134 /** Get drive_mode value.
3135  * Current drive mode
3136  * @return drive_mode value
3137  */
3140 {
3141  return (NavigatorInterface::DriveMode)data->drive_mode;
3142 }
3144 /** Get maximum length of drive_mode value.
3145  * @return length of drive_mode value, can be length of the array or number of
3146  * maximum number of characters for a string
3147  */
3148 size_t
3150 {
3151  return 1;
3152 }
3154 /** Set drive_mode value.
3155  * Current drive mode
3156  * @param new_drive_mode new drive_mode value
3157  */
3158 void
3160 {
3161  data->drive_mode = new_drive_mode;
3162 }
3164 /** Clone this message.
3165  * Produces a message of the same type as this message and copies the
3166  * data to the new message.
3167  * @return clone of this message
3168  */
3169 Message *
3171 {
3172  return new NavigatorInterface::SetDriveModeMessage(this);
3173 }
3174 /** @class NavigatorInterface::SetStopAtTargetMessage <interfaces/NavigatorInterface.h>
3175  * SetStopAtTargetMessage Fawkes BlackBoard Interface Message.
3176  *
3177 
3178  */
3179 
3180 
3181 /** Constructor with initial values.
3182  * @param ini_stop_at_target initial value for stop_at_target
3183  */
3184 NavigatorInterface::SetStopAtTargetMessage::SetStopAtTargetMessage(const bool ini_stop_at_target) : Message("SetStopAtTargetMessage")
3185 {
3186  data_size = sizeof(SetStopAtTargetMessage_data_t);
3187  data_ptr = malloc(data_size);
3188  memset(data_ptr, 0, data_size);
3189  data = (SetStopAtTargetMessage_data_t *)data_ptr;
3191  data->stop_at_target = ini_stop_at_target;
3192  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3193  enum_map_DriveMode[(int)Forward] = "Forward";
3194  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3195  enum_map_DriveMode[(int)Backward] = "Backward";
3196  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3197  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3198  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3199  add_fieldinfo(IFT_BOOL, "stop_at_target", 1, &data->stop_at_target);
3200 }
3201 /** Constructor */
3203 {
3204  data_size = sizeof(SetStopAtTargetMessage_data_t);
3205  data_ptr = malloc(data_size);
3206  memset(data_ptr, 0, data_size);
3207  data = (SetStopAtTargetMessage_data_t *)data_ptr;
3209  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3210  enum_map_DriveMode[(int)Forward] = "Forward";
3211  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3212  enum_map_DriveMode[(int)Backward] = "Backward";
3213  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3214  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3215  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3216  add_fieldinfo(IFT_BOOL, "stop_at_target", 1, &data->stop_at_target);
3217 }
3218 
3219 /** Destructor */
3221 {
3222  free(data_ptr);
3223 }
3225 /** Copy constructor.
3226  * @param m message to copy from
3227  */
3229 {
3230  data_size = m->data_size;
3231  data_ptr = malloc(data_size);
3233  data = (SetStopAtTargetMessage_data_t *)data_ptr;
3235 }
3236 
3237 /* Methods */
3238 /** Get stop_at_target value.
3239  * Stop when target is reached?
3240  * @return stop_at_target value
3241  */
3242 bool
3244 {
3245  return data->stop_at_target;
3246 }
3248 /** Get maximum length of stop_at_target value.
3249  * @return length of stop_at_target value, can be length of the array or number of
3250  * maximum number of characters for a string
3251  */
3252 size_t
3254 {
3255  return 1;
3256 }
3258 /** Set stop_at_target value.
3259  * Stop when target is reached?
3260  * @param new_stop_at_target new stop_at_target value
3261  */
3262 void
3264 {
3265  data->stop_at_target = new_stop_at_target;
3266 }
3268 /** Clone this message.
3269  * Produces a message of the same type as this message and copies the
3270  * data to the new message.
3271  * @return clone of this message
3272  */
3273 Message *
3275 {
3277 }
3278 /** @class NavigatorInterface::SetOrientationModeMessage <interfaces/NavigatorInterface.h>
3279  * SetOrientationModeMessage Fawkes BlackBoard Interface Message.
3280  *
3281 
3282  */
3283 
3284 
3285 /** Constructor with initial values.
3286  * @param ini_orientation_mode initial value for orientation_mode
3287  */
3288 NavigatorInterface::SetOrientationModeMessage::SetOrientationModeMessage(const OrientationMode ini_orientation_mode) : Message("SetOrientationModeMessage")
3289 {
3290  data_size = sizeof(SetOrientationModeMessage_data_t);
3291  data_ptr = malloc(data_size);
3292  memset(data_ptr, 0, data_size);
3293  data = (SetOrientationModeMessage_data_t *)data_ptr;
3295  data->orientation_mode = ini_orientation_mode;
3296  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3297  enum_map_DriveMode[(int)Forward] = "Forward";
3298  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3299  enum_map_DriveMode[(int)Backward] = "Backward";
3300  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3301  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3302  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3303  add_fieldinfo(IFT_ENUM, "orientation_mode", 1, &data->orientation_mode, "OrientationMode", &enum_map_OrientationMode);
3304 }
3305 /** Constructor */
3307 {
3308  data_size = sizeof(SetOrientationModeMessage_data_t);
3309  data_ptr = malloc(data_size);
3310  memset(data_ptr, 0, data_size);
3311  data = (SetOrientationModeMessage_data_t *)data_ptr;
3313  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3314  enum_map_DriveMode[(int)Forward] = "Forward";
3315  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3316  enum_map_DriveMode[(int)Backward] = "Backward";
3317  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3318  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3319  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3320  add_fieldinfo(IFT_ENUM, "orientation_mode", 1, &data->orientation_mode, "OrientationMode", &enum_map_OrientationMode);
3321 }
3322 
3323 /** Destructor */
3325 {
3326  free(data_ptr);
3327 }
3329 /** Copy constructor.
3330  * @param m message to copy from
3331  */
3333 {
3334  data_size = m->data_size;
3335  data_ptr = malloc(data_size);
3337  data = (SetOrientationModeMessage_data_t *)data_ptr;
3339 }
3340 
3341 /* Methods */
3342 /** Get orientation_mode value.
3343  * Mode how/when to orientate if orientation is given
3344  * @return orientation_mode value
3345  */
3348 {
3349  return (NavigatorInterface::OrientationMode)data->orientation_mode;
3350 }
3352 /** Get maximum length of orientation_mode value.
3353  * @return length of orientation_mode value, can be length of the array or number of
3354  * maximum number of characters for a string
3355  */
3356 size_t
3358 {
3359  return 1;
3360 }
3362 /** Set orientation_mode value.
3363  * Mode how/when to orientate if orientation is given
3364  * @param new_orientation_mode new orientation_mode value
3365  */
3366 void
3368 {
3369  data->orientation_mode = new_orientation_mode;
3370 }
3372 /** Clone this message.
3373  * Produces a message of the same type as this message and copies the
3374  * data to the new message.
3375  * @return clone of this message
3376  */
3377 Message *
3379 {
3381 }
3382 /** @class NavigatorInterface::ResetParametersMessage <interfaces/NavigatorInterface.h>
3383  * ResetParametersMessage Fawkes BlackBoard Interface Message.
3384  *
3385 
3386  */
3387 
3388 
3389 /** Constructor */
3391 {
3392  data_size = sizeof(ResetParametersMessage_data_t);
3393  data_ptr = malloc(data_size);
3394  memset(data_ptr, 0, data_size);
3395  data = (ResetParametersMessage_data_t *)data_ptr;
3397  enum_map_DriveMode[(int)MovingNotAllowed] = "MovingNotAllowed";
3398  enum_map_DriveMode[(int)Forward] = "Forward";
3399  enum_map_DriveMode[(int)AllowBackward] = "AllowBackward";
3400  enum_map_DriveMode[(int)Backward] = "Backward";
3401  enum_map_DriveMode[(int)ESCAPE] = "ESCAPE";
3402  enum_map_OrientationMode[(int)OrientAtTarget] = "OrientAtTarget";
3403  enum_map_OrientationMode[(int)OrientDuringTravel] = "OrientDuringTravel";
3404 }
3405 
3406 /** Destructor */
3408 {
3409  free(data_ptr);
3410 }
3412 /** Copy constructor.
3413  * @param m message to copy from
3414  */
3416 {
3417  data_size = m->data_size;
3418  data_ptr = malloc(data_size);
3420  data = (ResetParametersMessage_data_t *)data_ptr;
3422 }
3423 
3424 /* Methods */
3425 /** Clone this message.
3426  * Produces a message of the same type as this message and copies the
3427  * data to the new message.
3428  * @return clone of this message
3429  */
3430 Message *
3432 {
3434 }
3435 /** Check if message is valid and can be enqueued.
3436  * @param message Message to check
3437  * @return true if the message is valid, false otherwise.
3438  */
3439 bool
3440 NavigatorInterface::message_valid(const Message *message) const
3441 {
3442  const StopMessage *m0 = dynamic_cast<const StopMessage *>(message);
3443  if ( m0 != NULL ) {
3444  return true;
3445  }
3446  const TurnMessage *m1 = dynamic_cast<const TurnMessage *>(message);
3447  if ( m1 != NULL ) {
3448  return true;
3449  }
3450  const CartesianGotoMessage *m2 = dynamic_cast<const CartesianGotoMessage *>(message);
3451  if ( m2 != NULL ) {
3452  return true;
3453  }
3454  const CartesianGotoWithToleranceMessage *m3 = dynamic_cast<const CartesianGotoWithToleranceMessage *>(message);
3455  if ( m3 != NULL ) {
3456  return true;
3457  }
3458  const CartesianGotoWithFrameMessage *m4 = dynamic_cast<const CartesianGotoWithFrameMessage *>(message);
3459  if ( m4 != NULL ) {
3460  return true;
3461  }
3462  const CartesianGotoWithFrameWithToleranceMessage *m5 = dynamic_cast<const CartesianGotoWithFrameWithToleranceMessage *>(message);
3463  if ( m5 != NULL ) {
3464  return true;
3465  }
3466  const PolarGotoMessage *m6 = dynamic_cast<const PolarGotoMessage *>(message);
3467  if ( m6 != NULL ) {
3468  return true;
3469  }
3470  const PlaceGotoMessage *m7 = dynamic_cast<const PlaceGotoMessage *>(message);
3471  if ( m7 != NULL ) {
3472  return true;
3473  }
3474  const PlaceWithOriGotoMessage *m8 = dynamic_cast<const PlaceWithOriGotoMessage *>(message);
3475  if ( m8 != NULL ) {
3476  return true;
3477  }
3478  const ObstacleMessage *m9 = dynamic_cast<const ObstacleMessage *>(message);
3479  if ( m9 != NULL ) {
3480  return true;
3481  }
3482  const ResetOdometryMessage *m10 = dynamic_cast<const ResetOdometryMessage *>(message);
3483  if ( m10 != NULL ) {
3484  return true;
3485  }
3486  const SetMaxVelocityMessage *m11 = dynamic_cast<const SetMaxVelocityMessage *>(message);
3487  if ( m11 != NULL ) {
3488  return true;
3489  }
3490  const SetMaxRotationMessage *m12 = dynamic_cast<const SetMaxRotationMessage *>(message);
3491  if ( m12 != NULL ) {
3492  return true;
3493  }
3494  const SetEscapingMessage *m13 = dynamic_cast<const SetEscapingMessage *>(message);
3495  if ( m13 != NULL ) {
3496  return true;
3497  }
3498  const SetSecurityDistanceMessage *m14 = dynamic_cast<const SetSecurityDistanceMessage *>(message);
3499  if ( m14 != NULL ) {
3500  return true;
3501  }
3502  const SetDriveModeMessage *m15 = dynamic_cast<const SetDriveModeMessage *>(message);
3503  if ( m15 != NULL ) {
3504  return true;
3505  }
3506  const SetStopAtTargetMessage *m16 = dynamic_cast<const SetStopAtTargetMessage *>(message);
3507  if ( m16 != NULL ) {
3508  return true;
3509  }
3510  const SetOrientationModeMessage *m17 = dynamic_cast<const SetOrientationModeMessage *>(message);
3511  if ( m17 != NULL ) {
3512  return true;
3513  }
3514  const ResetParametersMessage *m18 = dynamic_cast<const ResetParametersMessage *>(message);
3515  if ( m18 != NULL ) {
3516  return true;
3517  }
3518  return false;
3519 }
3520 
3521 /// @cond INTERNALS
3522 EXPORT_INTERFACE(NavigatorInterface)
3523 /// @endcond
3524 
3525 
3526 } // end namespace fawkes
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:1641
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:1621
fawkes::NavigatorInterface::ESCAPE
Escape constant.
Definition: NavigatorInterface.h:68
fawkes::NavigatorInterface::flags
uint32_t flags() const
Get flags value.
Definition: NavigatorInterface.cpp:181
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::orientation_tolerance
float orientation_tolerance() const
Get orientation_tolerance value.
Definition: NavigatorInterface.cpp:1494
fawkes::NavigatorInterface::dest_y
float dest_y() const
Get dest_y value.
Definition: NavigatorInterface.cpp:306
fawkes::NavigatorInterface::CartesianGotoMessage::CartesianGotoMessage
CartesianGotoMessage()
Constructor.
Definition: NavigatorInterface.cpp:1151
fawkes::NavigatorInterface::SetDriveModeMessage::~SetDriveModeMessage
~SetDriveModeMessage()
Destructor.
Definition: NavigatorInterface.cpp:3120
fawkes::NavigatorInterface::TurnMessage::set_velocity
void set_velocity(const float new_velocity)
Set velocity value.
Definition: NavigatorInterface.cpp:1102
fawkes::NavigatorInterface::FLAG_POLAR_GOTO
static const uint32_t FLAG_POLAR_GOTO
FLAG_POLAR_GOTO constant.
Definition: NavigatorInterface.h:56
fawkes::NavigatorInterface::SetMaxVelocityMessage::set_max_velocity
void set_max_velocity(const float new_max_velocity)
Set max_velocity value.
Definition: NavigatorInterface.cpp:2745
fawkes::NavigatorInterface::PolarGotoMessage::~PolarGotoMessage
~PolarGotoMessage()
Destructor.
Definition: NavigatorInterface.cpp:2067
fawkes::NavigatorInterface::set_security_distance
void set_security_distance(const float new_security_distance)
Set security_distance value.
Definition: NavigatorInterface.cpp:582
fawkes::Interface::data_ptr
void * data_ptr
Definition: interface.h:223
fawkes::NavigatorInterface::maxlenof_error_code
size_t maxlenof_error_code() const
Get maximum length of error_code value.
Definition: NavigatorInterface.cpp:477
fawkes::NavigatorInterface::ResetParametersMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:3435
fawkes::NavigatorInterface::SetDriveModeMessage::set_drive_mode
void set_drive_mode(const DriveMode new_drive_mode)
Set drive_mode value.
Definition: NavigatorInterface.cpp:3163
fawkes::NavigatorInterface::SetStopAtTargetMessage::~SetStopAtTargetMessage
~SetStopAtTargetMessage()
Destructor.
Definition: NavigatorInterface.cpp:3224
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::set_target_frame
void set_target_frame(const char *new_target_frame)
Set target_frame value.
Definition: NavigatorInterface.cpp:1721
fawkes::NavigatorInterface::SetMaxRotationMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2860
fawkes::NavigatorInterface::ResetOdometryMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2652
fawkes::NavigatorInterface::SetOrientationModeMessage
Definition: NavigatorInterface.h:663
fawkes::NavigatorInterface::TurnMessage::velocity
float velocity() const
Get velocity value.
Definition: NavigatorInterface.cpp:1081
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:1444
fawkes::NavigatorInterface::ObstacleMessage::width
float width() const
Get width value.
Definition: NavigatorInterface.cpp:2568
fawkes::NavigatorInterface::CartesianGotoMessage::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:1244
fawkes::NavigatorInterface::AllowBackward
Moving allow backward constant.
Definition: NavigatorInterface.h:66
fawkes::NavigatorInterface::CartesianGotoMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:1274
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:1867
fawkes::NavigatorInterface::SetOrientationModeMessage::maxlenof_orientation_mode
size_t maxlenof_orientation_mode() const
Get maximum length of orientation_mode value.
Definition: NavigatorInterface.cpp:3361
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::set_translation_tolerance
void set_translation_tolerance(const float new_translation_tolerance)
Set translation_tolerance value.
Definition: NavigatorInterface.cpp:1484
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:1827
fawkes::NavigatorInterface::SetStopAtTargetMessage::set_stop_at_target
void set_stop_at_target(const bool new_stop_at_target)
Set stop_at_target value.
Definition: NavigatorInterface.cpp:3267
fawkes::NavigatorInterface::SetDriveModeMessage::drive_mode
DriveMode drive_mode() const
Get drive_mode value.
Definition: NavigatorInterface.cpp:3143
fawkes::NavigatorInterface::maxlenof_msgid
size_t maxlenof_msgid() const
Get maximum length of msgid value.
Definition: NavigatorInterface.cpp:410
fawkes::NavigatorInterface::StopMessage::~StopMessage
~StopMessage()
Destructor.
Definition: NavigatorInterface.cpp:903
fawkes::NavigatorInterface::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:223
fawkes::NavigatorInterface::StopMessage
Definition: NavigatorInterface.h:119
fawkes::NavigatorInterface::set_dest_dist
void set_dest_dist(const float new_dest_dist)
Set dest_dist value.
Definition: NavigatorInterface.cpp:388
fawkes::NavigatorInterface::TurnMessage::angle
float angle() const
Get angle value.
Definition: NavigatorInterface.cpp:1050
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_target_frame
size_t maxlenof_target_frame() const
Get maximum length of target_frame value.
Definition: NavigatorInterface.cpp:1927
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::maxlenof_place
size_t maxlenof_place() const
Get maximum length of place value.
Definition: NavigatorInterface.cpp:2375
fawkes::NavigatorInterface::TurnMessage::maxlenof_velocity
size_t maxlenof_velocity() const
Get maximum length of velocity value.
Definition: NavigatorInterface.cpp:1091
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::~CartesianGotoWithFrameWithToleranceMessage
~CartesianGotoWithFrameWithToleranceMessage()
Destructor.
Definition: NavigatorInterface.cpp:1804
fawkes::NavigatorInterface::target_frame
char * target_frame() const
Get target_frame value.
Definition: NavigatorInterface.cpp:754
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2427
fawkes::NavigatorInterface::CartesianGotoMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:1285
fawkes::NavigatorInterface::SetMaxVelocityMessage::~SetMaxVelocityMessage
~SetMaxVelocityMessage()
Destructor.
Definition: NavigatorInterface.cpp:2702
fawkes::NavigatorInterface::ObstacleMessage::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:2528
fawkes::NavigatorInterface::PolarGotoMessage::PolarGotoMessage
PolarGotoMessage()
Constructor.
Definition: NavigatorInterface.cpp:2047
fawkes::NavigatorInterface::maxlenof_dest_y
size_t maxlenof_dest_y() const
Get maximum length of dest_y value.
Definition: NavigatorInterface.cpp:316
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:2396
fawkes::NavigatorInterface::CartesianGotoMessage::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:1204
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::maxlenof_orientation_tolerance
size_t maxlenof_orientation_tolerance() const
Get maximum length of orientation_tolerance value.
Definition: NavigatorInterface.cpp:1504
fawkes::NavigatorInterface::set_dest_ori
void set_dest_ori(const float new_dest_ori)
Set dest_ori value.
Definition: NavigatorInterface.cpp:357
fawkes::NavigatorInterface::CartesianGotoMessage::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:1194
fawkes::NavigatorInterface::SetOrientationModeMessage::orientation_mode
OrientationMode orientation_mode() const
Get orientation_mode value.
Definition: NavigatorInterface.cpp:3351
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::orientation_tolerance
float orientation_tolerance() const
Get orientation_tolerance value.
Definition: NavigatorInterface.cpp:1978
fawkes::Message
Definition: message.h:40
fawkes::NavigatorInterface::SetSecurityDistanceMessage::security_distance
float security_distance() const
Get security_distance value.
Definition: NavigatorInterface.cpp:3039
fawkes::NavigatorInterface::PolarGotoMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:2170
fawkes::NavigatorInterface::set_drive_mode
void set_drive_mode(const DriveMode new_drive_mode)
Set drive_mode value.
Definition: NavigatorInterface.cpp:646
fawkes::NavigatorInterface::dest_dist
float dest_dist() const
Get dest_dist value.
Definition: NavigatorInterface.cpp:368
fawkes::NavigatorInterface::PolarGotoMessage::maxlenof_dist
size_t maxlenof_dist() const
Get maximum length of dist value.
Definition: NavigatorInterface.cpp:2130
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::CartesianGotoWithToleranceMessage
CartesianGotoWithToleranceMessage()
Constructor.
Definition: NavigatorInterface.cpp:1329
fawkes::NavigatorInterface::is_escaping_enabled
bool is_escaping_enabled() const
Get escaping_enabled value.
Definition: NavigatorInterface.cpp:594
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:1651
fawkes::NavigatorInterface::enum_tostring
virtual const char * enum_tostring(const char *enumtype, int val) const
Definition: NavigatorInterface.cpp:845
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:1907
fawkes::NavigatorInterface::Forward
Moving forward constant.
Definition: NavigatorInterface.h:65
fawkes::NavigatorInterface::SetSecurityDistanceMessage::set_security_distance
void set_security_distance(const float new_security_distance)
Set security_distance value.
Definition: NavigatorInterface.cpp:3059
fawkes::NavigatorInterface::set_error_code
void set_error_code(const uint32_t new_error_code)
Set error_code value.
Definition: NavigatorInterface.cpp:489
fawkes::Message::data_ptr
void * data_ptr
Definition: message.h:124
fawkes::IFT_BOOL
boolean field
Definition: types.h:48
fawkes::NavigatorInterface::set_dest_x
void set_dest_x(const float new_dest_x)
Set dest_x value.
Definition: NavigatorInterface.cpp:295
fawkes::NavigatorInterface::SetStopAtTargetMessage
Definition: NavigatorInterface.h:636
fawkes::NavigatorInterface::SetOrientationModeMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:3382
fawkes::NavigatorInterface::copy_values
virtual void copy_values(const Interface *other)
Copy values from other interface.
Definition: NavigatorInterface.cpp:834
fawkes::NavigatorInterface::FLAG_ESCAPING
static const uint32_t FLAG_ESCAPING
FLAG_ESCAPING constant.
Definition: NavigatorInterface.h:60
fawkes::NavigatorInterface::SetDriveModeMessage
Definition: NavigatorInterface.h:609
fawkes::NavigatorInterface::SetEscapingMessage::is_escaping_enabled
bool is_escaping_enabled() const
Get escaping_enabled value.
Definition: NavigatorInterface.cpp:2934
fawkes::NavigatorInterface::dest_x
float dest_x() const
Get dest_x value.
Definition: NavigatorInterface.cpp:275
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:1837
fawkes::NavigatorInterface::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:254
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:1631
fawkes::NavigatorInterface::ResetParametersMessage
Definition: NavigatorInterface.h:690
fawkes::NavigatorInterface::SetEscapingMessage::set_escaping_enabled
void set_escaping_enabled(const bool new_escaping_enabled)
Set escaping_enabled value.
Definition: NavigatorInterface.cpp:2955
fawkes::NavigatorInterface::SetEscapingMessage::maxlenof_escaping_enabled
size_t maxlenof_escaping_enabled() const
Get maximum length of escaping_enabled value.
Definition: NavigatorInterface.cpp:2944
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::translation_tolerance
float translation_tolerance() const
Get translation_tolerance value.
Definition: NavigatorInterface.cpp:1948
fawkes::IFT_FLOAT
float field
Definition: types.h:57
fawkes::NavigatorInterface::tostring_OrientationMode
const char * tostring_OrientationMode(OrientationMode value) const
Convert OrientationMode constant to string.
Definition: NavigatorInterface.cpp:166
fawkes::NavigatorInterface::PolarGotoMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:2150
fawkes::IFT_ENUM
field with interface specific enum type
Definition: types.h:61
fawkes::Message::data_ts
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:134
fawkes::NavigatorInterface::security_distance
float security_distance() const
Get security_distance value.
Definition: NavigatorInterface.cpp:562
fawkes::NavigatorInterface::msgid
uint32_t msgid() const
Get msgid value.
Definition: NavigatorInterface.cpp:400
fawkes::NavigatorInterface::ObstacleMessage::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:2518
fawkes::NavigatorInterface::PolarGotoMessage::phi
float phi() const
Get phi value.
Definition: NavigatorInterface.cpp:2090
fawkes::IFT_UINT32
32 bit unsigned integer field
Definition: types.h:54
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage
Definition: NavigatorInterface.h:264
fawkes::NavigatorInterface::TurnMessage
Definition: NavigatorInterface.h:154
fawkes::NavigatorInterface::ResetParametersMessage::ResetParametersMessage
ResetParametersMessage()
Constructor.
Definition: NavigatorInterface.cpp:3394
fawkes::NavigatorInterface::SetStopAtTargetMessage::maxlenof_stop_at_target
size_t maxlenof_stop_at_target() const
Get maximum length of stop_at_target value.
Definition: NavigatorInterface.cpp:3257
fawkes::NavigatorInterface::FLAG_SECURITY_DISTANCE
static const uint32_t FLAG_SECURITY_DISTANCE
FLAG_SECURITY_DISTANCE constant.
Definition: NavigatorInterface.h:59
fawkes::NavigatorInterface::maxlenof_dest_x
size_t maxlenof_dest_x() const
Get maximum length of dest_x value.
Definition: NavigatorInterface.cpp:285
fawkes::NavigatorInterface::ObstacleMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2599
fawkes::NavigatorInterface::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:213
fawkes::NavigatorInterface::maxlenof_flags
size_t maxlenof_flags() const
Get maximum length of flags value.
Definition: NavigatorInterface.cpp:191
fawkes::NavigatorInterface::set_max_rotation
void set_max_rotation(const float new_max_rotation)
Set max_rotation value.
Definition: NavigatorInterface.cpp:551
fawkes::NavigatorInterface::PolarGotoMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:2160
fawkes::NavigatorInterface::set_max_velocity
void set_max_velocity(const float new_max_velocity)
Set max_velocity value.
Definition: NavigatorInterface.cpp:520
fawkes::NavigatorInterface::FLAG_UPDATES_DEST_DIST
static const uint32_t FLAG_UPDATES_DEST_DIST
FLAG_UPDATES_DEST_DIST constant.
Definition: NavigatorInterface.h:58
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::CartesianGotoWithFrameMessage
CartesianGotoWithFrameMessage()
Constructor.
Definition: NavigatorInterface.cpp:1567
fawkes::NavigatorInterface::ResetOdometryMessage::ResetOdometryMessage
ResetOdometryMessage()
Constructor.
Definition: NavigatorInterface.cpp:2611
fawkes::NavigatorInterface::SetStopAtTargetMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:3278
fawkes::NavigatorInterface::SetDriveModeMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:3174
fawkes::NavigatorInterface::TurnMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:1113
fawkes::NavigatorInterface::ResetParametersMessage::~ResetParametersMessage
~ResetParametersMessage()
Destructor.
Definition: NavigatorInterface.cpp:3411
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:1374
fawkes::Interface::type
const char * type() const
Get type of interface.
Definition: interface.cpp:643
fawkes::Interface::add_fieldinfo
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the field info list.
Definition: interface.cpp:339
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:1733
fawkes::NavigatorInterface::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:244
fawkes::NavigatorInterface::SetSecurityDistanceMessage::maxlenof_security_distance
size_t maxlenof_security_distance() const
Get maximum length of security_distance value.
Definition: NavigatorInterface.cpp:3049
fawkes::NavigatorInterface::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:264
fawkes::NavigatorInterface::OrientAtTarget
Orient when at target, if orientation is given.
Definition: NavigatorInterface.h:74
fawkes::NavigatorInterface::ERROR_OBSTRUCTION
static const uint32_t ERROR_OBSTRUCTION
ERROR_OBSTRUCTION constant.
Definition: NavigatorInterface.h:51
fawkes::NavigatorInterface::PlaceGotoMessage::~PlaceGotoMessage
~PlaceGotoMessage()
Destructor.
Definition: NavigatorInterface.cpp:2232
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::maxlenof_target_frame
size_t maxlenof_target_frame() const
Get maximum length of target_frame value.
Definition: NavigatorInterface.cpp:1711
fawkes::Interface::data_ts
interface_data_ts_t * data_ts
Definition: interface.h:227
fawkes::NavigatorInterface::SetMaxRotationMessage::maxlenof_max_rotation
size_t maxlenof_max_rotation() const
Get maximum length of max_rotation value.
Definition: NavigatorInterface.cpp:2839
fawkes::NavigatorInterface::SetEscapingMessage::SetEscapingMessage
SetEscapingMessage()
Constructor.
Definition: NavigatorInterface.cpp:2892
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:2416
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:1434
fawkes::NavigatorInterface::ObstacleMessage::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:2558
fawkes::NavigatorInterface::TurnMessage::~TurnMessage
~TurnMessage()
Destructor.
Definition: NavigatorInterface.cpp:1027
fawkes::NavigatorInterface::TurnMessage::TurnMessage
TurnMessage()
Constructor.
Definition: NavigatorInterface.cpp:1008
fawkes::NavigatorInterface::maxlenof_max_rotation
size_t maxlenof_max_rotation() const
Get maximum length of max_rotation value.
Definition: NavigatorInterface.cpp:541
fawkes::NavigatorInterface::ERROR_NONE
static const uint32_t ERROR_NONE
ERROR_NONE constant.
Definition: NavigatorInterface.h:49
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::maxlenof_x
size_t maxlenof_x() const
Get maximum length of x value.
Definition: NavigatorInterface.cpp:1384
fawkes::NavigatorInterface::MovingNotAllowed
Moving not allowed constant.
Definition: NavigatorInterface.h:64
fawkes::Message::message_data_ts_t
Timestamp data, must be present and first entries for each interface data structs!...
Definition: message.h:129
fawkes::NavigatorInterface::FLAG_NONE
static const uint32_t FLAG_NONE
FLAG_NONE constant.
Definition: NavigatorInterface.h:54
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_translation_tolerance
size_t maxlenof_translation_tolerance() const
Get maximum length of translation_tolerance value.
Definition: NavigatorInterface.cpp:1958
fawkes::NavigatorInterface::SetEscapingMessage
Definition: NavigatorInterface.h:554
fawkes::NavigatorInterface::SetMaxVelocityMessage
Definition: NavigatorInterface.h:500
fawkes::NavigatorInterface::PolarGotoMessage
Definition: NavigatorInterface.h:350
fawkes::NavigatorInterface::SetDriveModeMessage::maxlenof_drive_mode
size_t maxlenof_drive_mode() const
Get maximum length of drive_mode value.
Definition: NavigatorInterface.cpp:3153
fawkes::NavigatorInterface::set_dest_y
void set_dest_y(const float new_dest_y)
Set dest_y value.
Definition: NavigatorInterface.cpp:326
fawkes::NavigatorInterface::SetMaxVelocityMessage::max_velocity
float max_velocity() const
Get max_velocity value.
Definition: NavigatorInterface.cpp:2725
fawkes::TypeMismatchException
Definition: software.h:47
fawkes::NavigatorInterface::set_escaping_enabled
void set_escaping_enabled(const bool new_escaping_enabled)
Set escaping_enabled value.
Definition: NavigatorInterface.cpp:615
fawkes::Interface::data_changed
bool data_changed
Definition: interface.h:225
fawkes::NavigatorInterface::ObstacleMessage::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:2538
fawkes::NavigatorInterface::ResetOdometryMessage
Definition: NavigatorInterface.h:478
fawkes::NavigatorInterface::set_msgid
void set_msgid(const uint32_t new_msgid)
Set msgid value.
Definition: NavigatorInterface.cpp:421
fawkes::NavigatorInterface::CartesianGotoMessage::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:1214
fawkes::NavigatorInterface::Backward
Moving backward constant.
Definition: NavigatorInterface.h:67
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2009
fawkes::NavigatorInterface::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:233
fawkes::NavigatorInterface::ObstacleMessage::set_width
void set_width(const float new_width)
Set width value.
Definition: NavigatorInterface.cpp:2588
fawkes::NavigatorInterface::StopMessage::StopMessage
StopMessage()
Constructor.
Definition: NavigatorInterface.cpp:885
fawkes::NavigatorInterface::PlaceGotoMessage::PlaceGotoMessage
PlaceGotoMessage()
Constructor.
Definition: NavigatorInterface.cpp:2214
fawkes::NavigatorInterface::set_orientation_mode
void set_orientation_mode(const OrientationMode new_orientation_mode)
Set orientation_mode value.
Definition: NavigatorInterface.cpp:743
fawkes::NavigatorInterface::CartesianGotoMessage::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:1224
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:1414
fawkes::NavigatorInterface::ResetOdometryMessage::~ResetOdometryMessage
~ResetOdometryMessage()
Destructor.
Definition: NavigatorInterface.cpp:2628
fawkes::NavigatorInterface::maxlenof_drive_mode
size_t maxlenof_drive_mode() const
Get maximum length of drive_mode value.
Definition: NavigatorInterface.cpp:636
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::maxlenof_translation_tolerance
size_t maxlenof_translation_tolerance() const
Get maximum length of translation_tolerance value.
Definition: NavigatorInterface.cpp:1474
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::~PlaceWithOriGotoMessage
~PlaceWithOriGotoMessage()
Destructor.
Definition: NavigatorInterface.cpp:2342
fawkes::NavigatorInterface::SetMaxRotationMessage::SetMaxRotationMessage
SetMaxRotationMessage()
Constructor.
Definition: NavigatorInterface.cpp:2788
fawkes::NavigatorInterface::maxlenof_target_frame
size_t maxlenof_target_frame() const
Get maximum length of target_frame value.
Definition: NavigatorInterface.cpp:764
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::translation_tolerance
float translation_tolerance() const
Get translation_tolerance value.
Definition: NavigatorInterface.cpp:1464
fawkes::NavigatorInterface::ERROR_PATH_GEN_FAIL
static const uint32_t ERROR_PATH_GEN_FAIL
ERROR_PATH_GEN_FAIL constant.
Definition: NavigatorInterface.h:53
fawkes::Interface::Interface
Interface()
Constructor.
Definition: interface.cpp:236
fawkes::NavigatorInterface::SetMaxRotationMessage::max_rotation
float max_rotation() const
Get max_rotation value.
Definition: NavigatorInterface.cpp:2829
fawkes::NavigatorInterface::DriveMode
DriveMode
Drive modes enum.
Definition: NavigatorInterface.h:63
fawkes::NavigatorInterface::PlaceGotoMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2287
fawkes::NavigatorInterface::set_stop_at_target
void set_stop_at_target(const bool new_stop_at_target)
Set stop_at_target value.
Definition: NavigatorInterface.cpp:712
fawkes::NavigatorInterface::ObstacleMessage::~ObstacleMessage
~ObstacleMessage()
Destructor.
Definition: NavigatorInterface.cpp:2485
fawkes::NavigatorInterface::StopMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:973
fawkes::NavigatorInterface::FLAG_PLACE_GOTO
static const uint32_t FLAG_PLACE_GOTO
FLAG_PLACE_GOTO constant.
Definition: NavigatorInterface.h:57
fawkes::NavigatorInterface::set_final
void set_final(const bool new_final)
Set final value.
Definition: NavigatorInterface.cpp:454
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_orientation_tolerance
size_t maxlenof_orientation_tolerance() const
Get maximum length of orientation_tolerance value.
Definition: NavigatorInterface.cpp:1988
fawkes
fawkes::NavigatorInterface::CartesianGotoMessage::~CartesianGotoMessage
~CartesianGotoMessage()
Destructor.
Definition: NavigatorInterface.cpp:1171
fawkes::Interface::set_hash
void set_hash(unsigned char *ihash)
Set hash.
Definition: interface.cpp:319
fawkes::NavigatorInterface::is_auto_drive_mode
bool is_auto_drive_mode() const
Get auto_drive_mode value.
Definition: NavigatorInterface.cpp:659
fawkes::Message::data_size
unsigned int data_size
Definition: message.h:125
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::~CartesianGotoWithFrameMessage
~CartesianGotoWithFrameMessage()
Destructor.
Definition: NavigatorInterface.cpp:1588
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::place
char * place() const
Get place value.
Definition: NavigatorInterface.cpp:2365
fawkes::NavigatorInterface::PolarGotoMessage::set_dist
void set_dist(const float new_dist)
Set dist value.
Definition: NavigatorInterface.cpp:2140
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::CartesianGotoWithFrameWithToleranceMessage
CartesianGotoWithFrameWithToleranceMessage()
Constructor.
Definition: NavigatorInterface.cpp:1781
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:1525
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_target_frame
void set_target_frame(const char *new_target_frame)
Set target_frame value.
Definition: NavigatorInterface.cpp:1937
fawkes::NavigatorInterface::CartesianGotoMessage::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:1234
fawkes::NavigatorInterface::CartesianGotoMessage
Definition: NavigatorInterface.h:186
fawkes::NavigatorInterface::set_target_frame
void set_target_frame(const char *new_target_frame)
Set target_frame value.
Definition: NavigatorInterface.cpp:774
fawkes::NavigatorInterface::SetMaxRotationMessage
Definition: NavigatorInterface.h:527
fawkes::NavigatorInterface::max_velocity
float max_velocity() const
Get max_velocity value.
Definition: NavigatorInterface.cpp:500
fawkes::NavigatorInterface::PolarGotoMessage::maxlenof_phi
size_t maxlenof_phi() const
Get maximum length of phi value.
Definition: NavigatorInterface.cpp:2100
fawkes::NavigatorInterface::FLAG_CART_GOTO
static const uint32_t FLAG_CART_GOTO
FLAG_CART_GOTO constant.
Definition: NavigatorInterface.h:55
fawkes::NavigatorInterface::max_rotation
float max_rotation() const
Get max_rotation value.
Definition: NavigatorInterface.cpp:531
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:1671
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:1847
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::~CartesianGotoWithToleranceMessage
~CartesianGotoWithToleranceMessage()
Destructor.
Definition: NavigatorInterface.cpp:1351
fawkes::NavigatorInterface::ERROR_UNKNOWN_PLACE
static const uint32_t ERROR_UNKNOWN_PLACE
ERROR_UNKNOWN_PLACE constant.
Definition: NavigatorInterface.h:52
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:1887
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::target_frame
char * target_frame() const
Get target_frame value.
Definition: NavigatorInterface.cpp:1917
fawkes::NavigatorInterface::StopMessage::set_msgid
void set_msgid(const uint32_t new_msgid)
Set msgid value.
Definition: NavigatorInterface.cpp:962
fawkes::NavigatorInterface::SetSecurityDistanceMessage
Definition: NavigatorInterface.h:582
fawkes::NavigatorInterface::SetEscapingMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2966
fawkes::NavigatorInterface::SetMaxVelocityMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2756
fawkes::NavigatorInterface::PlaceGotoMessage::set_place
void set_place(const char *new_place)
Set place value.
Definition: NavigatorInterface.cpp:2275
fawkes::NavigatorInterface::maxlenof_dest_dist
size_t maxlenof_dest_dist() const
Get maximum length of dest_dist value.
Definition: NavigatorInterface.cpp:378
fawkes::NavigatorInterface::dest_ori
float dest_ori() const
Get dest_ori value.
Definition: NavigatorInterface.cpp:337
fawkes::NavigatorInterface::maxlenof_max_velocity
size_t maxlenof_max_velocity() const
Get maximum length of max_velocity value.
Definition: NavigatorInterface.cpp:510
fawkes::NavigatorInterface::SetStopAtTargetMessage::SetStopAtTargetMessage
SetStopAtTargetMessage()
Constructor.
Definition: NavigatorInterface.cpp:3206
fawkes::NavigatorInterface::ERROR_MOTOR
static const uint32_t ERROR_MOTOR
ERROR_MOTOR constant.
Definition: NavigatorInterface.h:50
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_orientation_tolerance
void set_orientation_tolerance(const float new_orientation_tolerance)
Set orientation_tolerance value.
Definition: NavigatorInterface.cpp:1998
fawkes::NavigatorInterface::tostring_DriveMode
const char * tostring_DriveMode(DriveMode value) const
Convert DriveMode constant to string.
Definition: NavigatorInterface.cpp:150
fawkes::NavigatorInterface::TurnMessage::maxlenof_angle
size_t maxlenof_angle() const
Get maximum length of angle value.
Definition: NavigatorInterface.cpp:1060
fawkes::NavigatorInterface::PlaceGotoMessage
Definition: NavigatorInterface.h:385
fawkes::Message::add_fieldinfo
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the info list.
Definition: message.cpp:404
fawkes::NavigatorInterface::create_message
virtual Message * create_message(const char *type) const
Definition: NavigatorInterface.cpp:783
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:1681
fawkes::NavigatorInterface::ObstacleMessage
Definition: NavigatorInterface.h:443
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:1404
fawkes::NavigatorInterface::ObstacleMessage::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:2508
fawkes::NavigatorInterface::is_stop_at_target
bool is_stop_at_target() const
Get stop_at_target value.
Definition: NavigatorInterface.cpp:692
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage
Definition: NavigatorInterface.h:221
fawkes::NavigatorInterface::CartesianGotoMessage::orientation
float orientation() const
Get orientation value.
Definition: NavigatorInterface.cpp:1254
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:2406
fawkes::OrientAtTarget
Indicating that the robot is at target and has to orient.
Definition: types.h:46
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::PlaceWithOriGotoMessage
PlaceWithOriGotoMessage()
Constructor.
Definition: NavigatorInterface.cpp:2323
fawkes::NavigatorInterface::PlaceGotoMessage::place
char * place() const
Get place value.
Definition: NavigatorInterface.cpp:2255
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::x
float x() const
Get x value.
Definition: NavigatorInterface.cpp:1611
fawkes::NavigatorInterface::OrientDuringTravel
Orient during travel BUT NOT at target, if omnidirectional platform and orientation is given.
Definition: NavigatorInterface.h:75
fawkes::NavigatorInterface::ObstacleMessage::ObstacleMessage
ObstacleMessage()
Constructor.
Definition: NavigatorInterface.cpp:2465
fawkes::NavigatorInterface::SetStopAtTargetMessage::is_stop_at_target
bool is_stop_at_target() const
Get stop_at_target value.
Definition: NavigatorInterface.cpp:3247
fawkes::Interface::data_size
unsigned int data_size
Definition: interface.h:224
fawkes::NavigatorInterface::OrientationMode
OrientationMode
Orientation mode enum.
Definition: NavigatorInterface.h:73
fawkes::NavigatorInterface::SetMaxRotationMessage::~SetMaxRotationMessage
~SetMaxRotationMessage()
Destructor.
Definition: NavigatorInterface.cpp:2806
fawkes::NavigatorInterface::PlaceGotoMessage::maxlenof_place
size_t maxlenof_place() const
Get maximum length of place value.
Definition: NavigatorInterface.cpp:2265
fawkes::NavigatorInterface::message_valid
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
Definition: NavigatorInterface.cpp:3444
fawkes::NavigatorInterface::SetSecurityDistanceMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:3070
fawkes::NavigatorInterface::maxlenof_stop_at_target
size_t maxlenof_stop_at_target() const
Get maximum length of stop_at_target value.
Definition: NavigatorInterface.cpp:702
fawkes::NavigatorInterface::ObstacleMessage::maxlenof_width
size_t maxlenof_width() const
Get maximum length of width value.
Definition: NavigatorInterface.cpp:2578
fawkes::NavigatorInterface::CartesianGotoMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:1264
fawkes::NavigatorInterface::maxlenof_orientation_mode
size_t maxlenof_orientation_mode() const
Get maximum length of orientation_mode value.
Definition: NavigatorInterface.cpp:733
fawkes::NavigatorInterface::PolarGotoMessage::clone
virtual Message * clone() const
Clone this message.
Definition: NavigatorInterface.cpp:2181
fawkes::NavigatorInterface::SetEscapingMessage::~SetEscapingMessage
~SetEscapingMessage()
Destructor.
Definition: NavigatorInterface.cpp:2910
fawkes::NavigatorInterface::maxlenof_final
size_t maxlenof_final() const
Get maximum length of final value.
Definition: NavigatorInterface.cpp:443
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::set_orientation_tolerance
void set_orientation_tolerance(const float new_orientation_tolerance)
Set orientation_tolerance value.
Definition: NavigatorInterface.cpp:1514
fawkes::IFT_STRING
string field
Definition: types.h:59
fawkes::NavigatorInterface::SetDriveModeMessage::SetDriveModeMessage
SetDriveModeMessage()
Constructor.
Definition: NavigatorInterface.cpp:3102
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:1424
fawkes::NavigatorInterface::error_code
uint32_t error_code() const
Get error_code value.
Definition: NavigatorInterface.cpp:467
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::set_x
void set_x(const float new_x)
Set x value.
Definition: NavigatorInterface.cpp:1394
fawkes::NavigatorInterface::SetMaxVelocityMessage::maxlenof_max_velocity
size_t maxlenof_max_velocity() const
Get maximum length of max_velocity value.
Definition: NavigatorInterface.cpp:2735
fawkes::NavigatorInterface::PolarGotoMessage::set_phi
void set_phi(const float new_phi)
Set phi value.
Definition: NavigatorInterface.cpp:2110
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::target_frame
char * target_frame() const
Get target_frame value.
Definition: NavigatorInterface.cpp:1701
fawkes::NavigatorInterface::maxlenof_dest_ori
size_t maxlenof_dest_ori() const
Get maximum length of dest_ori value.
Definition: NavigatorInterface.cpp:347
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:1661
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::maxlenof_orientation
size_t maxlenof_orientation() const
Get maximum length of orientation value.
Definition: NavigatorInterface.cpp:1897
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_y
void set_y(const float new_y)
Set y value.
Definition: NavigatorInterface.cpp:1877
fawkes::NavigatorInterface::maxlenof_security_distance
size_t maxlenof_security_distance() const
Get maximum length of security_distance value.
Definition: NavigatorInterface.cpp:572
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage
Definition: NavigatorInterface.h:303
fawkes::NavigatorInterface::SetOrientationModeMessage::~SetOrientationModeMessage
~SetOrientationModeMessage()
Destructor.
Definition: NavigatorInterface.cpp:3328
fawkes::NavigatorInterface::StopMessage::msgid
uint32_t msgid() const
Get msgid value.
Definition: NavigatorInterface.cpp:934
fawkes::Interface::add_messageinfo
void add_messageinfo(const char *name)
Add an entry to the message info list.
Definition: interface.cpp:378
fawkes::NavigatorInterface::set_flags
void set_flags(const uint32_t new_flags)
Set flags value.
Definition: NavigatorInterface.cpp:202
fawkes::NavigatorInterface::SetMaxVelocityMessage::SetMaxVelocityMessage
SetMaxVelocityMessage()
Constructor.
Definition: NavigatorInterface.cpp:2684
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::set_translation_tolerance
void set_translation_tolerance(const float new_translation_tolerance)
Set translation_tolerance value.
Definition: NavigatorInterface.cpp:1968
fawkes::NavigatorInterface::set_auto_drive_mode
void set_auto_drive_mode(const bool new_auto_drive_mode)
Set auto_drive_mode value.
Definition: NavigatorInterface.cpp:681
fawkes::NavigatorInterface::SetMaxRotationMessage::set_max_rotation
void set_max_rotation(const float new_max_rotation)
Set max_rotation value.
Definition: NavigatorInterface.cpp:2849
fawkes::NavigatorInterface::PlaceWithOriGotoMessage
Definition: NavigatorInterface.h:412
fawkes::NavigatorInterface::ObstacleMessage::maxlenof_y
size_t maxlenof_y() const
Get maximum length of y value.
Definition: NavigatorInterface.cpp:2548
fawkes::NavigatorInterface::maxlenof_auto_drive_mode
size_t maxlenof_auto_drive_mode() const
Get maximum length of auto_drive_mode value.
Definition: NavigatorInterface.cpp:669
fawkes::NavigatorInterface::PlaceWithOriGotoMessage::set_place
void set_place(const char *new_place)
Set place value.
Definition: NavigatorInterface.cpp:2385
fawkes::NavigatorInterface::CartesianGotoWithFrameMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:1691
fawkes::NavigatorInterface::CartesianGotoWithFrameWithToleranceMessage::y
float y() const
Get y value.
Definition: NavigatorInterface.cpp:1857
fawkes::NavigatorInterface::SetSecurityDistanceMessage::SetSecurityDistanceMessage
SetSecurityDistanceMessage()
Constructor.
Definition: NavigatorInterface.cpp:2998
fawkes::NavigatorInterface::is_final
bool is_final() const
Get final value.
Definition: NavigatorInterface.cpp:433
fawkes::NavigatorInterface::SetOrientationModeMessage::set_orientation_mode
void set_orientation_mode(const OrientationMode new_orientation_mode)
Set orientation_mode value.
Definition: NavigatorInterface.cpp:3371
fawkes::NavigatorInterface::StopMessage::maxlenof_msgid
size_t maxlenof_msgid() const
Get maximum length of msgid value.
Definition: NavigatorInterface.cpp:944
fawkes::NavigatorInterface::SetSecurityDistanceMessage::~SetSecurityDistanceMessage
~SetSecurityDistanceMessage()
Destructor.
Definition: NavigatorInterface.cpp:3016
fawkes::NavigatorInterface::orientation_mode
OrientationMode orientation_mode() const
Get orientation_mode value.
Definition: NavigatorInterface.cpp:723
fawkes::NavigatorInterface::maxlenof_escaping_enabled
size_t maxlenof_escaping_enabled() const
Get maximum length of escaping_enabled value.
Definition: NavigatorInterface.cpp:604
fawkes::NavigatorInterface::SetOrientationModeMessage::SetOrientationModeMessage
SetOrientationModeMessage()
Constructor.
Definition: NavigatorInterface.cpp:3310
fawkes::NavigatorInterface::PolarGotoMessage::dist
float dist() const
Get dist value.
Definition: NavigatorInterface.cpp:2120
fawkes::NavigatorInterface::CartesianGotoWithToleranceMessage::set_orientation
void set_orientation(const float new_orientation)
Set orientation value.
Definition: NavigatorInterface.cpp:1454
fawkes::NavigatorInterface::TurnMessage::set_angle
void set_angle(const float new_angle)
Set angle value.
Definition: NavigatorInterface.cpp:1070
fawkes::NavigatorInterface::drive_mode
DriveMode drive_mode() const
Get drive_mode value.
Definition: NavigatorInterface.cpp:626