robot.h
Go to the documentation of this file.
1 /*
2 ROBOOP -- A robotics object oriented package in C++
3 Copyright (C) 1996-2004 Richard Gourdeau
4 
5 This library is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as
7 published by the Free Software Foundation; either version 2.1 of the
8 License, or (at your option) any later version.
9 
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
14 
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 
19 
20 Report problems and direct all questions to:
21 
22 Richard Gourdeau
23 Professeur Agrege
24 Departement de genie electrique
25 Ecole Polytechnique de Montreal
26 C.P. 6079, Succ. Centre-Ville
27 Montreal, Quebec, H3C 3A7
28 
29 email: richard.gourdeau@polymtl.ca
30 -------------------------------------------------------------------------------
31 Revision_history:
32 
33 2003/02/03: Etienne Lachance
34  -Removed class mlink. DH and modified DH parameters are now included in link.
35  -Created virtual class Robot_basic which is now the base class of Robot and
36  mRobot.
37  -Removed classes RobotMotor and mRobotMotor. Motors effect are now included
38  in classes Robot and mRobot. Code using the old motor class whould need to
39  be change by changing RobotMotor by Robot and mRobotMotor by mRobot.
40  -Added classes mRobot_min_para (modified DH parameters) and IO_matrix_file.
41  -Created a new torque member function that allowed to have load on last link
42  (Robot_basic, Robot, mRobot, mRobot_min_para).
43  -Added the following member functions in class Robot_basic:
44  void kine_pd(Matrix & Rot, ColumnVector & pos, ColumnVector & posdot)const;
45  void kine_pd(Matrix & Rot, ColumnVector & pos, ColumnVector & posdot, int j)const;
46  ReturnMatrix kine_pd(void)const;
47  ReturnMatrix kine_pd(int j)const;
48  These functions are like the kine(), but with speed calculation.
49  -Added labels theta_min and theta_max in class Link.
50 
51 2003/04/29: Etienne Lachance
52  -All gnugrah.cpp definitions are now in gnugraph.h.
53  -The following ColumnVector are now part of class Robot_basic: *dw, *dwp, *dvp, *da,
54  *df, *dn, *dF, *dN, *dp.
55  -Added functons Robot_basic::jacobian_DLS_inv.
56  -Added z0 in Robot_basic.
57  -Fix kine_pd function.
58 
59 2003/08/22: Etienne Lachance
60  -Added parameter converge in member function inv_kin.
61 
62 2004/01/23: Etienne Lachance
63  -Added member function G() (gravity torque), and H() (corriolis torque)
64  on all robot class.
65  -Commun definitions are now in include file utils.h.
66  -Added const in non reference argument for all functions prototypes.
67 
68 2004/03/01: Etienne Lachance
69  -Added non member function perturb_robot.
70 
71 2004/03/21: Etienne Lachance
72  -Added the following member functions: get_theta_min, get_theta_max,
73  get_mc, get_r, get_p, get_m, get_Im, get_Gr, get_B, get_Cf, get_I,
74  set_m, set_mc, set_r, set_Im, set_B, set_Cf, set_I.
75 
76 2004/04/26: Etienne Lachance and Vincent Drolet
77  -Added member functions inv_kin_rhino and inv_kin_puma.
78 
79 2004/05/21: Etienne Lachance
80  -Added Doxygen comments.
81 
82 2004/07/01: Ethan Tira-Thompson
83  -Added support for newmat's use_namespace #define, using ROBOOP namespace
84 
85 2004/07/02: Etienne Lachance
86  -Added joint_offset variable in class Link and Link member functions
87  get_joint_offset. Idea proposed by Ethan Tira-Thompson.
88 
89 2004/07/16: Ethan Tira-Thompson
90  -Added Link::immobile flag and accessor functions
91  -Added get_available_q* functions
92  -inv_kin functions are now all virtual
93  -Added parameters to jacobian and inv_kin functions to work with frames
94  other than the end effector
95 
96 2004/10/02: Etienne Lachance
97  -Added Schlling for analytic inverse kinematic.
98 
99 2005/11/06: Etienne Lachance
100  - No need to provide a copy constructor and the assignment operator
101  (operator=) for Link class. Instead we use the one provide by the
102  compiler.
103  -No need to provide an assignment operator for Robot, mRobot and
104  mRobot_min_para classes.
105 -------------------------------------------------------------------------------
106 */
107 
108 #ifndef __cplusplus
109 #error Must use C++ for the type Robot
110 #endif
111 #ifndef ROBOT_H
112 #define ROBOT_H
113 
119 static const char header_rcsid[] = "$Id: robot.h,v 1.52 2006/05/16 16:11:15 gourdeau Exp $";
121 
122 #include "utils.h"
123 
124 #ifdef use_namespace
125 namespace ROBOOP {
126  using namespace NEWMAT;
127 #endif
128 
129 
137 class Link
138 {
139  friend class Robot_basic;
140  friend class Robot;
141  friend class mRobot;
142  friend class mRobot_min_para;
143 
144 public:
145  Link(const int jt = 0, const Real it = 0.0, const Real id = 0.0,
146  const Real ia = 0.0, const Real ial = 0.0, const Real theta_min = -M_PI/2,
147  const Real theta_max = M_PI/2, const Real it_off = 0.0, const Real mass = 1.0,
148  const Real cmx = 0.0, const Real cmy = 0.0, const Real cmz = 0.0,
149  const Real ixx = 0.0, const Real ixy = 0.0, const Real ixz = 0.0,
150  const Real iyy = 0.0, const Real iyz = 0.0, const Real izz = 0.0,
151  const Real iIm = 0.0, const Real iGr = 0.0, const Real iB = 0.0,
152  const Real iCf = 0.0, const bool dh = true, const bool min_inertial_para = false,
153  const bool immobile = false);
154  ~Link(){}
155  void transform(const Real q);
156  bool get_DH(void) const {return DH; }
157  int get_joint_type(void) const { return joint_type; }
158  Real get_theta(void) const { return theta; }
159  Real get_d(void) const { return d; }
160  Real get_a(void) const { return a; }
161  Real get_alpha(void) const { return alpha; }
162  Real get_q(void) const;
163  Real get_theta_min(void) const { return theta_min; }
164  Real get_theta_max(void) const { return theta_max; }
165  Real get_joint_offset(void) const { return joint_offset; }
166  ReturnMatrix get_mc(void) { return mc; }
167  ReturnMatrix get_r(void) { return r; }
168  ReturnMatrix get_p(void) const { return p; }
169  Real get_m(void) const { return m; }
170  Real get_Im(void) const { return Im; }
171  Real get_Gr(void) const { return Gr; }
172  Real get_B(void) const { return B; }
173  Real get_Cf(void) const { return Cf; }
174  ReturnMatrix get_I(void) const { return I; }
175  bool get_immobile(void) const { return immobile; }
176  void set_m(const Real m_) { m = m_; }
177  void set_mc(const ColumnVector & mc_);
178  void set_r(const ColumnVector & r_);
179  void set_Im(const Real Im_) { Im = Im_; }
180  void set_B(const Real B_) { B = B_; }
181  void set_Cf(const Real Cf_) { Cf = Cf_; }
182  void set_I(const Matrix & I);
183  void set_immobile(bool im) { immobile=im; }
184 
185  Matrix R;
186  Real qp,
187  qpp;
188 
189 private:
190  int joint_type;
191  Real theta,
192  d,
193  a,
194  alpha,
195  theta_min,
196  theta_max,
197  joint_offset;
198  bool DH,
199  min_para;
200  ColumnVector r,
201  p;
202  Real m,
203  Im,
204  Gr,
205  B,
206  Cf;
207  ColumnVector mc;
208  Matrix I;
209  bool immobile;
210 };
211 
216 class Robot_basic {
217  friend class Robot;
218  friend class mRobot;
219  friend class mRobot_min_para;
220  friend class Robotgl;
221  friend class mRobotgl;
222 public:
223  Robot_basic(const int ndof = 1, const bool dh_parameter = false,
224  const bool min_inertial_para = false);
225  Robot_basic(const Matrix & initrobot_motor, const bool dh_parameter = false,
226  const bool min_inertial_para = false);
227  Robot_basic(const Matrix & initrobot, const Matrix & initmotor,
228  const bool dh_parameter = false, const bool min_inertial_para = false);
229  Robot_basic(const std::string & filename, const std::string & robotName,
230  const bool dh_parameter = false, const bool min_inertial_para = false);
231  Robot_basic(const Robot_basic & x);
232  virtual ~Robot_basic();
233  Robot_basic & operator=(const Robot_basic & x);
234 
235  Real get_q(const int i) const {
236  if(i < 1 || i > dof) error("i must be 1 <= i <= dof");
237  return links[i].get_q();
238  }
239  bool get_DH()const { return links[1].DH; }
240  int get_dof()const { return dof; }
241  int get_available_dof()const { return get_available_dof(dof); }
242  int get_available_dof(const int endlink)const;
243  int get_fix()const { return fix; }
244  ReturnMatrix get_q(void)const;
245  ReturnMatrix get_qp(void)const;
246  ReturnMatrix get_qpp(void)const;
247  ReturnMatrix get_available_q(void)const { return get_available_q(dof); }
248  ReturnMatrix get_available_qp(void)const { return get_available_qp(dof); }
249  ReturnMatrix get_available_qpp(void)const { return get_available_qpp(dof); }
250  ReturnMatrix get_available_q(const int endlink)const;
251  ReturnMatrix get_available_qp(const int endlink)const;
252  ReturnMatrix get_available_qpp(const int endlink)const;
253  void set_q(const ColumnVector & q);
254  void set_q(const Matrix & q);
255  void set_q(const Real q, const int i) {
256  if(i < 1 || i > dof) error("i must be 1 <= i <= dof");
257  links[i].transform(q);
258  }
259  void set_qp(const ColumnVector & qp);
260  void set_qpp(const ColumnVector & qpp);
261  void kine(Matrix & Rot, ColumnVector & pos)const;
262  void kine(Matrix & Rot, ColumnVector & pos, const int j)const;
263  ReturnMatrix kine(void)const;
264  ReturnMatrix kine(const int j)const;
265  ReturnMatrix kine_pd(const int ref=0)const;
266  virtual void kine_pd(Matrix & Rot, ColumnVector & pos,
267  ColumnVector & pos_dot, const int ref)const=0;
268  virtual void robotType_inv_kin() = 0;
269  virtual ReturnMatrix inv_kin(const Matrix & Tobj, const int mj = 0);
271  ReturnMatrix inv_kin(const Matrix & Tobj, const int mj,
272  bool & converge) {return inv_kin(Tobj,mj,dof,converge);}
273  virtual ReturnMatrix inv_kin(const Matrix & Tobj, const int mj, const int endlink, bool & converge);
274  virtual ReturnMatrix inv_kin_rhino(const Matrix & Tobj, bool & converge) = 0;
275  virtual ReturnMatrix inv_kin_puma(const Matrix & Tobj, bool & converge) = 0;
276  virtual ReturnMatrix inv_kin_schilling(const Matrix & Tobj, bool & converge) = 0;
277  virtual ReturnMatrix jacobian(const int ref=0)const { return jacobian(dof,ref); }
278  virtual ReturnMatrix jacobian(const int endlink, const int ref)const = 0;
279  virtual ReturnMatrix jacobian_dot(const int ref=0)const = 0;
280  ReturnMatrix jacobian_DLS_inv(const double eps, const double lambda_max, const int ref=0)const;
281  virtual void dTdqi(Matrix & dRot, ColumnVector & dp, const int i) = 0;
282  virtual ReturnMatrix dTdqi(const int i) = 0;
283  ReturnMatrix acceleration(const ColumnVector & q, const ColumnVector & qp,
284  const ColumnVector & tau);
285  ReturnMatrix acceleration(const ColumnVector & q, const ColumnVector & qp,
286  const ColumnVector & tau, const ColumnVector & Fext,
287  const ColumnVector & Next);
288  ReturnMatrix inertia(const ColumnVector & q);
289  virtual ReturnMatrix torque_novelocity(const ColumnVector & qpp) = 0;
290  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
291  const ColumnVector & qpp) = 0;
292  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
293  const ColumnVector & qpp,
294  const ColumnVector & Fext_,
295  const ColumnVector & Next_) = 0;
296  virtual void delta_torque(const ColumnVector & q, const ColumnVector & qp,
297  const ColumnVector & qpp, const ColumnVector & dq,
298  const ColumnVector & dqp, const ColumnVector & dqpp,
299  ColumnVector & torque, ColumnVector & dtorque) =0;
300  virtual void dq_torque(const ColumnVector & q, const ColumnVector & qp,
301  const ColumnVector & qpp, const ColumnVector & dq,
302  ColumnVector & torque, ColumnVector & dtorque) =0;
303  virtual void dqp_torque(const ColumnVector & q, const ColumnVector & qp,
304  const ColumnVector & dqp, ColumnVector & torque,
305  ColumnVector & dtorque) =0;
306  ReturnMatrix dtau_dq(const ColumnVector & q, const ColumnVector & qp,
307  const ColumnVector & qpp);
308  ReturnMatrix dtau_dqp(const ColumnVector & q, const ColumnVector & qp);
309  virtual ReturnMatrix G() = 0;
310  virtual ReturnMatrix C(const ColumnVector & qp) = 0;
311  void error(const std::string & msg1) const;
312 
313  ColumnVector *w, *wp, *vp, *a, *f, *f_nv, *n, *n_nv, *F, *N, *p, *pp,
314  *dw, *dwp, *dvp, *da, *df, *dn, *dF, *dN, *dp,
315  z0,
316  gravity;
317  Matrix *R;
318  Link *links;
319 
320 private:
321  void cleanUpPointers();
322 
324  enum EnumRobotType
325  {
326  DEFAULT = 0,
327  RHINO = 1,
328  PUMA = 2,
329  SCHILLING = 3
330  };
331  EnumRobotType robotType;
332  int dof,
333  fix;
334 };
335 
340 class Robot : public Robot_basic
341 {
342 public:
343  Robot(const int ndof=1);
344  Robot(const Matrix & initrobot);
345  Robot(const Matrix & initrobot, const Matrix & initmotor);
346  Robot(const Robot & x);
347  Robot(const std::string & filename, const std::string & robotName);
348  virtual ~Robot(){}
349  virtual void robotType_inv_kin();
350  virtual void kine_pd(Matrix & Rot, ColumnVector & pos,
351  ColumnVector & pos_dot, const int ref)const;
352  ReturnMatrix inv_kin(const Matrix & Tobj, const int mj = 0);
353  virtual ReturnMatrix inv_kin(const Matrix & Tobj, const int mj, const int endlink, bool & converge);
354  virtual ReturnMatrix inv_kin_rhino(const Matrix & Tobj, bool & converge);
355  virtual ReturnMatrix inv_kin_puma(const Matrix & Tobj, bool & converge);
356  virtual ReturnMatrix inv_kin_schilling(const Matrix & Tobj, bool & converge);
357  virtual ReturnMatrix jacobian(const int ref=0)const { return jacobian(dof,ref); }
358  virtual ReturnMatrix jacobian(const int endlink, const int ref)const;
359  virtual ReturnMatrix jacobian_dot(const int ref=0)const;
360  virtual void dTdqi(Matrix & dRot, ColumnVector & dp, const int i);
361  virtual ReturnMatrix dTdqi(const int i);
362  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
363  const ColumnVector & qpp);
364  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
365  const ColumnVector & qpp,
366  const ColumnVector & Fext_,
367  const ColumnVector & Next_);
368  virtual ReturnMatrix torque_novelocity(const ColumnVector & qpp);
369  virtual void delta_torque(const ColumnVector & q, const ColumnVector & qp,
370  const ColumnVector & qpp, const ColumnVector & dq,
371  const ColumnVector & dqp, const ColumnVector & dqpp,
372  ColumnVector & ltorque, ColumnVector & dtorque);
373  virtual void dq_torque(const ColumnVector & q, const ColumnVector & qp,
374  const ColumnVector & qpp, const ColumnVector & dq,
375  ColumnVector & torque, ColumnVector & dtorque);
376  virtual void dqp_torque(const ColumnVector & q, const ColumnVector & qp,
377  const ColumnVector & dqp, ColumnVector & torque,
378  ColumnVector & dtorque);
379  virtual ReturnMatrix G();
380  virtual ReturnMatrix C(const ColumnVector & qp);
381 };
382 
383 // ---------- R O B O T M O D I F I E D DH N O T A T I O N --------------
384 
389 class mRobot : public Robot_basic {
390 public:
391  mRobot(const int ndof=1);
392  mRobot(const Matrix & initrobot_motor);
393  mRobot(const Matrix & initrobot, const Matrix & initmotor);
394  mRobot(const mRobot & x);
395  mRobot(const std::string & filename, const std::string & robotName);
396  virtual ~mRobot(){}
397  virtual void robotType_inv_kin();
398  ReturnMatrix inv_kin(const Matrix & Tobj, const int mj = 0);
399  virtual ReturnMatrix inv_kin(const Matrix & Tobj, const int mj, const int endlink, bool & converge);
400  virtual ReturnMatrix inv_kin_rhino(const Matrix & Tobj, bool & converge);
401  virtual ReturnMatrix inv_kin_puma(const Matrix & Tobj, bool & converge);
402  virtual ReturnMatrix inv_kin_schilling(const Matrix & Tobj, bool & converge);
403  virtual void kine_pd(Matrix & Rot, ColumnVector & pos,
404  ColumnVector & pos_dot, const int ref)const;
405  virtual ReturnMatrix jacobian(const int ref=0)const { return jacobian(dof,ref); }
406  virtual ReturnMatrix jacobian(const int endlink, const int ref)const;
407  virtual ReturnMatrix jacobian_dot(const int ref=0)const;
408  virtual void dTdqi(Matrix & dRot, ColumnVector & dp, const int i);
409  virtual ReturnMatrix dTdqi(const int i);
410  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
411  const ColumnVector & qpp);
412  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
413  const ColumnVector & qpp,
414  const ColumnVector & Fext_,
415  const ColumnVector & Next_);
416  virtual ReturnMatrix torque_novelocity(const ColumnVector & qpp);
417  virtual void delta_torque(const ColumnVector & q, const ColumnVector & qp,
418  const ColumnVector & qpp, const ColumnVector & dq,
419  const ColumnVector & dqp, const ColumnVector & dqpp,
420  ColumnVector & torque, ColumnVector & dtorque);
421  virtual void dq_torque(const ColumnVector & q, const ColumnVector & qp,
422  const ColumnVector & qpp, const ColumnVector & dq,
423  ColumnVector & torque, ColumnVector & dtorque);
424  virtual void dqp_torque(const ColumnVector & q, const ColumnVector & qp,
425  const ColumnVector & dqp, ColumnVector & torque,
426  ColumnVector & dtorque);
427  virtual ReturnMatrix G();
428  virtual ReturnMatrix C(const ColumnVector & qp);
429 };
430 
431 // --- R O B O T DH M O D I F I E D, M I N I M U M P A R A M E T E R S ---
432 
437 class mRobot_min_para : public Robot_basic
438 {
439 public:
440  mRobot_min_para(const int ndof=1);
441  mRobot_min_para(const Matrix & dhinit);
442  mRobot_min_para(const Matrix & initrobot, const Matrix & initmotor);
443  mRobot_min_para(const mRobot_min_para & x);
444  mRobot_min_para(const std::string & filename, const std::string & robotName);
445  virtual ~mRobot_min_para(){}
446  virtual void robotType_inv_kin();
447  ReturnMatrix inv_kin(const Matrix & Tobj, const int mj = 0);
448  virtual ReturnMatrix inv_kin(const Matrix & Tobj, const int mj, const int endlink, bool & converge);
449  virtual ReturnMatrix inv_kin_rhino(const Matrix & Tobj, bool & converge);
450  virtual ReturnMatrix inv_kin_puma(const Matrix & Tobj, bool & converge);
451  virtual ReturnMatrix inv_kin_schilling(const Matrix & Tobj, bool & converge);
452  virtual void kine_pd(Matrix & Rot, ColumnVector & pos,
453  ColumnVector & pos_dot, const int ref=0)const;
454  virtual ReturnMatrix jacobian(const int ref=0)const { return jacobian(dof,ref); }
455  virtual ReturnMatrix jacobian(const int endlink, const int ref)const;
456  virtual ReturnMatrix jacobian_dot(const int ref=0)const;
457  virtual void dTdqi(Matrix & dRot, ColumnVector & dp, const int i);
458  virtual ReturnMatrix dTdqi(const int i);
459  virtual ReturnMatrix torque(const ColumnVector & q, const ColumnVector & qp,
460  const ColumnVector & qpp);
461  virtual ReturnMatrix torque(const ColumnVector & q,
462  const ColumnVector & qp,
463  const ColumnVector & qpp,
464  const ColumnVector & Fext_,
465  const ColumnVector & Next_);
466  virtual ReturnMatrix torque_novelocity(const ColumnVector & qpp);
467  virtual void delta_torque(const ColumnVector & q, const ColumnVector & qp,
468  const ColumnVector & qpp, const ColumnVector & dq,
469  const ColumnVector & dqp, const ColumnVector & dqpp,
470  ColumnVector & torque, ColumnVector & dtorque);
471  virtual void dq_torque(const ColumnVector & q, const ColumnVector & qp,
472  const ColumnVector & qpp, const ColumnVector & dq,
473  ColumnVector & torque, ColumnVector & dtorque);
474  virtual void dqp_torque(const ColumnVector & q, const ColumnVector & qp,
475  const ColumnVector & dqp, ColumnVector & torque,
476  ColumnVector & dtorque);
477  virtual ReturnMatrix G();
478  virtual ReturnMatrix C(const ColumnVector & qp);
479 };
480 
481 void perturb_robot(Robot_basic & robot, const double f = 0.1);
482 
483 bool Rhino_DH(const Robot_basic & robot);
484 bool Puma_DH(const Robot_basic & robot);
485 bool Schilling_DH(const Robot_basic & robot);
486 
487 bool Rhino_mDH(const Robot_basic & robot);
488 bool Puma_mDH(const Robot_basic & robot);
489 bool Schilling_mDH(const Robot_basic & robot);
490 
491 #ifdef use_namespace
492 }
493 #endif
494 
495 #endif
496 
Robot_basic::jacobian
virtual ReturnMatrix jacobian(const int ref=0) const
Jacobian of mobile links expressed at frame ref.
Definition: robot.h:277
acceleration
int acceleration
Definition: wrapper_control_demo.cpp:40
kni_demo.m
m
Definition: kni_demo.py:33
mRobot_min_para::~mRobot_min_para
virtual ~mRobot_min_para()
Destructor.
Definition: robot.h:445
mRobot_min_para::jacobian
virtual ReturnMatrix jacobian(const int ref=0) const
Jacobian of mobile links expressed at frame ref.
Definition: robot.h:454
Robot_basic::get_DH
bool get_DH() const
Return true if in DH notation, false otherwise.
Definition: robot.h:239
mRobot::~mRobot
virtual ~mRobot()
Destructor.
Definition: robot.h:396
Robot_basic::fix
int fix
Virtual link, used with modified DH notation.
Definition: robot.h:332
Robot_basic::get_dof
int get_dof() const
Return dof.
Definition: robot.h:240
Robot
DH notation robot class.
Definition: robot.h:340
Robot_basic::links
Link * links
Pointer on Link cclass.
Definition: robot.h:318
Puma_DH
bool Puma_DH(const Robot_basic &robot)
Return true if the robot is like a Puma on DH notation.
Definition: robot.cpp:1516
Robot_basic::get_available_qpp
ReturnMatrix get_available_qpp(void) const
Return the joint acceleration vector of available (non-immobile) joints.
Definition: robot.h:249
Rhino_mDH
bool Rhino_mDH(const Robot_basic &robot)
Return true if the robot is like a Rhino on modified DH notation.
Definition: robot.cpp:1583
Robot_basic::set_q
void set_q(const Real q, const int i)
Definition: robot.h:255
Real
double Real
Definition: include.h:307
Schilling_mDH
bool Schilling_mDH(const Robot_basic &robot)
Return true if the robot is like a Schilling on modified DH notation.
Definition: robot.cpp:1649
header_rcsid
static const char header_rcsid[]
RCS/CVS version.
Definition: robot.h:120
Robot_basic::get_q
ReturnMatrix get_q(void) const
Return the joint position vector.
Definition: robot.cpp:1004
Robot_basic::robotType
EnumRobotType robotType
Robot type.
Definition: robot.h:331
Robot_basic::get_available_dof
int get_available_dof() const
Counts number of currently non-immobile links.
Definition: robot.h:241
utils.h
Utility header file.
Robot_basic::p
ColumnVector * p
Definition: robot.h:313
d
FloatVector * d
Definition: include/libKinematics.h:78
Robot_basic
Virtual base robot class.
Definition: robot.h:216
mRobot
Modified DH notation robot class.
Definition: robot.h:389
Puma_mDH
bool Puma_mDH(const Robot_basic &robot)
Return true if the robot is like a Puma on modified DH notation.
Definition: robot.cpp:1615
Robot_basic::get_fix
int get_fix() const
Return fix.
Definition: robot.h:243
Matrix
The usual rectangular matrix.
Definition: newmat.h:625
Robot_basic::get_available_q
ReturnMatrix get_available_q(void) const
Return the joint position vector of available (non-immobile) joints.
Definition: robot.h:247
a
FloatVector FloatVector * a
Definition: include/libKinematics.h:78
mRobot_min_para
Modified DH notation and minimal inertial parameters robot class.
Definition: robot.h:437
mRobot::jacobian
virtual ReturnMatrix jacobian(const int ref=0) const
Jacobian of mobile links expressed at frame ref.
Definition: robot.h:405
Robot_basic::get_available_qp
ReturnMatrix get_available_qp(void) const
Return the joint velocity vector of available (non-immobile) joints.
Definition: robot.h:248
Rhino_DH
bool Rhino_DH(const Robot_basic &robot)
Return true if the robot is like a Rhino on DH notation.
Definition: robot.cpp:1483
alpha
FloatVector FloatVector FloatVector * alpha
Definition: include/libKinematics.h:78
perturb_robot
void perturb_robot(Robot_basic &robot, const double f=0.1)
Modify a robot.
Definition: robot.cpp:1446
ColumnVector
Column vector.
Definition: newmat.h:1008
Schilling_DH
bool Schilling_DH(const Robot_basic &robot)
Return true if the robot is like a Schilling on DH notation.
Definition: robot.cpp:1549
Robot_basic::R
Matrix * R
Temprary rotation matrix.
Definition: robot.h:317
Robot::~Robot
virtual ~Robot()
Destructor.
Definition: robot.h:348
Robot_basic::inv_kin
ReturnMatrix inv_kin(const Matrix &Tobj, const int mj, bool &converge)
Definition: robot.h:271
Robot::jacobian
virtual ReturnMatrix jacobian(const int ref=0) const
Jacobian of mobile links expressed at frame ref.
Definition: robot.h:357
Robot_basic::z0
ColumnVector z0
Axis vector at each joint.
Definition: robot.h:313
Robot_basic::get_q
Real get_q(const int i) const
Definition: robot.h:235
Robot_basic::EnumRobotType
EnumRobotType
enum EnumRobotType
Definition: robot.h:324
robot
Robot robot
Definition: demo.cpp:227

kni
Author(s): Martin Günther
autogenerated on Fri Jan 3 2020 04:01:16