yarp-devices
TechnosoftIpos.hpp
1 // -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-
2 
3 #ifndef __TECHNOSOFT_IPOS_HPP__
4 #define __TECHNOSOFT_IPOS_HPP__
5 
6 #include "TechnosoftIposBase.hpp"
7 
8 namespace roboticslab
9 {
10 
21 class TechnosoftIpos : public yarp::dev::DeviceDriver,
22  public yarp::dev::IAxisInfoRaw,
23  public yarp::dev::IControlLimitsRaw,
24  public yarp::dev::IControlModeRaw,
25  public yarp::dev::ICurrentControlRaw,
26  public yarp::dev::IEncodersTimedRaw,
27  public yarp::dev::IImpedanceControlRaw,
28  public yarp::dev::IInteractionModeRaw,
29  public yarp::dev::IJointFaultRaw,
30  public yarp::dev::IMotorRaw,
31  public yarp::dev::IMotorEncodersRaw,
32  public yarp::dev::IPidControlRaw,
33  public yarp::dev::IPositionControlRaw,
34  public yarp::dev::IPositionDirectRaw,
35  public yarp::dev::IRemoteVariablesRaw,
36  public yarp::dev::ITorqueControlRaw,
37  public yarp::dev::IVelocityControlRaw,
38  public ICanBusSharer
39 {
40 public:
41 
42  ~TechnosoftIpos() override
43  { close(); }
44 
45  // --------- DeviceDriver declarations. Implementation in DeviceDriverImpl.cpp ---------
46 
47  bool open(yarp::os::Searchable & config) override;
48  bool close() override;
49 
50  std::string id() const override
51  { return impl->id(); }
52 
53  // --------- ICanBusSharer declarations. Implementation in ICanBusSharerImpl.cpp ---------
54 
55  unsigned int getId() override
56  { return impl->getId(); }
57 
58  std::vector<unsigned int> getAdditionalIds() override
59  { return impl->getAdditionalIds(); }
60 
61  bool notifyMessage(const can_message & message) override
62  { return impl->notifyMessage(message); }
63 
64  bool initialize() override
65  { return impl->initialize(); }
66 
67  bool finalize() override
68  { return impl->finalize(); }
69 
70  bool registerSender(ICanSenderDelegate * sender) override
71  { return impl->registerSender(sender); }
72 
73  bool synchronize(double timestamp) override
74  { return impl->synchronize(timestamp); }
75 
76  // --------- IAxisInfoRaw declarations. Implementation in IAxisInfoRawImpl.cpp ---------
77 
78  bool getAxisNameRaw(int axis, std::string & name) override
79  { return impl->getAxisNameRaw(axis, name); }
80 
81  bool getJointTypeRaw(int axis, yarp::dev::JointTypeEnum & type) override
82  { return impl->getJointTypeRaw(axis, type); }
83 
84  // --------- IControlLimitsRaw declarations. Implementation in IControlLimitsRawImpl.cpp ---------
85 
86  bool setLimitsRaw(int axis, double min, double max) override
87  { return impl->setLimitsRaw(axis, min, max); }
88 
89  bool getLimitsRaw(int axis, double * min, double * max) override
90  { return impl->getLimitsRaw(axis, min, max); }
91 
92  bool setVelLimitsRaw(int axis, double min, double max) override
93  { return impl->setVelLimitsRaw(axis, min, max); }
94 
95  bool getVelLimitsRaw(int axis, double * min, double * max) override
96  { return impl->getVelLimitsRaw(axis, min, max); }
97 
98  // --------- IControlModeRaw declarations. Implementation in IControlModeRawImpl.cpp ---------
99 
100  bool getControlModeRaw(int j, int * mode) override
101  { return impl->getControlModeRaw(j, mode); }
102 
103  bool getControlModesRaw(int * modes) override
104  { return impl->getControlModesRaw(modes); }
105 
106  bool getControlModesRaw(int n_joint, const int * joints, int * modes) override
107  { return impl->getControlModesRaw(n_joint, joints, modes); }
108 
109  bool setControlModeRaw(int j, int mode) override
110  { return impl->setControlModeRaw(j, mode); }
111 
112  bool setControlModesRaw(int * modes) override
113  { return impl->setControlModesRaw(modes); }
114 
115  bool setControlModesRaw(int n_joint, const int * joints, int * modes) override
116  { return impl->setControlModesRaw(n_joint, joints, modes); }
117 
118  // --------- ICurrentControlRaw declarations. Implementation in ICurrentControlRawImpl.cpp ---------
119 
120  //bool getNumberOfMotorsRaw(int * number) override;
121 
122  bool getCurrentRaw(int m, double * curr) override
123  { return impl->getCurrentRaw(m, curr); }
124 
125  bool getCurrentsRaw(double * currs) override
126  { return impl->getCurrentsRaw(currs); }
127 
128  bool getCurrentRangeRaw(int m, double * min, double * max) override
129  { return impl->getCurrentRangeRaw(m, min, max); }
130 
131  bool getCurrentRangesRaw(double * min, double * max) override
132  { return impl->getCurrentRangesRaw(min, max); }
133 
134  bool setRefCurrentRaw(int m, double curr) override
135  { return impl->setRefCurrentRaw(m, curr); }
136 
137  bool setRefCurrentsRaw(const double * currs) override
138  { return impl->setRefCurrentsRaw(currs); }
139 
140  bool setRefCurrentsRaw(int n_motor, const int * motors, const double * currs) override
141  { return impl->setRefCurrentsRaw(n_motor, motors, currs); }
142 
143  bool getRefCurrentRaw(int m, double * curr) override
144  { return impl->getRefCurrentRaw(m, curr); }
145 
146  bool getRefCurrentsRaw(double * currs) override
147  { return impl->getRefCurrentsRaw(currs); }
148 
149  // ---------- IEncodersRaw declarations. Implementation in IEncodersRawImpl.cpp ----------
150 
151  bool getAxes(int * ax) override
152  { return impl->getAxes(ax); }
153 
154  bool resetEncoderRaw(int j) override
155  { return impl->resetEncoderRaw(j); }
156 
157  bool resetEncodersRaw() override
158  { return impl->resetEncodersRaw(); }
159 
160  bool setEncoderRaw(int j, double val) override
161  { return impl->setEncoderRaw(j, val); }
162 
163  bool setEncodersRaw(const double * vals) override
164  { return impl->setEncodersRaw(vals); }
165 
166  bool getEncoderRaw(int j, double * v) override
167  { return impl->getEncoderRaw(j, v); }
168 
169  bool getEncodersRaw(double * encs) override
170  { return impl->getEncodersRaw(encs); }
171 
172  bool getEncoderSpeedRaw(int j, double * sp) override
173  { return impl->getEncoderSpeedRaw(j, sp); }
174 
175  bool getEncoderSpeedsRaw(double * spds) override
176  { return impl->getEncoderSpeedsRaw(spds); }
177 
178  bool getEncoderAccelerationRaw(int j, double * spds) override
179  { return impl->getEncoderAccelerationRaw(j, spds); }
180 
181  bool getEncoderAccelerationsRaw(double * accs) override
182  { return impl->getEncoderAccelerationsRaw(accs); }
183 
184  // ---------- IEncodersTimedRaw declarations. Implementation in IEncodersRawImpl.cpp ----------
185 
186  bool getEncoderTimedRaw(int j, double * encs, double * time) override
187  { return impl->getEncoderTimedRaw(j, encs, time); }
188 
189  bool getEncodersTimedRaw(double * encs, double * time) override
190  { return impl->getEncodersTimedRaw(encs, time); }
191 
192  // ---------- IImpedanceControlRaw declarations. Implementation in IImpedanceControlRawImpl.cpp ----------
193 
194  //bool getAxes(int * ax) override;
195 
196  bool getImpedanceRaw(int j, double * stiffness, double * damping) override
197  { return impl->getImpedanceRaw(j, stiffness, damping); }
198 
199  bool setImpedanceRaw(int j, double stiffness, double damping) override
200  { return impl->setImpedanceRaw(j, stiffness, damping); }
201 
202  bool setImpedanceOffsetRaw(int j, double offset) override
203  { return impl->setImpedanceOffsetRaw(j, offset); }
204 
205  bool getImpedanceOffsetRaw(int j, double * offset) override
206  { return impl->getImpedanceOffsetRaw(j, offset); }
207 
208  bool getCurrentImpedanceLimitRaw(int j, double * min_stiff, double * max_stiff, double * min_damp, double * max_damp) override
209  { return impl->getCurrentImpedanceLimitRaw(j, min_stiff, max_stiff, min_damp, max_damp); }
210 
211  // ---------- IInteractionModeRaw declarations. Implementation in IInteractionModeRawImpl.cpp ----------
212 
213  bool getInteractionModeRaw(int axis, yarp::dev::InteractionModeEnum * mode) override
214  { return impl->getInteractionModeRaw(axis, mode); }
215 
216  bool getInteractionModesRaw(int n_joints, int * joints, yarp::dev::InteractionModeEnum * modes) override
217  { return impl->getInteractionModesRaw(n_joints, joints, modes); }
218 
219  bool getInteractionModesRaw(yarp::dev::InteractionModeEnum * modes) override
220  { return impl->getInteractionModesRaw(modes); }
221 
222  bool setInteractionModeRaw(int axis, yarp::dev::InteractionModeEnum mode) override
223  { return impl->setInteractionModeRaw(axis, mode); }
224 
225  bool setInteractionModesRaw(int n_joints, int * joints, yarp::dev::InteractionModeEnum * modes) override
226  { return impl->setInteractionModesRaw(n_joints, joints, modes); }
227 
228  bool setInteractionModesRaw(yarp::dev::InteractionModeEnum * modes) override
229  { return impl->setInteractionModesRaw(modes); }
230 
231  // ---------- IJointFaultRaw declarations. Implementation in IJointFaultRawImpl.cpp ----------
232 
233  bool getLastJointFaultRaw(int j, int & fault, std::string & message) override
234  { return impl->getLastJointFaultRaw(j, fault, message); }
235 
236  // --------- IMotorRaw declarations. Implementation in IMotorRawImpl.cpp ---------
237 
238  bool getNumberOfMotorsRaw(int * num) override
239  { return impl->getNumberOfMotorsRaw(num); }
240 
241  bool getTemperatureRaw(int m, double * val) override
242  { return impl->getTemperatureRaw(m, val); }
243 
244  bool getTemperaturesRaw(double * vals) override
245  { return impl->getTemperaturesRaw(vals); }
246 
247  bool getTemperatureLimitRaw(int m, double * temp) override
248  { return impl->getTemperatureLimitRaw(m, temp); }
249 
250  bool setTemperatureLimitRaw(int m, double temp) override
251  { return impl->setTemperatureLimitRaw(m, temp); }
252 
253  bool getGearboxRatioRaw(int m, double * val) override
254  { return impl->getGearboxRatioRaw(m, val); }
255 
256  bool setGearboxRatioRaw(int m, double val) override
257  { return impl->setGearboxRatioRaw(m, val); }
258 
259  // --------- IMotorEncodersRaw declarations. Implementation in IMotorEncodersRawImpl.cpp ---------
260 
261  bool getNumberOfMotorEncodersRaw(int * num) override
262  { return impl->getNumberOfMotorEncodersRaw(num); }
263 
264  bool resetMotorEncoderRaw(int m) override
265  { return impl->resetMotorEncoderRaw(m); }
266 
267  bool resetMotorEncodersRaw() override
268  { return impl->resetMotorEncodersRaw(); }
269 
270  bool setMotorEncoderCountsPerRevolutionRaw(int m, double cpr) override
271  { return impl->setMotorEncoderCountsPerRevolutionRaw(m, cpr); }
272 
273  bool getMotorEncoderCountsPerRevolutionRaw(int m, double * cpr) override
274  { return impl->getMotorEncoderCountsPerRevolutionRaw(m, cpr); }
275 
276  bool setMotorEncoderRaw(int m, double val) override
277  { return impl->setMotorEncoderRaw(m, val); }
278 
279  bool setMotorEncodersRaw(const double * vals) override
280  { return impl->setMotorEncodersRaw(vals); }
281 
282  bool getMotorEncoderRaw(int m, double * v) override
283  { return impl->getMotorEncoderRaw(m, v); }
284 
285  bool getMotorEncodersRaw(double * encs) override
286  { return impl->getMotorEncodersRaw(encs); }
287 
288  bool getMotorEncoderTimedRaw(int m, double * encs, double * stamp) override
289  { return impl->getMotorEncoderTimedRaw(m, encs, stamp); }
290 
291  bool getMotorEncodersTimedRaw(double * encs, double * stamps) override
292  { return impl->getMotorEncodersTimedRaw(encs, stamps); }
293 
294  bool getMotorEncoderSpeedRaw(int m, double * sp) override
295  { return impl->getMotorEncoderSpeedRaw(m, sp); }
296 
297  bool getMotorEncoderSpeedsRaw(double * spds) override
298  { return impl->getMotorEncoderSpeedsRaw(spds); }
299 
300  bool getMotorEncoderAccelerationRaw(int m, double * spds) override
301  { return impl->getMotorEncoderAccelerationRaw(m, spds); }
302 
303  bool getMotorEncoderAccelerationsRaw(double * vaccs) override
304  { return impl->getMotorEncoderAccelerationsRaw(vaccs); }
305 
306  // --------- IPidControlRaw declarations. Implementation in IPidControlRawImpl.cpp ---------
307 
308  bool setPidRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, const yarp::dev::Pid & pid) override
309  { return impl->setPidRaw(pidtype, j, pid); }
310 
311  bool setPidsRaw(const yarp::dev::PidControlTypeEnum & pidtype, const yarp::dev::Pid * pids) override
312  { return impl->setPidsRaw(pidtype, pids); }
313 
314  bool setPidReferenceRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double ref) override
315  { return impl->setPidReferenceRaw(pidtype, j, ref); }
316 
317  bool setPidReferencesRaw(const yarp::dev::PidControlTypeEnum & pidtype, const double * refs) override
318  { return impl->setPidReferencesRaw(pidtype, refs); }
319 
320  bool setPidErrorLimitRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double limit) override
321  { return impl->setPidErrorLimitRaw(pidtype, j, limit); }
322 
323  bool setPidErrorLimitsRaw(const yarp::dev::PidControlTypeEnum & pidtype, const double * limits) override
324  { return impl->setPidErrorLimitsRaw(pidtype, limits); }
325 
326  bool getPidErrorRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double * err) override
327  { return impl->getPidErrorRaw(pidtype, j, err); }
328 
329  bool getPidErrorsRaw(const yarp::dev::PidControlTypeEnum & pidtype, double * errs) override
330  { return impl->getPidErrorsRaw(pidtype, errs); }
331 
332  bool getPidOutputRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double * out) override
333  { return impl->getPidOutputRaw(pidtype, j, out); }
334 
335  bool getPidOutputsRaw(const yarp::dev::PidControlTypeEnum & pidtype, double * outs) override
336  { return impl->getPidOutputsRaw(pidtype, outs); }
337 
338  bool getPidRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, yarp::dev::Pid * pid) override
339  { return impl->getPidRaw(pidtype, j, pid); }
340 
341  bool getPidsRaw(const yarp::dev::PidControlTypeEnum & pidtype, yarp::dev::Pid * pids) override
342  { return impl->getPidsRaw(pidtype, pids); }
343 
344  bool getPidReferenceRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double * ref) override
345  { return impl->getPidReferenceRaw(pidtype, j, ref); }
346 
347  bool getPidReferencesRaw(const yarp::dev::PidControlTypeEnum & pidtype, double * refs) override
348  { return impl->getPidReferencesRaw(pidtype, refs); }
349 
350  bool getPidErrorLimitRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double * limit) override
351  { return impl->getPidErrorLimitRaw(pidtype, j, limit); }
352 
353  bool getPidErrorLimitsRaw(const yarp::dev::PidControlTypeEnum & pidtype, double * limits) override
354  { return impl->getPidErrorLimitsRaw(pidtype, limits); }
355 
356  bool resetPidRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j) override
357  { return impl->resetPidRaw(pidtype, j); }
358 
359  bool disablePidRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j) override
360  { return impl->disablePidRaw(pidtype, j); }
361 
362  bool enablePidRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j) override
363  { return impl->enablePidRaw(pidtype, j); }
364 
365  bool setPidOffsetRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, double v) override
366  { return impl->setPidOffsetRaw(pidtype, j, v); }
367 
368  bool isPidEnabledRaw(const yarp::dev::PidControlTypeEnum & pidtype, int j, bool * enabled) override
369  { return impl->isPidEnabledRaw(pidtype, j, enabled); }
370 
371  // ------- IPositionControlRaw declarations. Implementation in IPositionControlRawImpl.cpp -------
372 
373  //bool getAxes(int * ax) override;
374 
375  bool positionMoveRaw(int j, double ref) override
376  { return impl->positionMoveRaw(j, ref); }
377 
378  bool positionMoveRaw(const double * refs) override
379  { return impl->positionMoveRaw(refs); }
380 
381  bool positionMoveRaw(int n_joint, const int * joints, const double * refs) override
382  { return impl->positionMoveRaw(n_joint, joints, refs); }
383 
384  bool relativeMoveRaw(int j, double delta) override
385  { return impl->relativeMoveRaw(j, delta); }
386 
387  bool relativeMoveRaw(const double * deltas) override
388  { return impl->relativeMoveRaw(deltas); }
389 
390  bool relativeMoveRaw(int n_joint, const int * joints, const double * deltas) override
391  { return impl->relativeMoveRaw(n_joint, joints, deltas); }
392 
393  bool checkMotionDoneRaw(int j, bool * flag) override
394  { return impl->checkMotionDoneRaw(j, flag); }
395 
396  bool checkMotionDoneRaw(bool * flag) override
397  { return impl->checkMotionDoneRaw(flag); }
398 
399  bool checkMotionDoneRaw(int n_joint, const int * joints, bool * flag) override
400  { return impl->checkMotionDoneRaw(n_joint, joints, flag); }
401 
402  bool setRefSpeedRaw(int j, double sp) override
403  { return impl->setRefSpeedRaw(j, sp); }
404 
405  bool setRefSpeedsRaw(const double * spds) override
406  { return impl->setRefSpeedsRaw(spds); }
407 
408  bool setRefSpeedsRaw(int n_joint, const int * joints, const double * spds) override
409  { return impl->setRefSpeedsRaw(n_joint, joints, spds); }
410 
411  bool setRefAccelerationRaw(int j, double acc) override
412  { return impl->setRefAccelerationRaw(j, acc); }
413 
414  bool setRefAccelerationsRaw(const double * accs) override
415  { return impl->setRefAccelerationsRaw(accs); }
416 
417  bool setRefAccelerationsRaw(int n_joint, const int * joints, const double * accs) override
418  { return impl->setRefAccelerationsRaw(n_joint, joints, accs); }
419 
420  bool getRefSpeedRaw(int j, double * ref) override
421  { return impl->getRefSpeedRaw(j, ref); }
422 
423  bool getRefSpeedsRaw(double * spds) override
424  { return impl->getRefSpeedsRaw(spds); }
425 
426  bool getRefSpeedsRaw(int n_joint, const int * joints, double * spds) override
427  { return impl->getRefSpeedsRaw(n_joint, joints, spds); }
428 
429  bool getRefAccelerationRaw(int j, double * acc) override
430  { return impl->getRefAccelerationRaw(j, acc); }
431 
432  bool getRefAccelerationsRaw(double * accs) override
433  { return impl->getRefAccelerationsRaw(accs); }
434 
435  bool getRefAccelerationsRaw(int n_joint, const int * joints, double * accs) override
436  { return impl->getRefAccelerationsRaw(n_joint, joints, accs); }
437 
438  bool stopRaw(int j) override
439  { return impl->stopRaw(j); }
440 
441  bool stopRaw() override
442  { return impl->stopRaw(); }
443 
444  bool stopRaw(int n_joint, const int * joints) override
445  { return impl->stopRaw(n_joint, joints); }
446 
447  bool getTargetPositionRaw(int joint, double * ref) override
448  { return impl->getTargetPositionRaw(joint, ref); }
449 
450  bool getTargetPositionsRaw(double * refs) override
451  { return impl->getTargetPositionsRaw(refs); }
452 
453  bool getTargetPositionsRaw(int n_joint, const int * joints, double * refs) override
454  { return impl->getTargetPositionsRaw(n_joint, joints, refs); }
455 
456  // ------- IPositionDirectRaw declarations. Implementation in IPositionDirectRawImpl.cpp -------
457 
458  //bool getAxes(int * ax) override;
459 
460  bool setPositionRaw(int j, double ref) override
461  { return impl->setPositionRaw(j, ref); }
462 
463  bool setPositionsRaw(const double * refs) override
464  { return impl->setPositionsRaw(refs); }
465 
466  bool setPositionsRaw(int n_joint, const int * joints, const double * refs) override
467  { return impl->setPositionsRaw(n_joint, joints, refs); }
468 
469  bool getRefPositionRaw(int joint, double * ref) override
470  { return impl->getRefPositionRaw(joint, ref); }
471 
472  bool getRefPositionsRaw(double * refs) override
473  { return impl->getRefPositionsRaw(refs); }
474 
475  bool getRefPositionsRaw(int n_joint, const int * joints, double * refs) override
476  { return impl->getRefPositionsRaw(n_joint, joints, refs); }
477 
478  // ------- IRemoteVariablesRaw declarations. Implementation in IRemoteVariablesRawImpl.cpp -------
479 
480  bool getRemoteVariableRaw(std::string key, yarp::os::Bottle & val) override
481  { return impl->getRemoteVariableRaw(key, val); }
482 
483  bool setRemoteVariableRaw(std::string key, const yarp::os::Bottle & val) override
484  { return impl->setRemoteVariableRaw(key, val); }
485 
486  bool getRemoteVariablesListRaw(yarp::os::Bottle * listOfKeys) override
487  { return impl->getRemoteVariablesListRaw(listOfKeys); }
488 
489  // -------- ITorqueControlRaw declarations. Implementation in ITorqueControlRawImpl.cpp --------
490 
491  //bool getAxes(int * ax) override;
492 
493  bool getRefTorqueRaw(int j, double * t) override
494  { return impl->getRefTorqueRaw(j, t); }
495 
496  bool getRefTorquesRaw(double * t) override
497  { return impl->getRefTorquesRaw(t); }
498 
499  bool setRefTorqueRaw(int j, double t) override
500  { return impl->setRefTorqueRaw(j, t); }
501 
502  bool setRefTorquesRaw(int n_joint, const int * joints, const double * t) override
503  { return impl->setRefTorquesRaw(n_joint, joints, t); }
504 
505  bool setRefTorquesRaw(const double * t) override
506  { return impl->setRefTorquesRaw(t); }
507 
508  bool getTorqueRaw(int j, double * t) override
509  { return impl->getTorqueRaw(j, t); }
510 
511  bool getTorquesRaw(double * t) override
512  { return impl->getTorquesRaw(t); }
513 
514  bool getTorqueRangeRaw(int j, double * min, double * max) override
515  { return impl->getTorqueRangeRaw(j, min, max); }
516 
517  bool getTorqueRangesRaw(double * min, double * max) override
518  { return impl->getTorqueRangesRaw(min, max); }
519 
520  bool getMotorTorqueParamsRaw(int j, yarp::dev::MotorTorqueParameters * params) override
521  { return impl->getMotorTorqueParamsRaw(j, params); }
522 
523  bool setMotorTorqueParamsRaw(int j, const yarp::dev::MotorTorqueParameters params) override
524  { return impl->setMotorTorqueParamsRaw(j, params); }
525 
526  // --------- IVelocityControlRaw declarations. Implementation in IVelocityControlRawImpl.cpp ---------
527 
528  //bool getAxes(int * ax) override;
529 
530  bool velocityMoveRaw(int j, double sp) override
531  { return impl->velocityMoveRaw(j, sp); }
532 
533  bool velocityMoveRaw(const double * sp) override
534  { return impl->velocityMoveRaw(sp); }
535 
536  bool velocityMoveRaw(int n_joint, const int * joints, const double * spds) override
537  { return impl->velocityMoveRaw(n_joint, joints, spds); }
538 
539  bool getRefVelocityRaw(int joint, double * vel) override
540  { return impl->getRefVelocityRaw(joint, vel); }
541 
542  bool getRefVelocitiesRaw(double * vels) override
543  { return impl->getRefVelocitiesRaw(vels); }
544 
545  bool getRefVelocitiesRaw(int n_joint, const int * joints, double * vels) override
546  { return impl->getRefVelocitiesRaw(n_joint, joints, vels); }
547 
548  //bool setRefAccelerationRaw(int j, double acc) override;
549  //bool setRefAccelerationsRaw(const double * accs) override;
550  //bool setRefAccelerationsRaw(int n_joint, const int * joints, const double * accs) override;
551  //bool getRefAccelerationRaw(int j, double * acc) override;
552  //bool getRefAccelerationsRaw(double * accs) override;
553  //bool getRefAccelerationsRaw(int n_joint, const int * joints, double * accs) override;
554  //bool stopRaw(int j) override;
555  //bool stopRaw() override;
556  //bool stopRaw(int n_joint, const int *joints) override;
557 
558 private:
559 
560  TechnosoftIposBase * impl {nullptr};
561 };
562 
563 } // namespace roboticslab
564 
565 #endif // __TECHNOSOFT_IPOS_HPP__
Abstract base for a CAN bus sharer.
Definition: ICanBusSharer.hpp:25
virtual bool synchronize(double timestamp)=0
Perform synchronized action on CAN master's request.
Implementation-agnostic consumer for TX CAN transfers.
Definition: ICanSenderDelegate.hpp:22
unsigned int getId() override
Retrieve CAN node ID.
Definition: ICanBusSharerImpl.cpp:39
bool initialize() override
Perform CAN node initialization.
Definition: ICanBusSharerImpl.cpp:67
std::vector< unsigned int > getAdditionalIds() override
Retrieve more associated CAN node IDs, if any.
Definition: ICanBusSharerImpl.cpp:46
bool notifyMessage(const can_message &message) override
Notify observers that a new CAN message has arrived.
Definition: ICanBusSharerImpl.cpp:176
bool registerSender(ICanSenderDelegate *sender) override
Pass a handle to a CAN sender delegate instance.
Definition: ICanBusSharerImpl.cpp:58
bool finalize() override
Finalize CAN node communications.
Definition: ICanBusSharerImpl.cpp:134
Implementation for the Technosoft iPOS as a single CAN bus joint (control board raw interfaces).
Definition: TechnosoftIpos.hpp:39
bool synchronize(double timestamp) override
Perform synchronized action on CAN master's request.
Definition: TechnosoftIpos.hpp:73
std::vector< unsigned int > getAdditionalIds() override
Retrieve more associated CAN node IDs, if any.
Definition: TechnosoftIpos.hpp:58
bool notifyMessage(const can_message &message) override
Notify observers that a new CAN message has arrived.
Definition: TechnosoftIpos.hpp:61
bool registerSender(ICanSenderDelegate *sender) override
Pass a handle to a CAN sender delegate instance.
Definition: TechnosoftIpos.hpp:70
bool finalize() override
Finalize CAN node communications.
Definition: TechnosoftIpos.hpp:67
unsigned int getId() override
Retrieve CAN node ID.
Definition: TechnosoftIpos.hpp:55
bool initialize() override
Perform CAN node initialization.
Definition: TechnosoftIpos.hpp:64
The main, catch-all namespace for Robotics Lab UC3M.
Definition: groups.dox:6
Proxy CAN message structure.
Definition: CanMessage.hpp:20