Main MRPT website > C++ reference for MRPT 1.4.0
CTuMicos.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 CTuMicos_H
11#define CTuMicos_H
12
16
17namespace mrpt
18{
19 namespace hwdrivers
20 {
21 /** This class implements initialization and comunication methods to
22 * control a Tilt Unit model DT-80, working in radians .
23 * \ingroup mrpt_hwdrivers_grp
24 */
26 {
27
28 public:
29
30 /** Default constructor */
31
33
34 /** Destructor */
35
36 virtual ~CTuMicos(){ close(); }
37
38 /*************************** Commands ***************************/
39
40 public:
41
42 /** Search limit forward */
43
44 virtual bool rangeMeasure();
45
46 /** Specification of positions in absolute terms */
47
48 virtual bool moveToAbsPos(char axis,double nRad);
49
50 /** Query position in absolute terms */
51
52 virtual bool absPosQ(char axis,double &nRad);
53
54 /** Specify desired axis position as an offset from the current position. \n
55 * This method recives the number of radians to move.
56 * \code
57 * Example of use:
58 * TT-500 *
59 * A *
60 * TO * Current Tilt position is -500
61 * TO500 *
62 * A *
63 * TT * Current Pan position is 1000
64 * \endcode
65 */
66
67 virtual bool moveToOffPos(char axis,double nRad);
68
69 /** Query position in relative terms */
70
71 virtual bool offPosQ(char axis,double &nRad);
72
73 /** Query max movement limit of a axis in absolute terms */
74
75 virtual bool maxPosQ(char axis,double &nRad);
76
77 /** Query min movement limit of a axis in absolute terms */
78
79 virtual bool minPosQ(char axis,double &nRad);
80
81 /** Query if exist movement limits */
82
83 virtual bool enableLimitsQ(bool &enable); // Query if exist some limit
84
85 /** Enable/Disable movement limits */
86
87 virtual bool enableLimits(bool set);
88
89 /** With I mode (default) instructs pan-tilt unit to immediately
90 * execute positional commands. \n
91 * In S mode instructs pan-tilt unit to execute positional commands
92 * only when an Await Position Command Completion command is executed
93 * or when put into Immediate Execution Mode. \n
94 * \code
95 * Example of use of S mode:
96 * DR *
97 * S *
98 * PP1500 *
99 * TP-900 *
100 * PP * Current Pan position is 0
101 * TP * Current Tilt position is 0
102 * A *
103 * PP * Current Pan position is 1500
104 * TP * Current Tilt position is -900
105 * \endcode
106 */
107
108 virtual bool inmediateExecution(bool set);
109
110 /** Wait the finish of the last position command to
111 * continue accept commands
112 */
113
114 virtual bool aWait(void);
115
116 /** Inmediately stop all */
117
118 virtual bool haltAll();
119
120 /** Inmediately stop */
121
122 virtual bool halt(char axis);
123
124 /** Specification of turn speed */
125
126 virtual bool speed(char axis,double radSec);
127
128 /** Query turn speed */
129
130 virtual bool speedQ(char axis,double &radSec);
131
132 /** Specification (de/a)celeration in turn */
133
134 virtual bool aceleration(char axis,double radSec2);
135
136 /** Query (de/a)celeration in turn */
137
138 virtual bool acelerationQ(char axis,double &radSec2);
139
140 /** Specification of velocity to which start and finish
141 * the (de/a)celeration
142 */
143
144 virtual bool baseSpeed(char axis,double radSec);
145
146 /** Query velocity to which start and finish
147 * the (de/a)celeration
148 */
149
150 virtual bool baseSpeedQ(char axis,double &radSec);
151
152 /** Specification of velocity upper limit */
153
154 virtual bool upperSpeed(char axis,double radSec);
155
156 /** Query velocity upper limit */
157
158 virtual bool upperSpeedQ(char axis,double &radSec);
159
160 /** Specification of velocity lower limit */
161
162 virtual bool lowerSpeed(char axis,double radSec);
163
164 /** Query velocity lower limit */
165
166 virtual bool lowerSpeedQ(char axis,double &radSec);
167
168 /** Reset PTU to initial state */
169
170 virtual bool reset(void);
171
172 /** Save or restart default values */
173
174 virtual bool save(void);
175
176 /** Restore default values */
177
178 virtual bool restoreDefaults(void);
179
180 /** Restore factory default values */
181
182 virtual bool restoreFactoryDefaults(void);
183
184 /** Version and CopyRights */
185
186 virtual bool version(char * nVersion);
187
188 /** Number of version */
189
190 virtual void nversion(double &nVersion);
191
192 /** Query power mode */
193
194 virtual bool powerModeQ(bool transit,char &mode);
195
196 /** Specification of power mode */
197
198 virtual bool powerMode(bool transit,char mode);
199
200 /** Clear controller internal stack */
201
202 bool clear();
203
204 /** Set limits of movement */
205
206 virtual bool setLimits(char axis, double &l, double &u);
207
208 /* Change motion direction */
209
210 virtual bool changeMotionDir();
211
212
213 /**************************** State Queries ********************/
214
215 virtual int checkErrors();
216
217 /** Clear errors **/
218
219 virtual void clearErrors() { }
220
221
222 /*************************** Other member methods *****************/
223
224 public:
225
226 /** PTU and serial port initialization */
227
228 virtual bool init(const std::string &port);
229
230 /** Close conection with serial port */
231
232 virtual void close();
233
234 /** To obtains the mistake for use discrete values when the movement
235 * is expressed in radians. Parameters are the absolute position in
236 * radians and the axis desired
237 */
238
239 virtual double radError(char axis,double nRadMoved);
240
241 /** To obtain the discrete value for a number of radians */
242
243 virtual long radToPos(char axis,double nRad);
244
245 /** To obtain the number of radians for a discrete value */
246
247 virtual double posToRad(char axis,long nPos);
248
249 /** Performs a scan in the axis indicated and whit the precision desired. \n
250 * \param <axis> {Pan or Till} \n
251 * \param <tWait> {Wait time betwen commands} \n
252 * \param <initial> {initial position}
253 * \param <final> {final position}
254 * \param <radPre> {radians precision for the scan}
255 */
256
257 virtual bool scan(char axis, int wait, float initial, float final, double radPre);
258
259 /** Query verbose mode */
260
261 virtual bool verboseQ(bool &modo);
262
263 /** Set verbose. \n
264 * \conde
265 * Example of response with FV (verbose) active:
266 * FV *
267 * PP * Current pan position is 0
268 * Example of response with FT (terse) active:
269 * FT *
270 * PP * 0
271 * \endcode
272 */
273
274 virtual bool verbose(bool set);
275
276 /** Query echo mode */
277
278 virtual bool echoModeQ(bool &mode);
279
280 /** Enable/Disable echo response with command. \n
281 * \code
282 * Example of use (EE supposed):
283 * PP * 22
284 * ED *
285 * <pp entered again, but not echoed>* 22
286 * \endcode
287 */
288
289 virtual bool echoMode(bool mode);
290
291 /** Query the pan and tilt resolution per position moved
292 * and initialize local atributes
293 */
294
295 virtual bool resolution(void);
296
297 /** Check if ptu is moving */
298
299 virtual double status(double &rad);
300
301
302 /*************************** Methods for internal use ****************/
303
304 private:
305
306 /** To transmition commands to the PTU */
307
308 virtual bool transmit(const char * command);
309
310 /** To receive the responseof the PTU */
311
312 virtual bool receive(const char * command,char * response);
313
314 /** Used to obtains a number of radians */
315
316 virtual bool radQuerry(char axis,char command,double &nRad);
317
318 /** Method used for asign a number of radians with a command */
319
320 virtual bool radAsign(char axis,char command,double nRad);
321
322 /** Convert string to double */
323
324 static double convertToDouble(char *sDouble);
325
326 /** Convert string to long */
327
328 static long convertToLong(char *sLong);
329
330 /**************************** Atributes ********************/
331
332 public:
333
334 /* Index of the Tilt axis in use */
335
337
338
339 }; // End of class
340
341 } // End of namespace
342
343} // End of namespace
344
345#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 Tilt Unit model DT-80,...
Definition: CTuMicos.h:26
virtual bool changeMotionDir()
virtual bool enableLimitsQ(bool &enable)
Query if exist movement limits.
virtual bool moveToAbsPos(char axis, double nRad)
Specification of positions in absolute terms.
virtual void clearErrors()
Clear errors.
Definition: CTuMicos.h:219
virtual bool echoMode(bool mode)
Enable/Disable echo response with command.
virtual bool transmit(const char *command)
To transmition commands to the PTU.
virtual bool baseSpeedQ(char axis, double &radSec)
Query velocity to which start and finish the (de/a)celeration.
virtual bool moveToOffPos(char axis, double nRad)
Specify desired axis position as an offset from the current position.
virtual void close()
Close conection with serial port.
virtual bool lowerSpeed(char axis, double radSec)
Specification of velocity lower limit.
virtual bool receive(const char *command, char *response)
To receive the responseof the PTU.
virtual bool radAsign(char axis, char command, double nRad)
Method used for asign a number of radians with a command.
virtual bool init(const std::string &port)
PTU and serial port initialization.
virtual long radToPos(char axis, double nRad)
To obtain the discrete value for a number of radians.
virtual int checkErrors()
Check errors, returns 0 if there are not errors or error code otherwise.
virtual bool halt(char axis)
Inmediately stop.
virtual bool speed(char axis, double radSec)
Specification of turn speed.
virtual void nversion(double &nVersion)
Number of version.
virtual bool restoreFactoryDefaults(void)
Restore factory default values.
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 haltAll()
Inmediately stop all.
virtual bool powerModeQ(bool transit, char &mode)
Query power mode.
virtual bool maxPosQ(char axis, double &nRad)
Query max movement limit of a axis in absolute terms.
virtual bool verboseQ(bool &modo)
Query verbose mode.
virtual bool restoreDefaults(void)
Restore default values.
virtual bool radQuerry(char axis, char command, double &nRad)
Used to obtains a number of radians.
virtual ~CTuMicos()
Destructor.
Definition: CTuMicos.h:36
bool clear()
Clear controller internal stack.
virtual double status(double &rad)
Check if ptu is moving.
virtual bool baseSpeed(char axis, double radSec)
Specification of velocity to which start and finish the (de/a)celeration.
virtual bool acelerationQ(char axis, double &radSec2)
Query (de/a)celeration in turn.
virtual bool echoModeQ(bool &mode)
Query echo mode.
virtual double radError(char axis, double nRadMoved)
To obtains the mistake for use discrete values when the movement is expressed in radians.
virtual bool upperSpeed(char axis, double radSec)
Specification of velocity upper limit.
virtual bool speedQ(char axis, double &radSec)
Query turn speed.
virtual bool upperSpeedQ(char axis, double &radSec)
Query velocity upper limit.
virtual bool reset(void)
Reset PTU to initial state.
virtual bool save(void)
Save or restart default values.
virtual bool powerMode(bool transit, char mode)
Specification of power mode.
virtual bool minPosQ(char axis, double &nRad)
Query min movement limit of a axis in absolute terms.
static double convertToDouble(char *sDouble)
Convert string to double.
virtual bool verbose(bool set)
Set verbose.
virtual bool rangeMeasure()
Search limit forward.
virtual bool resolution(void)
Query the pan and tilt resolution per position moved and initialize local atributes.
virtual bool enableLimits(bool set)
Enable/Disable movement limits.
virtual bool offPosQ(char axis, double &nRad)
Query position in relative terms.
static long convertToLong(char *sLong)
Convert string to long.
virtual bool aceleration(char axis, double radSec2)
Specification (de/a)celeration in turn.
virtual bool lowerSpeedQ(char axis, double &radSec)
Query velocity lower limit.
virtual bool inmediateExecution(bool set)
With I mode (default) instructs pan-tilt unit to immediately execute positional commands.
virtual bool absPosQ(char axis, double &nRad)
Query position in absolute terms.
virtual bool setLimits(char axis, double &l, double &u)
Set limits of movement.
virtual double posToRad(char axis, long nPos)
To obtain the number of radians for a discrete value.
virtual bool version(char *nVersion)
Version and CopyRights.
CTuMicos()
Default constructor.
Definition: CTuMicos.h:32
virtual bool aWait(void)
Wait the finish of the last position command to continue accept commands.
This base class provides a common printf-like method to send debug information to std::cout,...
#define HWDRIVERS_IMPEXP
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.



Page generated by Doxygen 1.9.6 for MRPT 1.4.0 SVN: at Fri Jan 20 00:13:14 UTC 2023