HandUnitGuiPlugin.cpp
Go to the documentation of this file.
1#include "HandUnitGuiPlugin.h"
2
3#include <RobotAPI/gui-plugins/HandUnitPlugin/ui_HandUnitGuiPlugin.h>
4
5#include <math.h>
6
7#include <string>
8
9#include <QLabel>
10#include <QLineEdit>
11#include <QMessageBox>
12#include <QPushButton>
13#include <QString>
14#include <QTimer>
15#include <Qt>
16#include <QtGlobal>
17#include <QtWidgets/QSlider>
18#include <QtWidgets/QTableWidgetItem>
19
20#include <Ice/Current.h>
21
22#include <ArmarXCore/core/logging/Logging.h>
23#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
24#include <ArmarXCore/core/system/ArmarXDataPath.h>
25#include <ArmarXCore/observers/variant/SingleTypeVariantList.h>
26
27#include <RobotAPI/gui-plugins/HandUnitPlugin/ui_HandUnitConfigDialog.h>
28#include <RobotAPI/interface/core/NameValueMap.h>
29#include <RobotAPI/interface/units/HandUnitInterface.h>
30
31#include "HandUnitConfigDialog.h"
32
33namespace armarx
34{
39
40 HandUnitWidget::~HandUnitWidget() = default;
41
42 HandUnitWidget::HandUnitWidget() :
43 leftHandName("NOT SET YET"),
44 rightHandName("NOT SET YET"),
45 leftHandUnitProxyName(""),
46 rightHandUnitProxyName(""),
47 setLeftHandJointAnglesFlag(false),
48 setRightHandJointAnglesFlag(false)
49 {
50 // init gui
51 ARMARX_INFO << "Setup UI";
52 ui = std::make_unique<Ui::HandUnitGuiPlugin>();
53 ui->setupUi(getWidget());
54
55 ARMARX_INFO << "Done: Setup UI";
56
57 setLeftHandJointAngleUpdateTask =
58 new PeriodicTask<HandUnitWidget>(this, &HandUnitWidget::setLeftHandJointAngles, 50);
59 setRightHandJointAngleUpdateTask =
60 new PeriodicTask<HandUnitWidget>(this, &HandUnitWidget::setRightHandJointAngles, 50);
61 updateInfoTimer = new QTimer(this);
62 }
63
64 void
65 HandUnitWidget::onInitComponent()
66 {
67 usingProxy(leftHandUnitProxyName);
68 usingProxy(rightHandUnitProxyName);
69 //usingTopic(handName + "State");
70 //ARMARX_WARNING << "Listening on Topic: " << handName + "State";
71 }
72
73 void
74 HandUnitWidget::onConnectComponent()
75 {
76 updateInfoTimer->start(50);
77
78
79 setLeftHandJointAngleUpdateTask->start();
80
81 leftHandUnitProxy = getProxy<HandUnitInterfacePrx>(leftHandUnitProxyName);
82 leftHandName = leftHandUnitProxy->getHandName();
83
84 if (leftHandName == "Hand L" || leftHandName == "TCP L")
85 {
86 leftHandConversionFactor *= M_PI / 2;
87 }
88 else if (leftHandName != "Hand_L_EEF")
89 {
90 ARMARX_WARNING << "Left hand with name \"" << leftHandName << "\" is not supported.";
91 }
92
93 SingleTypeVariantListPtr leftHandPreshapeStrings =
94 SingleTypeVariantListPtr::dynamicCast(leftHandUnitProxy->getShapeNames());
95 QStringList leftHandList;
96 int leftHandPreshapeCount = leftHandPreshapeStrings->getSize();
97
98 for (int i = 0; i < leftHandPreshapeCount; ++i)
99 {
100 std::string shape = ((leftHandPreshapeStrings->getVariant(i))->get<std::string>());
101 // ARMARX_INFO << VAROUT(shape);
102 leftHandList << QString::fromStdString(shape);
103 }
104
105 ui->comboLeftHandPreshapes->clear();
106 ui->comboLeftHandPreshapes->addItems(leftHandList);
107
108 setRightHandJointAngleUpdateTask->start();
109
110 rightHandUnitProxy = getProxy<HandUnitInterfacePrx>(rightHandUnitProxyName);
111 rightHandName = rightHandUnitProxy->getHandName();
112
113 if (rightHandName == "Hand R" || rightHandName == "TCP R")
114 {
115 rightHandConversionFactor *= M_PI / 2;
116 }
117 else if (rightHandName != "Hand_R_EEF")
118 {
119 ARMARX_WARNING << "Right hand with name \"" << rightHandName << "\" is not supported.";
120 }
121
122 SingleTypeVariantListPtr rightHandPreshapeStrings =
123 SingleTypeVariantListPtr::dynamicCast(rightHandUnitProxy->getShapeNames());
124 QStringList rightHandList;
125 int rightHandPreshapeCount = rightHandPreshapeStrings->getSize();
126
127 for (int i = 0; i < rightHandPreshapeCount; ++i)
128 {
129 std::string shape = ((rightHandPreshapeStrings->getVariant(i))->get<std::string>());
130 // ARMARX_INFO << VAROUT(shape);
131 rightHandList << QString::fromStdString(shape);
132 }
133
134 ui->comboRightHandPreshapes->clear();
135 ui->comboRightHandPreshapes->addItems(rightHandList);
136
137 // ARMARX_INFO << "initGUIJointFrames";
138 initGUIJointFrames();
139 displayJointAngleUpdateTask =
140 new PeriodicTask<HandUnitWidget>(this, &HandUnitWidget::updateJointValueTable, 50);
141 displayJointAngleUpdateTask->start();
142
143 updateInfoLabel();
144 }
145
146 void
147 HandUnitWidget::onDisconnectComponent()
148 {
149 setLeftHandJointAngleUpdateTask->stop();
150 setRightHandJointAngleUpdateTask->stop();
151 displayJointAngleUpdateTask->stop();
152 updateInfoTimer->stop();
153 }
154
155 void
160
161 QPointer<QDialog>
162 HandUnitWidget::getConfigDialog(QWidget* parent)
163 {
164 if (!dialog)
165 {
166 dialog = new HandUnitConfigDialog(parent);
167 //dialog->ui->editHandUnitName->setText(QString::fromStdString(handUnitProxyName));
168 //dialog->ui->editHandName->setText(QString::fromStdString(handName));
169 }
170
171 return qobject_cast<HandUnitConfigDialog*>(dialog);
172 }
173
174 void
175 HandUnitWidget::configured()
176 {
177 leftHandUnitProxyName = dialog->proxyFinderLeftHand->getSelectedProxyName().toStdString();
178 rightHandUnitProxyName = dialog->proxyFinderRightHand->getSelectedProxyName().toStdString();
179 }
180
181 void
182 HandUnitWidget::preshapeLeftHand()
183 {
184 setLeftHandPreshape(ui->comboLeftHandPreshapes->currentText().toUtf8().data());
185 }
186
187 void
188 HandUnitWidget::preshapeRightHand()
189 {
190 setRightHandPreshape(ui->comboRightHandPreshapes->currentText().toUtf8().data());
191 }
192
193 void
194 HandUnitWidget::reloadPreshapes()
195 {
196 ARMARX_INFO << "Reloading preshapes in robot unit ...";
197
198 // left hand unit
199 {
200 if (leftHandUnitProxy)
201 {
202 ARMARX_INFO << "Left hand unit: reloading preshapes.";
203 leftHandUnitProxy->reloadPreshapes();
204 }
205 }
206
207 // right hand unit
208 {
209 if (rightHandUnitProxy)
210 {
211 ARMARX_INFO << "Right hand unit: reloading preshapes.";
212 rightHandUnitProxy->reloadPreshapes();
213 }
214 }
215 }
216
217 void
218 HandUnitWidget::setLeftHandJointAngles()
219 {
220 // ARMARX_INFO << "setLeftHandJointAngles";
221 if (!leftHandUnitProxy)
222 {
223 ARMARX_WARNING << "invalid proxy";
224 return;
225 }
226
227 if (!setLeftHandJointAnglesFlag)
228 {
229 return;
230 }
231
232 setLeftHandJointAnglesFlag = false;
233
234 NameValueMap leftHandJa;
235 NameValueMap currentLeftHandJointValues = leftHandUnitProxy->getCurrentJointValues();
236 float value = 0;
237 if (leftHandName == "Hand L" || leftHandName == "TCP L")
238 {
239 leftHandConversionFactor *= M_PI / 2;
240 }
241 else if (leftHandName != "Hand_L_EEF")
242 {
243 ARMARX_WARNING << "Left hand with name \"" << leftHandName << "\" is not supported.";
244 return;
245 }
246
247 for (const auto& pair : currentLeftHandJointValues)
248 {
249 if (pair.first == currentLeftHandJoint)
250 {
251 value = static_cast<float>(ui->horizontalSliderLeftHandJointPos->value() *
252 leftHandConversionFactor);
253 // ARMARX_INFO << VAROUT(value);
254 leftHandJa[pair.first] = value;
255 break;
256 }
257 }
258
259 // ARMARX_INFO << VAROUT(value / leftHandConversionFactor);
260 ui->lcdNumberLeftHandJointValue->display(value / leftHandConversionFactor);
261 leftHandUnitProxy->setJointAngles(leftHandJa);
262 }
263
264 void
265 HandUnitWidget::setRightHandJointAngles()
266 {
267 // ARMARX_INFO << "setRightHandJointAngles";
268 if (!rightHandUnitProxy)
269 {
270 ARMARX_WARNING << "invalid proxy";
271 return;
272 }
273
274 if (!setRightHandJointAnglesFlag)
275 {
276 return;
277 }
278
279 setRightHandJointAnglesFlag = false;
280
281 NameValueMap rightHandJa;
282 NameValueMap currentRightHandJointValues = rightHandUnitProxy->getCurrentJointValues();
283 float value = 0;
284 if (rightHandName == "Hand R" || rightHandName == "TCP R")
285 {
286 rightHandConversionFactor *= M_PI / 2;
287 }
288 else if (rightHandName != "Hand_R_EEF")
289 {
290 ARMARX_WARNING << "Right hand with name \"" << rightHandName << "\" is not supported.";
291 return;
292 }
293
294 for (const auto& pair : currentRightHandJointValues)
295 {
296 if (pair.first == currentRightHandJoint)
297 {
298 value = static_cast<float>(ui->horizontalSliderRightHandJointPos->value() *
299 rightHandConversionFactor);
300 // ARMARX_INFO << VAROUT(value);
301 rightHandJa[pair.first] = value;
302 break;
303 }
304 }
305
306 // ARMARX_INFO << VAROUT(value / rightHandConversionFactor);
307 ui->lcdNumberRightHandJointValue->display(value / rightHandConversionFactor);
308 rightHandUnitProxy->setJointAngles(rightHandJa);
309 }
310
311 void
312 HandUnitWidget::requestSetLeftHandJointAngles()
313 {
314 setLeftHandJointAnglesFlag = true;
315 }
316
317 void
318 HandUnitWidget::requestSetRightHandJointAngles()
319 {
320 setRightHandJointAnglesFlag = true;
321 }
322
323 void
324 HandUnitWidget::openLeftHand()
325 {
326 setLeftHandPreshape("Open");
327 }
328
329 void
330 HandUnitWidget::openRightHand()
331 {
332 setRightHandPreshape("Open");
333 }
334
335 void
336 HandUnitWidget::closeLeftHand()
337 {
338 setLeftHandPreshape("Close");
339 }
340
341 void
342 HandUnitWidget::closeRightHand()
343 {
344 setRightHandPreshape("Close");
345 }
346
347 void
348 HandUnitWidget::relaxLeftHand()
349 {
350 setLeftHandPreshape("Relax");
351 }
352
353 void
354 HandUnitWidget::relaxRightHand()
355 {
356 setRightHandPreshape("Relax");
357 }
358
359 void
360 HandUnitWidget::updateInfoLabel()
361 {
362 ui->labelInfoLeftHand->setText(
363 QString::fromStdString(leftHandUnitProxyName + " :: " + leftHandName +
364 " State: " + leftHandUnitProxy->describeHandState()));
365 ui->labelInfoRightHand->setText(
366 QString::fromStdString(rightHandUnitProxyName + " :: " + rightHandName +
367 " State: " + rightHandUnitProxy->describeHandState()));
368 }
369
370 void
371 HandUnitWidget::updateJointValueTable()
372 {
373 NameValueMap currentLeftHandJointValues = leftHandUnitProxy->getCurrentJointValues();
374 // ARMARX_INFO << VAROUT(leftHandUnitProxy->getCurrentJointValues());
375 int frameLeftHandRowIdx = 0;
376
377 for (const auto& pair : currentLeftHandJointValues)
378 {
379 // ARMARX_INFO << VAROUT(pair.first);
380 QString name(pair.first.c_str());
381 QTableWidgetItem* newItem = new QTableWidgetItem(QString::number(pair.second));
382 ui->tableWidgetLeftHand->setItem(frameLeftHandRowIdx, 1, newItem);
383 frameLeftHandRowIdx++;
384 }
385
386
387 NameValueMap currentRightHandJointValues = rightHandUnitProxy->getCurrentJointValues();
388 // ARMARX_INFO << VAROUT(rightHandUnitProxy->getCurrentJointValues());
389 int frameRightHandRowIdx = 0;
390
391 for (const auto& pair : currentRightHandJointValues)
392 {
393 // ARMARX_INFO << VAROUT(pair.first);
394 QString name(pair.first.c_str());
395 QTableWidgetItem* newItem = new QTableWidgetItem(QString::number(pair.second));
396 ui->tableWidgetRightHand->setItem(frameRightHandRowIdx, 1, newItem);
397 frameRightHandRowIdx++;
398 }
399 }
400
401 void
402 HandUnitWidget::setExpertMode(side side, int state)
403 {
404 bool const isExpert = state == Qt::Checked;
405
406 if (side == side::left)
407 {
408 ui->leftTare->setEnabled(isExpert);
409 ui->leftReboot->setEnabled(isExpert);
410 }
411 else if (side == side::right)
412 {
413 ui->rightTare->setEnabled(isExpert);
414 ui->rightReboot->setEnabled(isExpert);
415 }
416 else
417 {
418 ARMARX_WARNING << "Invalid side to set expert mode.";
419 }
420 }
421
422 void
423 HandUnitWidget::tareHand(bool checked, side side)
424 {
425 if (side == side::left)
426 {
427 if (checked)
428 {
429 ARMARX_INFO << "Trigger start taring left hand now...";
430 ui->leftTare->setText("tare now");
431 leftHandUnitProxy->startTare();
432 }
433 else
434 {
435 ARMARX_INFO << "Trigger taring left hand now...";
436 ui->leftTare->setText("start tare");
437 leftHandUnitProxy->tare();
438 }
439 }
440 else if (side == side::right)
441 {
442 if (checked)
443 {
444 ARMARX_INFO << "Trigger start taring right hand now...";
445 ui->rightTare->setText("tare now");
446 rightHandUnitProxy->startTare();
447 }
448 else
449 {
450 ARMARX_INFO << "Trigger taring left right now...";
451 ui->rightTare->setText("start tare");
452 rightHandUnitProxy->tare();
453 }
454 }
455 else
456 {
457 ARMARX_WARNING << "Invalid side to tare hand.";
458 }
459 }
460
461 void
462 HandUnitWidget::rebootHand(side side)
463 {
464 if (side == side::left)
465 {
466 ARMARX_INFO << "Trigger resetting left hand firmware now...";
467 leftHandUnitProxy->rebootEmbeddedSystem();
468 }
469 else if (side == side::right)
470 {
471 ARMARX_INFO << "Trigger resetting right hand firmware now...";
472 rightHandUnitProxy->rebootEmbeddedSystem();
473 }
474 else
475 {
476 ARMARX_WARNING << "Invalid side to reset hand firmware.";
477 }
478 }
479
480 void
481 HandUnitWidget::selectLeftHandJoint(int i)
482 {
483 // ARMARX_INFO << "selectLeftHandJoint " << i;
484 NameValueMap currentLeftHandJointValues = leftHandUnitProxy->getCurrentJointValues();
485 int idx = 0;
486
487 for (const auto& pair : currentLeftHandJointValues)
488 {
489 if (idx == i)
490 {
491 currentLeftHandJoint = pair.first;
492 int convertedValue = static_cast<int>(pair.second / leftHandConversionFactor);
493 ui->horizontalSliderLeftHandJointPos->setSliderPosition(convertedValue);
494 ui->lcdNumberLeftHandJointValue->display(convertedValue);
495 // ARMARX_INFO << "Found joint";
496 break;
497 }
498 idx++;
499 }
500 }
501
502 void
503 HandUnitWidget::selectRightHandJoint(int i)
504 {
505 // ARMARX_INFO << "selectRightHandJoint " << i;
506 NameValueMap currentRightHandJointValues = rightHandUnitProxy->getCurrentJointValues();
507 int idx = 0;
508
509 for (const auto& pair : currentRightHandJointValues)
510 {
511 if (idx == i)
512 {
513 currentRightHandJoint = pair.first;
514 int convertedValue = static_cast<int>(pair.second / rightHandConversionFactor);
515 ui->horizontalSliderRightHandJointPos->setSliderPosition(convertedValue);
516 ui->lcdNumberRightHandJointValue->display(convertedValue);
517 // ARMARX_INFO << "Found joint";
518 break;
519 }
520 idx++;
521 }
522 }
523
524 void
525 HandUnitWidget::setLeftHandPreshape(std::string preshape)
526 {
527 // ARMARX_INFO << "Setting new left hand shape: " << preshape;
528 leftHandUnitProxy->setShape(preshape);
529 }
530
531 void
532 HandUnitWidget::setRightHandPreshape(std::string preshape)
533 {
534 // ARMARX_INFO << "Setting new right hand shape: " << preshape;
535 rightHandUnitProxy->setShape(preshape);
536 }
537
538 void
539 HandUnitWidget::loadSettings(QSettings* settings)
540 {
541 leftHandUnitProxyName =
542 settings->value("leftHandUnitProxyName", QString::fromStdString(leftHandUnitProxyName))
543 .toString()
544 .toStdString();
545 leftHandName = settings->value("leftHandName", QString::fromStdString(leftHandName))
546 .toString()
547 .toStdString();
548 rightHandUnitProxyName =
549 settings
550 ->value("rightHandUnitProxyName", QString::fromStdString(rightHandUnitProxyName))
551 .toString()
552 .toStdString();
553 rightHandName = settings->value("rightHandName", QString::fromStdString(rightHandName))
554 .toString()
555 .toStdString();
556 }
557
558 void
559 HandUnitWidget::saveSettings(QSettings* settings)
560 {
561 settings->setValue("leftHandUnitProxyName", QString::fromStdString(leftHandUnitProxyName));
562 settings->setValue("leftHandName", QString::fromStdString(leftHandName));
563 settings->setValue("rightHandUnitProxyName",
564 QString::fromStdString(rightHandUnitProxyName));
565 settings->setValue("rightHandName", QString::fromStdString(rightHandName));
566 }
567
568 void
569 HandUnitWidget::initGUIJointFrames()
570 {
571 ARMARX_INFO << "initGUIJointFrames";
572
573 NameValueMap currentLeftHandJointValues = leftHandUnitProxy->getCurrentJointValues();
574 // ARMARX_INFO << VAROUT(leftHandUnitProxy->getCurrentJointValues());
575 int frameLeftHandRowIdx = 0;
576
577 connect(ui->buttonPreshapeLeftHand,
578 SIGNAL(clicked()),
579 this,
580 SLOT(preshapeLeftHand()),
581 Qt::UniqueConnection);
582 connect(ui->buttonOpenLeftHand,
583 SIGNAL(clicked()),
584 this,
585 SLOT(openLeftHand()),
586 Qt::UniqueConnection);
587 connect(ui->buttonCloseLeftHand,
588 SIGNAL(clicked()),
589 this,
590 SLOT(closeLeftHand()),
591 Qt::UniqueConnection);
592 connect(ui->buttonRelaxLeftHand,
593 SIGNAL(clicked()),
594 this,
595 SLOT(relaxLeftHand()),
596 Qt::UniqueConnection);
597 ui->horizontalSliderLeftHandJointPos->setMaximum(100);
598 ui->horizontalSliderLeftHandJointPos->setMinimum(0);
599 connect(ui->horizontalSliderLeftHandJointPos,
600 SIGNAL(sliderMoved(int)),
601 this,
602 SLOT(requestSetLeftHandJointAngles()),
603 Qt::UniqueConnection);
604 connect(ui->comboLeftHandJoints,
605 SIGNAL(currentIndexChanged(int)),
606 this,
607 SLOT(selectLeftHandJoint(int)),
608 Qt::UniqueConnection);
609 connect(ui->leftExpertMode,
610 &QCheckBox::stateChanged,
611 [&](int state) { setExpertMode(side::left, state); });
612 connect(ui->leftTare,
613 &QPushButton::toggled,
614 [&](bool checked) { tareHand(checked, side::left); });
615 connect(ui->leftReboot, &QPushButton::clicked, [&] { rebootHand(side::left); });
616
617 ui->tableWidgetLeftHand->setRowCount(currentLeftHandJointValues.size());
618 ui->tableWidgetLeftHand->setColumnCount(2);
619
620 ui->comboLeftHandJoints->clear();
621
622 qRegisterMetaType<QVector<int>>("QVector<int>");
623 for (const auto& pair : currentLeftHandJointValues)
624 {
625 // ARMARX_INFO << VAROUT(pair.first);
626 QString name(pair.first.c_str());
627 QTableWidgetItem* newItem = new QTableWidgetItem(name);
628 ui->tableWidgetLeftHand->setItem(frameLeftHandRowIdx, 0, newItem);
629 ui->comboLeftHandJoints->addItem(name);
630 frameLeftHandRowIdx++;
631 }
632
633 ui->comboLeftHandJoints->setCurrentIndex(-1);
634
635
636 NameValueMap currentRightHandJointValues = rightHandUnitProxy->getCurrentJointValues();
637 // ARMARX_INFO << VAROUT(rightHandUnitProxy->getCurrentJointValues());
638 int frameRightHandRowIdx = 0;
639
640 connect(ui->buttonPreshapeRightHand,
641 SIGNAL(clicked()),
642 this,
643 SLOT(preshapeRightHand()),
644 Qt::UniqueConnection);
645 connect(ui->buttonOpenRightHand,
646 SIGNAL(clicked()),
647 this,
648 SLOT(openRightHand()),
649 Qt::UniqueConnection);
650 connect(ui->buttonCloseRightHand,
651 SIGNAL(clicked()),
652 this,
653 SLOT(closeRightHand()),
654 Qt::UniqueConnection);
655 connect(ui->buttonRelaxRightHand,
656 SIGNAL(clicked()),
657 this,
658 SLOT(relaxRightHand()),
659 Qt::UniqueConnection);
660 ui->horizontalSliderRightHandJointPos->setMaximum(100);
661 ui->horizontalSliderRightHandJointPos->setMinimum(0);
662 connect(ui->horizontalSliderRightHandJointPos,
663 SIGNAL(sliderMoved(int)),
664 this,
665 SLOT(requestSetRightHandJointAngles()),
666 Qt::UniqueConnection);
667 connect(ui->comboRightHandJoints,
668 SIGNAL(currentIndexChanged(int)),
669 this,
670 SLOT(selectRightHandJoint(int)),
671 Qt::UniqueConnection);
672 connect(ui->rightExpertMode,
673 &QCheckBox::stateChanged,
674 [&](int state) { setExpertMode(side::right, state); });
675 connect(ui->rightTare,
676 &QPushButton::clicked,
677 [&](bool checked) { tareHand(checked, side::right); });
678 connect(ui->rightReboot, &QPushButton::clicked, [&] { rebootHand(side::right); });
679
680 ui->tableWidgetRightHand->setRowCount(currentRightHandJointValues.size());
681 ui->tableWidgetRightHand->setColumnCount(2);
682
683 ui->comboRightHandJoints->clear();
684
685 qRegisterMetaType<QVector<int>>("QVector<int>");
686 for (const auto& pair : currentRightHandJointValues)
687 {
688 // ARMARX_INFO << VAROUT(pair.first);
689 QString name(pair.first.c_str());
690 QTableWidgetItem* newItem = new QTableWidgetItem(name);
691 ui->tableWidgetRightHand->setItem(frameRightHandRowIdx, 0, newItem);
692 ui->comboRightHandJoints->addItem(name);
693 frameRightHandRowIdx++;
694 }
695
696 ui->comboRightHandJoints->setCurrentIndex(-1);
697
698
699 // reloading of preshapes
700 connect(ui->reloadPreshapesButton,
701 SIGNAL(clicked()),
702 this,
703 SLOT(reloadPreshapes()),
704 Qt::UniqueConnection);
705 }
706
707 void
708 armarx::HandUnitWidget::reportHandShaped(const std::string& handName,
709 const std::string& handShapeName,
710 const Ice::Current&)
711 {
712 ARMARX_IMPORTANT << handName << ": " << handShapeName;
713 }
714
715 void
716 armarx::HandUnitWidget::reportNewHandShapeName(const std::string& handName,
717 const std::string& handShapeName,
718 const Ice::Current&)
719 {
720 ARMARX_IMPORTANT << handName << ": " << handShapeName;
721 }
722
723 void
724 armarx::HandUnitWidget::reportJointAngles(const armarx::NameValueMap& actualJointAngles,
725 const Ice::Current& c)
726 {
727 }
728
729 void
730 armarx::HandUnitWidget::reportJointPressures(const armarx::NameValueMap& actualJointPressures,
731 const Ice::Current& c)
732 {
733 }
734} // namespace armarx
M_PI
#define M_PI
Definition MathTools.h:17
c
constexpr T c
Definition UnscentedKalmanFilterTest.cpp:46
armarx::ArmarXGuiPlugin::addWidget
std::enable_if<!HasGetWidgetName< ArmarXWidgetType >::value >::type addWidget()
Definition ArmarXGuiPlugin.h:56
armarx::ArmarXWidgetController::getWidget
virtual QPointer< QWidget > getWidget()
getWidget returns a pointer to the a widget of this controller.
Definition ArmarXWidgetController.cpp:54
armarx::HandUnitWidget::tareHand
void tareHand(bool checked, side side)
Definition HandUnitGuiPlugin.cpp:423
armarx::HandUnitWidget::onInitComponent
void onInitComponent() override
Pure virtual hook for the subclass.
Definition HandUnitGuiPlugin.cpp:65
armarx::HandUnitWidget::onDisconnectComponent
void onDisconnectComponent() override
Hook for subclass.
Definition HandUnitGuiPlugin.cpp:147
armarx::HandUnitWidget::ui
std::unique_ptr< Ui::HandUnitGuiPlugin > ui
Definition HandUnitGuiPlugin.h:165
armarx::HandUnitWidget::loadSettings
void loadSettings(QSettings *settings) override
Implement to load the settings that are part of the GUI configuration.
Definition HandUnitGuiPlugin.cpp:539
armarx::HandUnitWidget::saveSettings
void saveSettings(QSettings *settings) override
Implement to save the settings as part of the GUI configuration.
Definition HandUnitGuiPlugin.cpp:559
armarx::HandUnitWidget::reportJointPressures
void reportJointPressures(const ::armarx::NameValueMap &actualJointPressures, const Ice::Current &) override
Definition HandUnitGuiPlugin.cpp:730
armarx::HandUnitWidget::getConfigDialog
QPointer< QDialog > getConfigDialog(QWidget *parent=0) override
getConfigDialog returns a pointer to the a configuration widget of this controller.
Definition HandUnitGuiPlugin.cpp:162
armarx::HandUnitWidget::reportHandShaped
void reportHandShaped(const std::string &, const std::string &, const Ice::Current &) override
Definition HandUnitGuiPlugin.cpp:708
armarx::HandUnitWidget::onConnectComponent
void onConnectComponent() override
Pure virtual hook for the subclass.
Definition HandUnitGuiPlugin.cpp:74
armarx::HandUnitWidget::setExpertMode
void setExpertMode(side side, int state)
Definition HandUnitGuiPlugin.cpp:402
armarx::HandUnitWidget::configured
void configured() override
This function must be implemented by the user, if he supplies a config dialog.
Definition HandUnitGuiPlugin.cpp:175
armarx::HandUnitWidget::reportNewHandShapeName
void reportNewHandShapeName(const std::string &, const std::string &, const Ice::Current &) override
Definition HandUnitGuiPlugin.cpp:716
armarx::HandUnitWidget::onExitComponent
void onExitComponent() override
Hook for subclass.
Definition HandUnitGuiPlugin.cpp:156
armarx::HandUnitWidget::~HandUnitWidget
~HandUnitWidget() override
armarx::HandUnitWidget::reportJointAngles
void reportJointAngles(const ::armarx::NameValueMap &actualJointAngles, const Ice::Current &) override
Definition HandUnitGuiPlugin.cpp:724
armarx::ManagedIceObject::usingProxy
bool usingProxy(const std::string &name, const std::string &endpoints="")
Registers a proxy for retrieval after initialization and adds it to the dependency list.
Definition ManagedIceObject.cpp:154
armarx::ManagedIceObject::getProxy
Ice::ObjectPrx getProxy(long timeoutMs=0, bool waitForScheduler=true) const
Returns the proxy of this object (optionally it waits for the proxy)
Definition ManagedIceObject.cpp:407
armarx::PeriodicTask
The periodic task executes one thread method repeatedly using the time period specified in the constr...
Definition PeriodicTask.h:56
ARMARX_INFO
#define ARMARX_INFO
The normal logging level.
Definition Logging.h:179
ARMARX_IMPORTANT
#define ARMARX_IMPORTANT
The logging level for always important information, but expected behaviour (in contrast to ARMARX_WAR...
Definition Logging.h:188
ARMARX_WARNING
#define ARMARX_WARNING
The logging level for unexpected behaviour, but not a serious problem.
Definition Logging.h:191
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition ArmarXTimeserver.cpp:28
armarx::SingleTypeVariantListPtr
IceInternal::Handle< SingleTypeVariantList > SingleTypeVariantListPtr
Definition SingleTypeVariantList.h:38
armarx::get< std::string >
std::string Variant::get< std::string >() const
Definition Variant.cpp:284