icub-test
Loading...
Searching...
No Matches
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
42using namespace robottestingframework;
43
44using namespace yarp::dev;
45using namespace std;
46
47// prepare the plugin
48ROBOTTESTINGFRAMEWORK_PREPARE_PLUGIN(TorqueControlStiffDampCheck)
49
50TorqueControlStiffDampCheck::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
67TorqueControlStiffDampCheck::~TorqueControlStiffDampCheck() { }
68
69bool 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
157void 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
165void 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
175void 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
210void 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
237bool 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
258void 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
275std::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
283void 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.8