icub-test
•All Data Structures Modules Pages
TorqueControlStiffDampCheck.cpp
1 /*
2  * iCub Robot Unit Tests (Robot Testing Framework)
3  *
4  * Copyright (C) 2015-2019 Istituto Italiano di Tecnologia (IIT)
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <math.h>
22 #include <robottestingframework/TestAssert.h>
23 #include <robottestingframework/dll/Plugin.h>
24 #include <yarp/robottestingframework/TestAsserter.h>
25 #include <yarp/os/Time.h>
26 #include <yarp/os/Property.h>
27 #include <yarp/os/LogStream.h>
28 #include <yarp/os/ResourceFinder.h>
29 //#include <iostream>
30 //#include <yarp/manager/localbroker.h>
31 //#include <cstdlib>
32 
33 
34 
35 #include <fstream>
36 #include <algorithm> // std::replace
37 
38 
39 #include "TorqueControlStiffDampCheck.h"
40 
41 
42 using namespace robottestingframework;
43 
44 using namespace yarp::dev;
45 using namespace std;
46 
47 // prepare the plugin
48 ROBOTTESTINGFRAMEWORK_PREPARE_PLUGIN(TorqueControlStiffDampCheck)
49 
50 TorqueControlStiffDampCheck::TorqueControlStiffDampCheck() : yarp::robottestingframework::TestCase("TorqueControlStiffDampCheck") {
51  jointsList=0;
52  dd=0;
53  ipos=0;
54  iamp=0;
55  icmd=0;
56  iimd=0;
57  ienc=0;
58  itrq=0;
59  damping=0;
60  stiffness=0;
61  home=0;
62  n_part_joints=0;
63  n_cmd_joints=0;
64  plot_enabled = false;
65 }
66 
67 TorqueControlStiffDampCheck::~TorqueControlStiffDampCheck() { }
68 
69 bool TorqueControlStiffDampCheck::setup(yarp::os::Property& property) {
70 
71  //updating the test name
72  if(property.check("name"))
73  setName(property.find("name").asString());
74 
75  // updating parameters
76  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("robot"), "The robot name must be given as the test parameter!");
77  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("part"), "The part name must be given as the test parameter!");
78  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("joints"), "The joints list must be given as the test parameter!");
79  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("home"), "The home position list must be given as the test parameter!");
80  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("stiffness"),"The stiffness list must be given as the test parameter!");
81  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("damping"), "The damping listmust be given as the test parameter!");
82  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(property.check("duration"), "The duration must be given as the test parameter!");
83 
84  robotName = property.find("robot").asString();
85  partName = property.find("part").asString();
86 
87 
88 
89  Bottle* jointsBottle = property.find("joints").asList();
90  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(jointsBottle!=0,"unable to parse joints parameter");
91  n_cmd_joints = jointsBottle->size();
92  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(n_cmd_joints>0,"invalid number of joints, it must be >0");
93 
94  Bottle *b_stiff = property.find("stiffness").asList();
95  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(b_stiff!=0,"unable to parse stiffness parameter");
96  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE((b_stiff->size()==n_cmd_joints), Asserter::format("invalid number of stiffness values %d %d", b_stiff->size(), n_cmd_joints));
97 
98  Bottle *b_dump = property.find("damping").asList();
99  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(b_dump!=0,"unable to parse damping parameter");
100  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(b_dump->size()==n_cmd_joints,"invalid number of damping values");
101 
102  Bottle *b_home = property.find("home").asList();
103  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(b_home!=0,"unable to parse home parameter");
104  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(b_home->size()==n_cmd_joints,"invalid number of home values");
105 
106  testLen_sec = property.find("duration").asFloat64();
107  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(testLen_sec>0, "duretion should be bigger than 0");
108 
109  if(property.check("plot_enabled"))
110  {
111  plot_enabled = property.find("plot_enabled").asBool();
112  }
113  if(plot_enabled)
114  yInfo() << "Plot is enabled: the test will run octave and plot test result ";
115  else
116  yInfo() << "Plot is not enabled. The test collects only data. The user need to plot data to theck if test has successed.";
117 
118  Property options;
119  options.put("device", "remote_controlboard");
120  options.put("remote", "/"+robotName+"/"+partName);
121  options.put("local", "/TorqueControlStiffDampCheckTest/"+robotName+"/"+partName);
122 
123  dd = new PolyDriver(options);
124  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->isValid(),"Unable to open device driver");
125  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(itrq),"Unable to open torque control interface");
126  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(ienc),"Unable to open encoders interface");
127  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(iamp),"Unable to open ampliefier interface");
128  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(ipos),"Unable to open position interface");
129  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(icmd),"Unable to open control mode interface");
130  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(iimd),"Unable to open interaction mode interface");
131  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(dd->view(iimp),"Unable to open impedence control interface");
132 
133 
134  if (!ienc->getAxes(&n_part_joints))
135  {
136  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR("unable to get the number of joints of the part");
137  }
138 
139  if(n_part_joints<=0)
140  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR("Error this part has in invalid (<=0) number of jonits");
141 
142 
143 
144  jointsList=new int[n_cmd_joints];
145  stiffness=new double[n_cmd_joints];
146  damping=new double[n_cmd_joints];
147  pos_tot=new double[n_cmd_joints];
148  home=new double[n_cmd_joints];
149 
150  for (int i=0; i <n_cmd_joints; i++) jointsList[i]=jointsBottle->get(i).asInt32();
151  for (int i=0; i <n_cmd_joints; i++) stiffness[i]=b_stiff->get(i).asFloat64();
152  for (int i=0; i <n_cmd_joints; i++) damping[i]=b_dump->get(i).asFloat64();
153  for (int i=0; i <n_cmd_joints; i++) home[i]=b_home->get(i).asFloat64();
154  return true;
155 }
156 
157 void TorqueControlStiffDampCheck::tearDown()
158 {
159  if (jointsList) {delete jointsList; jointsList =0;}
160  if (stiffness) {delete stiffness; stiffness =0;}
161  if (damping) {delete damping; damping =0;}
162  if (dd) {delete dd; dd =0;}
163 }
164 
165 void TorqueControlStiffDampCheck::setMode(int desired_control_mode, yarp::dev::InteractionModeEnum desired_interaction_mode)
166 {
167  for (int i=0; i<n_cmd_joints; i++)
168  {
169  icmd->setControlMode(jointsList[i],desired_control_mode);
170  iimd->setInteractionMode(jointsList[i],desired_interaction_mode);
171  yarp::os::Time::delay(0.010);
172  }
173 }
174 
175 void TorqueControlStiffDampCheck::verifyMode(int desired_control_mode, yarp::dev::InteractionModeEnum desired_interaction_mode, std::string title)
176 {
177  int cmode;
178  yarp::dev::InteractionModeEnum imode;
179  int timeout = 0;
180 
181  while (1)
182  {
183  int ok=0;
184  for (int i=0; i<n_cmd_joints; i++)
185  {
186  icmd->getControlMode (jointsList[i],&cmode);
187  iimd->getInteractionMode(jointsList[i],&imode);
188  if (cmode==desired_control_mode && imode==desired_interaction_mode) ok++;
189  }
190  if (ok==n_cmd_joints) break;
191  if (timeout>100)
192  {
193  char sbuf[800];
194  sprintf(sbuf,"Test (%s) failed: current mode is (%s,%s), it should be (%s,%s)",title.c_str(),
195  Vocab32::decode((NetInt32)desired_control_mode).c_str(),
196  Vocab32::decode((NetInt32)desired_interaction_mode).c_str(),
197  Vocab32::decode((NetInt32)cmode).c_str(),
198  Vocab32::decode((NetInt32)imode).c_str());
199  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR(sbuf);
200  }
201  yarp::os::Time::delay(0.2);
202  timeout++;
203  }
204  char sbuf[500];
205  sprintf(sbuf,"Test (%s) passed: current mode is (%s,%s)",title.c_str(), Vocab32::decode((NetInt32)desired_control_mode).c_str(),
206  Vocab32::decode((NetInt32)desired_interaction_mode).c_str());
207  ROBOTTESTINGFRAMEWORK_TEST_REPORT(sbuf);
208 }
209 
210 void TorqueControlStiffDampCheck::goHome()
211 {
212  for (int i=0; i<n_cmd_joints; i++)
213  {
214  ipos->setRefSpeed(jointsList[i],20.0);
215  ipos->positionMove(jointsList[i],home[i]);
216  }
217 
218  int timeout = 0;
219  while (1)
220  {
221  int in_position=0;
222  for (int i=0; i<n_cmd_joints; i++)
223  {
224  ienc->getEncoder(jointsList[i],&pos_tot[i]);
225  if (fabs(pos_tot[i]-home[i])<0.8) in_position++;
226  }
227  if (in_position==n_cmd_joints) break;
228  if (timeout>100)
229  {
230  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR("Timeout while reaching home[i] position");
231  }
232  yarp::os::Time::delay(0.2);
233  timeout++;
234  }
235 }
236 
237 bool TorqueControlStiffDampCheck::setAndCheckImpedance(int joint, double stiffness, double damping)
238 {
239  iimp->setImpedance(joint, stiffness, damping);
240  yarp::os::Time::delay(0.01);
241  double readStiff, readDump;
242  iimp->getImpedance(joint, &readStiff, &readDump);
243 
244  double th = stiffness/100;
245  bool r1 = yarp::robottestingframework::TestAsserter::isApproxEqual(readStiff, stiffness, th, th);
246  th = damping/100;
247  bool r2 = yarp::robottestingframework::TestAsserter::isApproxEqual(readDump, damping, th, th);
248 
249  if(!r1 || !r2)
250  {
251  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("J %d: set stiff=%f dump=%f. Read stiff=%f dump=%f ",joint, stiffness, damping, readStiff, readDump));
252  return false;
253  }
254 
255  return true;
256 }
257 
258 void TorqueControlStiffDampCheck::saveToFile(std::string filename, yarp::os::Bottle &b)
259 {
260  std::fstream fs;
261  fs.open (filename.c_str(), std::fstream::out);
262 
263  for (int i=0; i<b.size(); i++)
264  {
265  std::string s = b.get(i).toString();
266  std::replace(s.begin(), s.end(), '(', ' ');
267  std::replace(s.begin(), s.end(), ')', ' ');
268  fs << s << endl;
269  }
270 
271  fs.close();
272 }
273 
274 
275 std::string TorqueControlStiffDampCheck::getPath(const std::string& str)
276 {
277  size_t found;
278  found=str.find_last_of("/\\");
279  return(str.substr(0,found));
280 }
281 
282 
283 void TorqueControlStiffDampCheck::run()
284 {
285  setMode(VOCAB_CM_POSITION,VOCAB_IM_STIFF);
286  verifyMode(VOCAB_CM_POSITION,VOCAB_IM_STIFF,"test0");
287 
288  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("try to move joints in home positions"));
289  goHome();
290 
291  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("try to set compliant mode"));
292  setMode(VOCAB_CM_POSITION,VOCAB_IM_COMPLIANT);
293  verifyMode(VOCAB_CM_POSITION,VOCAB_IM_COMPLIANT,"test1");
294 
295  for (int i=0; i<n_cmd_joints; i++)
296  {
297 
298  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("***** Start first part of test on joint %d......", jointsList[i]));
299  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(setAndCheckImpedance(jointsList[i], stiffness[i], 0) , Asserter::format("Error setting impedance on j %d", jointsList[i]));
300 
301 
302 
303  //get initila torque
304  double init_torque;
305  itrq->getTorque(jointsList[i], &init_torque);
306  ROBOTTESTINGFRAMEWORK_TEST_REPORT("Now the user should move the joint....the test will collect values of position and torque. Press a char to continue....");
307  char c;
308  int unused = scanf("%c", &c);
309  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("startingto collact data of joint %d......", jointsList[i]));
310 
311  double start_time = yarp::os::Time::now();
312  double curr_time = start_time;
313  while(curr_time < start_time+testLen_sec)
314  {
315  double curr_pos, torque, reftrq;
316  ienc->getEncoder(jointsList[i], &curr_pos);
317  itrq->getTorque(jointsList[i], &torque);
318  itrq->getRefTorque(jointsList[i], &reftrq);
319 
320  Bottle& row = b_pos_trq.addList();
321  row.addFloat64(curr_pos-home[i]);
322  row.addFloat64(torque- init_torque);
323  row.addFloat64(reftrq);
324  yarp::os::Time::delay(0.01);
325  curr_time = yarp::os::Time::now();
326  }
327 
328  string testfilename = "posVStrq_";
329  Bottle b;
330  b.addInt32(jointsList[i]);
331  string filename1 = testfilename + partName + "_j" + b.toString().c_str() + ".txt";
332  saveToFile(filename1,b_pos_trq);
333  b_pos_trq.clear();
334 
335 
336  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("....DONE on joint %d", jointsList[i]));
337  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("***** Start second part of test on joint %d......", jointsList[i]));
338  ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(setAndCheckImpedance(jointsList[i], 0, damping[i]) , Asserter::format("Error setting impedance on j %d", jointsList[i]));
339 
340  itrq->getTorque(jointsList[i], &init_torque);
341  ROBOTTESTINGFRAMEWORK_TEST_REPORT("Now the user should move the joint....the test will collect values of position and torque. Press a char to continue....");
342 
343  unused = scanf("%c", &c);
344 
345  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("startingto collact data of joint %d......", jointsList[i]));
346 
347  start_time = yarp::os::Time::now();
348  curr_time = start_time;
349  while(curr_time < start_time+testLen_sec)
350  {
351  double curr_vel, torque, reftrq;
352  ienc->getEncoderSpeed(jointsList[i], &curr_vel);
353  itrq->getTorque(jointsList[i], &torque);
354  itrq->getRefTorque(jointsList[i], &reftrq);
355 
356  Bottle& row = b_vel_trq.addList();
357  row.addFloat64(curr_vel);
358  row.addFloat64(torque- init_torque);
359  row.addFloat64(reftrq);
360  yarp::os::Time::delay(0.01);
361  curr_time = yarp::os::Time::now();
362  }
363 
364  testfilename = "velVStrq_";
365  Bottle b1;
366  b1.addInt32(jointsList[i]);
367  filename1 = testfilename + partName + "_j" + b1.toString().c_str() + ".txt";
368  saveToFile(filename1,b_vel_trq);
369  b_vel_trq.clear();
370  ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("....DONE on joint %d", jointsList[i]));
371 
372  }//end for
373 
374  ROBOTTESTINGFRAMEWORK_TEST_REPORT("Test ended. Puts joints in pos stiff and moves them to home pos");
375  setMode(VOCAB_CM_POSITION,VOCAB_IM_STIFF);
376  verifyMode(VOCAB_CM_POSITION,VOCAB_IM_STIFF,"test2");
377 
378  goHome();
379 
380  yarp::os::ResourceFinder rf;
381  rf.setDefaultContext("scripts");
382 
383  //find octave scripts
384  std::string octaveFile = rf.findFile("torqueStiffDamp_plotAll.m");
385  if(octaveFile.size() == 0)
386  {
387  yError()<<"Cannot find file encoderConsistencyPlotAll.m";
388  return;
389  }
390 
391  //prepare octave command
392  std::string octaveCommand= "octave --path "+ getPath(octaveFile);
393 
394  //transform stiffness, damping and jointslist in a vector string for octave
395  stringstream ss_stifness, ss_damping, ss_joints;
396  ss_stifness << "[";
397  ss_damping << "[";
398  ss_joints << "[";
399  for(int j=0; j<n_cmd_joints-1; j++)
400  {
401  ss_stifness << stiffness[j] <<", ";
402  ss_damping << damping[j] <<", ";
403  ss_joints << jointsList[j] <<", ";
404 
405  }
406  ss_stifness << stiffness[n_cmd_joints-1] << "]";
407  ss_damping << damping[n_cmd_joints-1] << "]";
408  ss_joints << jointsList[n_cmd_joints-1] << "]";
409 
410  stringstream ss;
411  ss << n_cmd_joints << ", "<< ss_stifness.str() << ", " << ss_damping.str() << ", " << ss_joints.str();
412  string str = ss.str();
413  octaveCommand+= " -q --eval \"torqueStiffDamp_plotAll('" +partName +"'," + str +")\" --persist";
414 
415  yInfo() << "octave cmd= " << octaveCommand;
416  if(plot_enabled)
417  {
418  int ret = system (octaveCommand.c_str());
419  }
420  else
421  {
422  yInfo() << "Test has collected all data. You need to plot data to check is test is passed";
423  yInfo() << "Please run following command to plot data.";
424  yInfo() << octaveCommand;
425  yInfo() << "To exit from Octave application please type 'exit' command.";
426  }
427 }
428 
429 
430 //void TorqueControlStiffDampCheck::run()
431 //{
434 
436 
439 
440 // for (int i=0; i<n_cmd_joints; i++)
441 // {
442 
443 // ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("***** Start first part of test on joint %d......", jointsList[i]));
444 // //ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(setAndCheckImpedance(jointsList[i], stiffness[i], 0) , Asserter::format("Error setting impedance on j %d", jointsList[i]));
445 
446 // ROBOTTESTINGFRAMEWORK_TEST_REPORT("Now the user should move the joint....the test will collect values of position and torque. Press a char to continue....");
447 // char c;
448 // scanf("%c", &c);
449 
450 // double start_time = yarp::os::Time::now();
451 // double curr_time = start_time;
452 // int x=0;
453 // while(curr_time < start_time+testLen_sec)
454 // {
455 // double curr_pos, torque;
456 // //ienc->getEncoder(jointsList[i], curr_pos);
457 // //itrq->getTorque(jointsList[i], torque);
458 
459 // Bottle& row = b_pos_trq.addList();
460 // //row.addFloat64(curr_pos-home[i], torque);
461 // row.addFloat64(x);
462 // row.addFloat64(10+x);
463 // yarp::os::Time::delay(0.01);
464 // curr_time = yarp::os::Time::now();
465 // x++;
466 // }
467 
468 // string testfilename = "posVStrq_";
469 // Bottle b;
470 // b.addInt32(jointsList[i]);
471 // string filename1 = testfilename + partName + "_j" + b.toString().c_str() + ".txt";
472 // saveToFile(filename1,b_pos_trq);
473 // b_pos_trq.clear();
474 
475 
476 
477 
478 // ROBOTTESTINGFRAMEWORK_TEST_REPORT(Asserter::format("***** Start second part of test on joint %d......", jointsList[i]));
479 // ROBOTTESTINGFRAMEWORK_ASSERT_ERROR_IF_FALSE(setAndCheckImpedance(jointsList[i], 0, damping[i]) , Asserter::format("Error setting impedance on j %d", jointsList[i]));
480 
481 // ROBOTTESTINGFRAMEWORK_TEST_REPORT("Now the user should move the joint....the test will collect values of position and torque. Press a char to continue....");
482 
483 // scanf("%c", &c);
484 // x=1000;
485 // start_time = yarp::os::Time::now();
486 // curr_time = start_time;
487 // while(curr_time < start_time+testLen_sec)
488 // {
489 // double curr_vel, torque;
490 // //ienc->getEncoderSpeed(jointsList[i], curr_vel);
491 // //itrq->getTorque(jointsList[i], torque);
492 
493 // Bottle& row = b_vel_trq.addList();
494 // row.addFloat64(x);
495 // row.addFloat64(x+20);
496 // yarp::os::Time::delay(0.01);
497 // curr_time = yarp::os::Time::now();
498 // x++;
499 // }
500 
501 // testfilename = "velVStrq_";
502 // Bottle b1;
503 // b1.addInt32(jointsList[i]);
504 // filename1 = testfilename + partName + "_j" + b1.toString().c_str() + ".txt";
505 // saveToFile(filename1,b_vel_trq);
506 // b_vel_trq.clear();
507 
508 
509 // }//end for
510 
513 
515 
516 // yarp::os::ResourceFinder rf;
517 // rf.setDefaultContext("scripts");
518 
519 // //find octave scripts
520 // std::string octaveFile = rf.findFile("torqueStiffDamp_plotAll.m");
521 // if(octaveFile.size() == 0)
522 // {
523 // yError()<<"Cannot find file encoderConsistencyPlotAll.m";
524 // return;
525 // }
526 
527 // //prepare octave command
528 // std::string octaveCommand= "octave --path "+ getPath(octaveFile);
529 
530 // //transform stiffness, damping and jointslist in a vector string for octave
531 // stringstream ss_stifness, ss_damping, ss_joints;
532 // ss_stifness << "[";
533 // ss_damping << "[";
534 // ss_joints << "[";
535 // for(int j=0; j<n_cmd_joints-1; j++)
536 // {
537 // ss_stifness << stiffness[j] <<", ";
538 // ss_damping << damping[j] <<", ";
539 // ss_joints << jointsList[j] <<", ";
540 
541 // }
542 // ss_stifness << stiffness[n_cmd_joints-1] << "]";
543 // ss_damping << damping[n_cmd_joints-1] << "]";
544 // ss_joints << jointsList[n_cmd_joints-1] << "]";
545 
546 // stringstream ss;
547 // ss << n_cmd_joints << ", "<< ss_stifness.str() << ", " << ss_damping.str() << ", " << ss_joints.str();
548 // string str = ss.str();
549 // octaveCommand+= " -q --eval \"torqueStiffDamp_plotAll('" +partName +"'," + str +")\" --persist";
550 
551 // yInfo() << "octave cmd= " << octaveCommand;
552 // if(plot_enabled)
553 // {
554 // int ret = system (octaveCommand.c_str());
555 // }
556 // else
557 // {
558 // yInfo() << "Test has collected all data. You need to plot data to check is test is passed";
559 // yInfo() << "Please run following command to plot data.";
560 // yInfo() << octaveCommand;
561 // yInfo() << "To exit from Octave application please type 'exit' command.";
562 // }
563 
564 //}
Generated by doxygen 1.9.1