Main MRPT website > C++ reference for MRPT 1.4.0
CPtuDPerception.h
Go to the documentation of this file.
1/* +---------------------------------------------------------------------------+
2 | Mobile Robot Programming Toolkit (MRPT) |
3 | http://www.mrpt.org/ |
4 | |
5 | Copyright (c) 2005-2016, Individual contributors, see AUTHORS file |
6 | See: http://www.mrpt.org/Authors - All rights reserved. |
7 | Released under BSD License. See details in http://www.mrpt.org/License |
8 +---------------------------------------------------------------------------+ */
9
10#ifndef CPtuDPerception_H
11#define CPtuDPerception_H
12
15
16namespace mrpt
17{
18 namespace hwdrivers
19 {
20 /** This class implements initialization and comunication methods to
21 * control a Pan and Tilt Unit model PTU-46-17.5, working in radians .
22 * \ingroup mrpt_hwdrivers_grp
23 */
25 {
26
27 public:
28
29 /** Default constructor */
30
32
33 /** Destructor */
34
35 virtual ~CPtuDPerception(){ close(); }
36
37 /*************************** Commands ***************************/
38
39 public:
40
41 /** Search limit forward */
42
43 virtual bool rangeMeasure();
44
45 /** Specification of positions in absolute terms */
46
47 virtual bool moveToAbsPos(char axis,double nRad);
48
49 /** Query position in absolute terms */
50
51 virtual bool absPosQ(char axis,double &nRad);
52
53 /** Specify desired axis position as an offset from the current position. \n
54 * This method recives the number of radians to move.
55 * \code
56 * Example of use:
57 * TT-500 *
58 * A *
59 * TO * Current Tilt position is -500
60 * TO500 *
61 * A *
62 * TT * Current Pan position is 1000
63 * \endcode
64 */
65
66 virtual bool moveToOffPos(char axis,double nRad);
67
68 /** Query position in relative terms */
69
70 virtual bool offPosQ(char axis,double &nRad);
71
72 /** Query max movement limit of a axis in absolute terms */
73
74 virtual bool maxPosQ(char axis,double &nRad);
75
76 /** Query min movement limit of a axis in absolute terms */
77
78 virtual bool minPosQ(char axis,double &nRad);
79
80 /** Query if exist movement limits */
81
82 virtual bool enableLimitsQ(bool &enable); // Query if exist some limit
83
84 /** Enable/Disable movement limits */
85
86 virtual bool enableLimits(bool set);
87
88 /** With I mode (default) instructs pan-tilt unit to immediately
89 * execute positional commands. \n
90 * In S mode instructs pan-tilt unit to execute positional commands
91 * only when an Await Position Command Completion command is executed
92 * or when put into Immediate Execution Mode. \n
93 * \code
94 * Example of use of S mode:
95 * DR *
96 * S *
97 * PP1500 *
98 * TP-900 *
99 * PP * Current Pan position is 0
100 * TP * Current Tilt position is 0
101 * A *
102 * PP * Current Pan position is 1500
103 * TP * Current Tilt position is -900
104 * \endcode
105 */
106
107 virtual bool inmediateExecution(bool set);
108
109 /** Wait the finish of the last position command to
110 * continue accept commands
111 */
112
113 virtual bool aWait(void);
114
115 /** Inmediately stop all */
116
117 virtual bool haltAll();
118
119 /** Inmediately stop */
120
121 virtual bool halt(char axis);
122
123 /** Specification of turn speed */
124
125 virtual bool speed(char axis,double radSec);
126
127 /** Query turn speed */
128
129 virtual bool speedQ(char axis,double &radSec);
130
131 /** Specification (de/a)celeration in turn */
132
133 virtual bool aceleration(char axis,double radSec2);
134
135 /** Query (de/a)celeration in turn */
136
137 virtual bool acelerationQ(char axis,double &radSec2);
138
139 /** Specification of velocity to which start and finish
140 * the (de/a)celeration
141 */
142
143 virtual bool baseSpeed(char axis,double radSec);
144
145 /** Query velocity to which start and finish
146 * the (de/a)celeration
147 */
148
149 virtual bool baseSpeedQ(char axis,double &radSec);
150
151 /** Specification of velocity upper limit */
152
153 virtual bool upperSpeed(char axis,double radSec);
154
155 /** Query velocity upper limit */
156
157 virtual bool upperSpeedQ(char axis,double &radSec);
158
159 /** Specification of velocity lower limit */
160
161 virtual bool lowerSpeed(char axis,double radSec);
162
163 /** Query velocity lower limit */
164
165 virtual bool lowerSpeedQ(char axis,double &radSec);
166
167 /** Reset PTU to initial state */
168
169 virtual bool reset(void);
170
171 /** Save or restart default values */
172
173 virtual bool save(void);
174
175 /** Restore default values */
176
177 virtual bool restoreDefaults(void);
178
179 /** Restore factory default values */
180
181 virtual bool restoreFactoryDefaults(void);
182
183 /** Version and CopyRights */
184
185 virtual bool version(char * nVersion);
186
187 /** Number of version */
188
189 virtual void nversion(double &nVersion);
190
191 /** Query power mode */
192
193 virtual bool powerModeQ(bool transit,char &mode);
194
195 /** Specification of power mode */
196
197 virtual bool powerMode(bool transit,char mode);
198
199 /** Check if ptu is moving */
200
201 virtual double status(double &rad){
203 return 1;
204 }
205
206 /** Set limits of movement */
207
208 virtual bool setLimits(char axis, double &l, double &u);
209
210 /* Change motion direction */
211
212 virtual bool changeMotionDir();
213
214
215 /**************************** State Queries ********************/
216
217 /** Check errors, returns 0 if there are not errors or error code in otherwise
218 * Error codes:
219 * \code
220 * 1: Com error
221 * 2: Time out error
222 * 3: Init error
223 * 4: Pan tilt hit error
224 * 5: Pan hit error
225 * 6: Tilt hit error
226 * 7: Max limit error
227 * 8: Min limit error
228 * 9: Out of range
229 * 10: Illegal command error
230 * 11: Unexpected error
231 * \endcode
232 **/
233
234 virtual int checkErrors();
235
236 inline bool noError() { return nError==1; }
237 inline bool comError() { return (nError % CPtuDPerception::ComError)==0; }
238 inline bool timeoutError() { return (nError % CPtuDPerception::TimeoutError)==0; }
239 inline bool initError() { return (nError % CPtuDPerception::InitError)==0; }
240 inline bool panTiltHitError() { return (nError % CPtuDPerception::PanTiltHitError)==0; }
241 inline bool panHitError() { return (nError % CPtuDPerception::PanHitError)==0; }
242 inline bool tiltHitError() { return (nError % CPtuDPerception::TiltHitError)==0; }
243 inline bool maxLimitError() { return (nError % CPtuDPerception::MaxLimitError)==0; }
244 inline bool minLimitError () { return (nError % CPtuDPerception::MinLimitError)==0; }
245 inline bool outOfRange() { return (nError % CPtuDPerception::OutOfRange)==0; }
246 inline bool illegalCommandError() { return (nError % CPtuDPerception::IllegalCommandError)==0; }
247 inline bool unExpectedError() { return (nError % CPtuDPerception::UnExpectedError)==0; }
248
249 /** Clear errors **/
250
251 virtual void clearErrors() { nError=NoError; }
252
253
254 /*************************** Other member methods *****************/
255
256 public:
257
258 /** PTU and serial port initialization */
259
260 virtual bool init(const std::string &port);
261
262 /** Close conection with serial port */
263
264 virtual void close();
265
266 /** To obtains the mistake for use discrete values when the movement
267 * is expressed in radians. Parameters are the absolute position in
268 * radians and the axis desired
269 */
270
271 virtual double radError(char axis,double nRadMoved);
272
273 /** To obtain the discrete value for a number of radians */
274
275 virtual long radToPos(char axis,double nRad);
276
277 /** To obtain the number of radians for a discrete value */
278
279 virtual double posToRad(char axis,long nPos);
280
281 /** Performs a scan in the axis indicated and whit the precision desired. \n
282 * \param <axis> {Pan or Till} \n
283 * \param <tWait> {Wait time betwen commands} \n
284 * \param <initial> {initial position}
285 * \param <final> {final position}
286 * \param <radPre> {radians precision for the scan}
287 */
288
289 virtual bool scan(char axis, int wait, float initial, float final, double radPre);
290
291 /** Query verbose mode */
292
293 virtual bool verboseQ(bool &modo);
294
295 /** Set verbose. \n
296 * \conde
297 * Example of response with FV (verbose) active:
298 * FV *
299 * PP * Current pan position is 0
300 * Example of response with FT (terse) active:
301 * FT *
302 * PP * 0
303 * \endcode
304 */
305
306 virtual bool verbose(bool set);
307
308 /** Query echo mode */
309
310 virtual bool echoModeQ(bool &mode);
311
312 /** Enable/Disable echo response with command. \n
313 * \code
314 * Example of use (EE supposed):
315 * PP * 22
316 * ED *
317 * <pp entered again, but not echoed>* 22
318 * \endcode
319 */
320
321 virtual bool echoMode(bool mode);
322
323 /** Query the pan and tilt resolution per position moved
324 * and initialize local atributes
325 */
326
327 virtual bool resolution(void);
328
329
330 /*************************** Methods for internal use ****************/
331
332 private:
333
334 /** To transmition commands to the PTU */
335
336 virtual bool transmit(const char * command);
337
338 /** To receive the responseof the PTU */
339
340 virtual bool receive(const char * command,char * response);
341
342 /** Used to obtains a number of radians */
343
344 virtual bool radQuerry(char axis,char command,double &nRad);
345
346 /** Method used for asign a number of radians with a command */
347
348 virtual bool radAsign(char axis,char command,double nRad);
349
350 /** Convert string to double */
351
352 virtual double convertToDouble(char *sDouble);
353
354 /** Convert string to long */
355
356 virtual long convertToLong(char *sLong);
357
358 /**************************** Atributes ********************/
359
360 public:
361
362 enum { NoError = 1, ComError = 2, TimeoutError = 3,
363 InitError = 5,PanHitError = 7, TiltHitError = 11, PanTiltHitError=13,
364 MaxLimitError = 17, MinLimitError = 19, OutOfRange = 23,
365 IllegalCommandError = 29, UnExpectedError =31 };
366
367 /** TimeoutError: Only occurs if the communication is cut with PTU
368 * so it is advisable to check the connection and initialize
369 * again the comunication.
370 */
371
373
374 enum { Pan = 'P', Tilt = 'T' };
375 enum { Regular = 'R', High = 'H', Low = 'L', Off = 'O' };
376 enum { Com1 = 1, Com2 = 2, Com3 = 3, Com4 = 4 };
377
378
379 }; // End of class
380
381 } // End of namespace
382
383} // End of namespace
384
385#endif
This class implements initialization and comunication methods to control a generic Pan and Tilt Unit,...
Definition: CPtuBase.h:24
This class implements initialization and comunication methods to control a Pan and Tilt Unit model PT...
virtual bool echoModeQ(bool &mode)
Query echo mode.
CPtuDPerception()
Default constructor.
virtual bool baseSpeed(char axis, double radSec)
Specification of velocity to which start and finish the (de/a)celeration.
virtual bool scan(char axis, int wait, float initial, float final, double radPre)
Performs a scan in the axis indicated and whit the precision desired.
virtual bool moveToOffPos(char axis, double nRad)
Specify desired axis position as an offset from the current position.
virtual bool lowerSpeed(char axis, double radSec)
Specification of velocity lower limit.
virtual long convertToLong(char *sLong)
Convert string to long.
virtual bool offPosQ(char axis, double &nRad)
Query position in relative terms.
virtual bool powerMode(bool transit, char mode)
Specification of power mode.
virtual bool radQuerry(char axis, char command, double &nRad)
Used to obtains a number of radians.
virtual bool baseSpeedQ(char axis, double &radSec)
Query velocity to which start and finish the (de/a)celeration.
virtual bool restoreFactoryDefaults(void)
Restore factory default values.
virtual bool aceleration(char axis, double radSec2)
Specification (de/a)celeration in turn.
virtual bool radAsign(char axis, char command, double nRad)
Method used for asign a number of radians with a command.
virtual bool enableLimitsQ(bool &enable)
Query if exist movement limits.
virtual bool moveToAbsPos(char axis, double nRad)
Specification of positions in absolute terms.
virtual ~CPtuDPerception()
Destructor.
virtual bool lowerSpeedQ(char axis, double &radSec)
Query velocity lower limit.
virtual bool haltAll()
Inmediately stop all.
virtual bool speedQ(char axis, double &radSec)
Query turn speed.
virtual bool resolution(void)
Query the pan and tilt resolution per position moved and initialize local atributes.
virtual bool minPosQ(char axis, double &nRad)
Query min movement limit of a axis in absolute terms.
virtual bool restoreDefaults(void)
Restore default values.
virtual void nversion(double &nVersion)
Number of version.
virtual void clearErrors()
Clear errors.
virtual bool verbose(bool set)
Set verbose.
virtual bool transmit(const char *command)
To transmition commands to the PTU.
int nError
TimeoutError: Only occurs if the communication is cut with PTU so it is advisable to check the connec...
virtual bool enableLimits(bool set)
Enable/Disable movement limits.
virtual bool absPosQ(char axis, double &nRad)
Query position in absolute terms.
virtual bool aWait(void)
Wait the finish of the last position command to continue accept commands.
virtual double radError(char axis, double nRadMoved)
To obtains the mistake for use discrete values when the movement is expressed in radians.
virtual bool speed(char axis, double radSec)
Specification of turn speed.
virtual bool reset(void)
Reset PTU to initial state.
virtual bool rangeMeasure()
Search limit forward.
virtual double posToRad(char axis, long nPos)
To obtain the number of radians for a discrete value.
virtual bool save(void)
Save or restart default values.
virtual bool powerModeQ(bool transit, char &mode)
Query power mode.
virtual bool inmediateExecution(bool set)
With I mode (default) instructs pan-tilt unit to immediately execute positional commands.
virtual double convertToDouble(char *sDouble)
Convert string to double.
virtual long radToPos(char axis, double nRad)
To obtain the discrete value for a number of radians.
virtual bool upperSpeedQ(char axis, double &radSec)
Query velocity upper limit.
virtual bool acelerationQ(char axis, double &radSec2)
Query (de/a)celeration in turn.
virtual bool echoMode(bool mode)
Enable/Disable echo response with command.
virtual bool halt(char axis)
Inmediately stop.
virtual bool receive(const char *command, char *response)
To receive the responseof the PTU.
virtual bool maxPosQ(char axis, double &nRad)
Query max movement limit of a axis in absolute terms.
virtual bool upperSpeed(char axis, double radSec)
Specification of velocity upper limit.
virtual bool verboseQ(bool &modo)
Query verbose mode.
virtual void close()
Close conection with serial port.
virtual bool version(char *nVersion)
Version and CopyRights.
virtual bool setLimits(char axis, double &l, double &u)
Set limits of movement.
virtual double status(double &rad)
Check if ptu is moving.
virtual int checkErrors()
Check errors, returns 0 if there are not errors or error code in otherwise Error codes:
virtual bool init(const std::string &port)
PTU and serial port initialization.
#define HWDRIVERS_IMPEXP
#define MRPT_UNUSED_PARAM(a)
Can be used to avoid "not used parameters" warnings from the compiler.
Definition: mrpt_macros.h:290
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.



Page generated by Doxygen 1.9.5 for MRPT 1.4.0 SVN: at Tue Dec 27 00:54:45 UTC 2022