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