YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
jointitem.cpp
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
4 * SPDX-License-Identifier: LGPL-2.1-or-later
5 */
6
7#include "jointitem.h"
8#include "ui_jointitem.h"
9
10#include "log.h"
11#include "yarpmotorgui.h"
12
13#include <cmath>
14
15#include <yarp/os/Log.h>
16#include <yarp/os/LogStream.h>
17
18#include <QDebug>
19#include <QKeyEvent>
20#include <QStandardItem>
21#include <QListView>
22
24{
25 ui->sliderPosTrajectory_Position->resetTarget();
26 ui->sliderMixedPosition->resetTarget();
27}
28
30{
31 if (this->internalState == Velocity)
32 {
33 velocityTimer.stop();
34 }
35 else if (this->internalState == VelocityDirect)
36 {
37 velocityDirectTimer.stop();
38 }
39 else if(this->internalState == Pwm)
40 {
41 pwmTimer.stop();
42 }
43 else if(this->internalState == Current)
44 {
45 currentTimer.stop();
46 }
47 else if(this->internalState == Torque)
48 {
49 torqueTimer.stop();
50 }
51 emit homeClicked(this);
52}
53
55{
56 if (this->internalState == Velocity)
57 {
58 velocityTimer.stop();
59 }
60 else if (this->internalState == VelocityDirect)
61 {
62 velocityDirectTimer.stop();
63 }
64 else if(this->internalState == Pwm)
65 {
66 pwmTimer.stop();
67 }
68 else if(this->internalState == Current)
69 {
70 currentTimer.stop();
71 }
72 else if(this->internalState == Torque)
73 {
74 torqueTimer.stop();
75 }
76 emit runClicked(this);
77}
78
80{
81 if (this->internalState == Velocity)
82 {
83 velocityTimer.stop();
84 }
85 else if (this->internalState == VelocityDirect)
86 {
87 velocityDirectTimer.stop();
88 }
89 else if(this->internalState == Pwm)
90 {
91 pwmTimer.stop();
92 }
93 else if(this->internalState == Current)
94 {
95 currentTimer.stop();
96 }
97 else if(this->internalState == Torque)
98 {
99 torqueTimer.stop();
100 }
101 emit idleClicked(this);
102}
103
105{
106 emit pidClicked(this);
107}
108
110{
111 QColor output;
112 switch (mode) {
113 case JointItem::Idle:{
114 output = idleColor;
115 break;
116 }
118 output = positionColor;
119 break;
120 }
122 output = positionDirectColor;
123 break;
124 }
125 case JointItem::Mixed:{
126 output = mixedColor;
127 break;
128 }
130 output = velocityColor;
131 break;
132 }
134 output = velocityDirectColor;
135 break;
136 }
137 case JointItem::Torque:{
138 output = torqueColor;
139 break;
140 }
141 case JointItem::Pwm:{
142 output = pwmColor;
143 break;
144 }
145 case JointItem::Current:{
146 output = currentColor;
147 break;
148 }
149
151 output = disconnectColor;
152 break;
153 }
154 case JointItem::HwFault:{
155 output = hwFaultColor;
156 break;
157 }
159 output = calibratingColor;
160 break;
161 }
163 output = calibratingColor;
164 break;
165 }
167 output = calibratingColor;
168 break;
169 }
170
171 default:
172 output = calibratingColor;
173 break;
174 }
175
176 return output;
177
178}
179
181{
182 switch (mode) {
183 case JointItem::Idle:{
185 break;
186 }
189 break;
190 }
193 break;
194 }
195 case JointItem::Mixed:{
197 break;
198 }
201 break;
202 }
205 break;
206 }
207 case JointItem::Torque:{
209 break;
210 }
211 case JointItem::Pwm:{
213 break;
214 }
215 case JointItem::Current:{
217 break;
218 }
219
220 //case JointItem::Disconnected:{
221 // return yarp::dev::ControlModeEnum::VOCAB_CM_DISCONNECTED;
222 // break;
223 //}
224
225 case JointItem::HwFault:{
227 break;
228 }
231 break;
232 }
235 break;
236 }
239 break;
240 }
241 }
243}
244
246{
247 QString output;
248 switch (mode) {
249 case JointItem::Idle:{
250 output = "Idle";
251 break;
252 }
254 output = "Position";
255 break;
256 }
258 output = "Position Direct";
259 break;
260 }
261 case JointItem::Mixed:{
262 output = "Mixed";
263 break;
264 }
266 output = "Velocity";
267 break;
268 }
270 output = "Velocity Direct";
271 break;
272 }
273 case JointItem::Torque:{
274 output = "Torque";
275 break;
276 }
277 case JointItem::Pwm:{
278 output = "PWM";
279 break;
280 }
281 case JointItem::Current:{
282 output = "Current";
283 break;
284 }
285
287 output = "Disconnected";
288 break;
289 }
290 case JointItem::HwFault:{
291 output = "Hardware Fault";
292 break;
293 }
295 output = "Calibrating";
296 break;
297 }
299 output = "Not Configured";
300 break;
301 }
303 output = "Configured";
304 break;
305 }
306
307 default:
308 output = "Unknown";
309 break;
310 }
311
312 return output;
313
314}
315
316void JointItem::updateTrajectoryPositionTarget(double val)
317{
318 ui->sliderPosTrajectory_Position->updateSliderTarget(val);
319}
320
321void JointItem::updateMixedPositionTarget(double val)
322{
323 ui->sliderMixedPosition->updateSliderTarget(val);
324}
325
326
327
328
329JointItem::JointItem(int index, std::vector<yarp::dev::SelectableControlModeEnum> modes, QWidget *parent) :
330 QWidget(parent),
331 ui(new Ui::JointItem)
332{
333 ui->setupUi(this);
334 internalState = StateStarting;
335 internalInteraction = InteractionStarting;
336 jointIndex = index;
337
338 connect(ui->comboMode,SIGNAL(currentIndexChanged(int)),this,SLOT(onModeChanged(int)));
339 connect(ui->comboInteraction,SIGNAL(currentIndexChanged(int)),this,SLOT(onInteractionChanged(int)));
340
341 ui->sliderPosTrajectory_Position->installEventFilter(this);
342 connect(ui->sliderPosTrajectory_Position,SIGNAL(sliderPressed()),this,SLOT(onSliderPosTrajectory_PositionPressed()));
343 connect(ui->sliderPosTrajectory_Position, SIGNAL(sliderReleased()), this, SLOT(onSliderPosTrajectory_PositionReleased()));
344 ui->sliderPosTrajectory_Position->disableClickOutOfHandle=true;
345 ui->sliderPosTrajectory_Position->enableViewTargetBox = true;
346 ui->sliderPosTrajectory_Position->enableViewTargetValue = false;
347
348 ui->sliderTorqueTorque->installEventFilter(this);
349 connect(ui->sliderTorqueTorque,SIGNAL(sliderPressed()),this,SLOT(onSliderTorquePressed()));
350 connect(ui->sliderTorqueTorque,SIGNAL(sliderReleased()),this,SLOT(onSliderTorqueReleased()));
351 ui->sliderTorqueTorque->disableClickOutOfHandle = true;
352 ui->sliderTorqueTorque->enableViewTargetBox = false;
353 ui->sliderTorqueTorque->enableViewTargetValue = false;
354
355 ui->sliderPWMOutput->installEventFilter(this);
356 connect(ui->sliderPWMOutput, SIGNAL(sliderPressed()), this, SLOT(onSliderPWMPressed()));
357 connect(ui->sliderPWMOutput, SIGNAL(sliderReleased()), this, SLOT(onSliderPWMReleased()));
358 ui->sliderPWMOutput->disableClickOutOfHandle = true;
359 ui->sliderPWMOutput->enableViewTargetBox = false;
360 ui->sliderPWMOutput->enableViewTargetValue = false;
361
362 ui->sliderCurrentOutput->installEventFilter(this);
363 connect(ui->sliderCurrentOutput, SIGNAL(sliderPressed()), this, SLOT(onSliderCurrentPressed()));
364 connect(ui->sliderCurrentOutput, SIGNAL(sliderReleased()), this, SLOT(onSliderCurrentReleased()));
365 ui->sliderCurrentOutput->disableClickOutOfHandle = true;
366 ui->sliderCurrentOutput->enableViewTargetBox = false;
367 ui->sliderCurrentOutput->enableViewTargetValue = false;
368
369 ui->sliderDirectPosition->installEventFilter(this);
370 connect(ui->sliderDirectPosition, SIGNAL(sliderPressed()), this, SLOT(onSliderDirectPositionPressed()));
371 connect(ui->sliderDirectPosition, SIGNAL(sliderReleased()), this, SLOT(onSliderDirectPositionReleased()));
372 ui->sliderDirectPosition->disableClickOutOfHandle = true;
373 ui->sliderDirectPosition->enableViewTargetBox = false;
374 ui->sliderDirectPosition->enableViewTargetValue = false;
375
376 ui->sliderVelocityDirectVelocityDirect->installEventFilter(this);
377 connect(ui->sliderVelocityDirectVelocityDirect, SIGNAL(sliderPressed()), this, SLOT(onSliderVelocityDirectPressed()));
378 connect(ui->sliderVelocityDirectVelocityDirect, SIGNAL(sliderReleased()), this, SLOT(onSliderVelocityDirectReleased()));
379 ui->sliderVelocityDirectVelocityDirect->disableClickOutOfHandle = true;
380 ui->sliderVelocityDirectVelocityDirect->enableViewTargetBox = false;
381 ui->sliderVelocityDirectVelocityDirect->enableViewTargetValue = false;
382
383 ui->sliderMixedPosition->installEventFilter(this);
384 connect(ui->sliderMixedPosition, SIGNAL(sliderPressed()), this, SLOT(onSliderMixedPositionPressed()));
385 connect(ui->sliderMixedPosition, SIGNAL(sliderReleased()), this, SLOT(onSliderMixedPositionReleased()));
386 ui->sliderMixedPosition->disableClickOutOfHandle = true;
387 ui->sliderMixedPosition->enableViewTargetBox = true;
388 ui->sliderMixedPosition->enableViewTargetValue = false;
389
390 ui->sliderVelTrajectory_Velocity->installEventFilter(this);
391 connect(ui->sliderVelTrajectory_Velocity,SIGNAL(sliderPressed()),this,SLOT(onSliderVelTrajectory_VelocityPressed()));
392 connect(ui->sliderVelTrajectory_Velocity,SIGNAL(sliderReleased()),this,SLOT(onSliderVelTrajectory_VelocityReleased()));
393 ui->sliderVelTrajectory_Velocity->disableClickOutOfHandle = true;
394 ui->sliderVelTrajectory_Velocity->enableViewTargetBox = false;
395 ui->sliderVelTrajectory_Velocity->enableViewTargetValue = false;
396
397 ui->sliderPosTrajectory_Velocity->installEventFilter(this);
398 connect(ui->sliderPosTrajectory_Velocity, SIGNAL(sliderPressed()), this, SLOT(onSliderPosTrajectory_VelocityPressed()));
399 connect(ui->sliderPosTrajectory_Velocity, SIGNAL(sliderReleased()), this, SLOT(onSliderPosTrajectory_VelocityReleased()));
400 ui->sliderPosTrajectory_Velocity->disableClickOutOfHandle = true;
401 ui->sliderPosTrajectory_Velocity->enableViewTargetBox = false;
402 ui->sliderPosTrajectory_Velocity->enableViewTargetValue = false;
403
404 ui->sliderVelTrajectory_Acceleration->installEventFilter(this);
405 connect(ui->sliderVelTrajectory_Acceleration, SIGNAL(sliderPressed()), this, SLOT(onSliderVelTrajectory_AccelerationPressed()));
406 connect(ui->sliderVelTrajectory_Acceleration, SIGNAL(sliderReleased()), this, SLOT(onSliderVelTrajectory_AccelerationReleased()));
407 ui->sliderVelTrajectory_Acceleration->disableClickOutOfHandle = true;
408 ui->sliderVelTrajectory_Acceleration->enableViewTargetBox = false;
409 ui->sliderVelTrajectory_Acceleration->enableViewTargetValue = false;
410
411 ui->sliderMixedVelocity->installEventFilter(this);
412 connect(ui->sliderMixedVelocity, SIGNAL(sliderPressed()), this, SLOT(onSliderMixedVelocityPressed()));
413 connect(ui->sliderMixedVelocity, SIGNAL(sliderReleased()), this, SLOT(onSliderMixedVelocityReleased()));
414 ui->sliderMixedVelocity->disableClickOutOfHandle = true;
415 ui->sliderMixedVelocity->enableViewTargetBox = false;
416 ui->sliderMixedVelocity->enableViewTargetValue = false;
417
418 connect(ui->buttonHome,SIGNAL(clicked()),this,SLOT(onHomeClicked()));
419 connect(ui->buttonIdle,SIGNAL(clicked()),this,SLOT(onIdleClicked()));
420 connect(ui->buttonRun,SIGNAL(clicked()),this,SLOT(onRunClicked()));
421 connect(ui->buttonPid,SIGNAL(clicked()),this,SLOT(onPidClicked()));
422 connect(ui->buttonCalib,SIGNAL(clicked()),this,SLOT(onCalibClicked()));
423
424 ui->groupBox->setTitle(QString("JOINT %1 (%2)").arg(index).arg(jointName));
425 // ui->groupBox->setAlignment(Qt::AlignHCenter);
426
427
428
429
430 comboStyle1 = "QComboBox {"
431 "border: 1px solid gray;"
432 "border-radius: 3px;"
433 "padding: 1px 18px 1px 3px;"
434 "min-width: 6em;}"
435 "QComboBox:editable {"
436 "background: white;"
437 "foreground: rgb(35, 38, 41);}"
438 "QComboBox::down-arrow {"
439 "image: url(:/images/downArrow.png);}";
440
441
442 comboStyle2 = "QComboBox:on { "
443 "padding-top: 3px;"
444 "padding-left: 4px;}"
445 "QComboBox::drop-down {"
446 "subcontrol-origin: padding;"
447 "subcontrol-position: top right;"
448 "width: 15px;"
449 "border-left-width: 1px;"
450 "border-left-color: darkgray;"
451 "border-left-style: solid; "
452 "border-top-right-radius: 3px; "
453 "border-bottom-right-radius: 3px;"
454 "background-color: darkgray;}";
455
456
457
458 installFilter();
459
460 ui->comboInteraction->setItemData(0,QColor(Qt::darkGray), Qt::BackgroundRole);
461 ui->comboInteraction->setItemData(1,QColor(0,80,255), Qt::BackgroundRole);
462 ui->comboInteraction->setItemData(1,QColor(35, 38, 41), Qt::ForegroundRole);
463
464 ui->comboMode->setItemData( IDLE, idleColor, Qt::BackgroundRole );
465 ui->comboMode->setItemData( POSITION, positionColor, Qt::BackgroundRole );
466 ui->comboMode->setItemData( POSITION_DIR, positionDirectColor, Qt::BackgroundRole );
467 ui->comboMode->setItemData( MIXED, mixedColor, Qt::BackgroundRole );
468 ui->comboMode->setItemData( VELOCITY, velocityColor, Qt::BackgroundRole );
469 ui->comboMode->setItemData( VELOCITY_DIR, velocityDirectColor, Qt::BackgroundRole );
470 ui->comboMode->setItemData( TORQUE, torqueColor, Qt::BackgroundRole );
471 ui->comboMode->setItemData( PWM, pwmColor, Qt::BackgroundRole );
472 ui->comboMode->setItemData( CURRENT, currentColor, Qt::BackgroundRole);
473
474 ui->comboMode->setItemData( IDLE, QColor(35, 38, 41), Qt::ForegroundRole );
475 ui->comboMode->setItemData( POSITION, QColor(35, 38, 41), Qt::ForegroundRole );
476 ui->comboMode->setItemData( POSITION_DIR, QColor(35, 38, 41), Qt::ForegroundRole );
477 ui->comboMode->setItemData( MIXED, QColor(35, 38, 41), Qt::ForegroundRole );
478 ui->comboMode->setItemData( VELOCITY, QColor(35, 38, 41), Qt::ForegroundRole );
479 ui->comboMode->setItemData( VELOCITY_DIR, QColor(35, 38, 41), Qt::ForegroundRole );
480 ui->comboMode->setItemData( TORQUE, QColor(35, 38, 41), Qt::ForegroundRole );
481 ui->comboMode->setItemData( PWM, QColor(35, 38, 41), Qt::ForegroundRole );
482 ui->comboMode->setItemData( CURRENT, QColor(35, 38, 41), Qt::ForegroundRole );
483
484 ui->comboMode->setItemData( IDLE, Idle, Qt::UserRole);
485 ui->comboMode->setItemData( POSITION, Position, Qt::UserRole );
486 ui->comboMode->setItemData( POSITION_DIR, PositionDirect, Qt::UserRole );
487 ui->comboMode->setItemData( MIXED, Mixed, Qt::UserRole );
488 ui->comboMode->setItemData( VELOCITY, Velocity, Qt::UserRole );
489 ui->comboMode->setItemData( VELOCITY_DIR, VelocityDirect, Qt::UserRole );
490 ui->comboMode->setItemData( TORQUE, Torque, Qt::UserRole );
491 ui->comboMode->setItemData( PWM, Pwm, Qt::UserRole);
492 ui->comboMode->setItemData( CURRENT, Current, Qt::UserRole);
493
494 setJointInternalState(IDLE);
495
496 ui->stackedWidget->widget(VELOCITY)->setEnabled(false);
497 velocityTimer.setInterval(50);
498 velocityTimer.setSingleShot(false);
499 connect(&velocityTimer,SIGNAL(timeout()),this,SLOT(onVelocityTimer()));
500
501 ui->stackedWidget->widget(VELOCITY_DIR)->setEnabled(false);
502 velocityDirectTimer.setInterval(50);
503 velocityDirectTimer.setSingleShot(false);
504 connect(&velocityDirectTimer,SIGNAL(timeout()),this,SLOT(onVelocityDirectTimer()));
505
506 ui->stackedWidget->widget(PWM)->setEnabled(false);
507 pwmTimer.setInterval(50);
508 pwmTimer.setSingleShot(false);
509 connect(&pwmTimer,SIGNAL(timeout()),this,SLOT(onPwmTimer()));
510
511 ui->stackedWidget->widget(CURRENT)->setEnabled(false);
512 currentTimer.setInterval(50);
513 currentTimer.setSingleShot(false);
514 connect(&currentTimer,SIGNAL(timeout()),this,SLOT(onCurrentTimer()));
515
516 ui->stackedWidget->widget(TORQUE)->setEnabled(false);
517 torqueTimer.setInterval(50);
518 torqueTimer.setSingleShot(false);
519 connect(&torqueTimer,SIGNAL(timeout()),this,SLOT(onTorqueTimer()));
520
521 // Enable only the modes that are supported by the joint, hiding the others from the user
522 // This works only if the order of the items in the combo box is the same as the order of the enum,
523 // which is currently true and guaranteed by construction, but it is something to keep in mind if we
524 // decide to change the order of the items in the combo box in the future.
525 int ccount = ui->comboMode->count();
526 for (int i = 0; i < ccount; ++i)
527 {
529 bool mode_enabled = (std::find(modes.begin(), modes.end(), cme) != modes.end());
530 if (mode_enabled)
531 {
532 QListView* listView = qobject_cast<QListView*>(ui->comboMode->view());
533 if (listView) {listView->setRowHidden(i, false);}
534 }
535 else
536 {
537 QListView* listView = qobject_cast<QListView*>(ui->comboMode->view());
538 if (listView) {listView->setRowHidden(i, true);}
539 }
540 }
541}
542
543bool JointItem::eventFilter(QObject *obj, QEvent *event)
544{
545 if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
546 auto* keyEvent = static_cast<QKeyEvent *>(event);
547 int key = keyEvent->key();
548 if(key == Qt::Key_Left || key == Qt::Key_Right || key == Qt::Key_Up ||
549 key == Qt::Key_Down || key == Qt::Key_PageUp || key == Qt::Key_PageDown){
550
551 //SliderWithTarget *slider=0;
552 QSlider* slider = nullptr;
553
554 if(obj == ui->sliderPosTrajectory_Position){
555 slider = ui->sliderPosTrajectory_Position;
556 if(keyEvent->type() == QEvent::KeyPress){
557 onSliderPosTrajectory_PositionPressed();
558 }
559 if(keyEvent->type() == QEvent::KeyRelease){
560 onSliderPosTrajectory_PositionReleased();
561 }
562 }
563 if(obj == ui->sliderPosTrajectory_Velocity){
564 slider = ui->sliderPosTrajectory_Velocity;
565 if (keyEvent->type() == QEvent::KeyPress){
566 onSliderPosTrajectory_VelocityPressed();
567 }
568 if (keyEvent->type() == QEvent::KeyRelease){
569 onSliderPosTrajectory_VelocityReleased();
570 }
571 }
572 if(obj == ui->sliderDirectPosition){
573 slider = ui->sliderDirectPosition;
574 if(keyEvent->type() == QEvent::KeyPress){
575 onSliderDirectPositionPressed();
576 }
577 if(keyEvent->type() == QEvent::KeyRelease){
578 onSliderDirectPositionReleased();
579 }
580 }
581 if(obj == ui->sliderMixedPosition){
582 slider = ui->sliderMixedPosition;
583 if(keyEvent->type() == QEvent::KeyPress){
584 onSliderMixedPositionPressed();
585 }
586 if(keyEvent->type() == QEvent::KeyRelease){
587 onSliderMixedPositionReleased();
588 }
589 }
590 if(obj == ui->sliderMixedVelocity){
591 slider = ui->sliderMixedVelocity;
592 }
593 if(obj == ui->sliderTorqueTorque){
594 slider = ui->sliderTorqueTorque;
595 if(keyEvent->type() == QEvent::KeyPress){
596 onSliderTorquePressed();
597 }
598 if(keyEvent->type() == QEvent::KeyRelease){
599 onSliderTorqueReleased();
600 }
601 }
602 if (obj == ui->sliderPWMOutput){
603 slider = ui->sliderPWMOutput;
604 if(keyEvent->type() == QEvent::KeyPress){
605 onSliderPWMPressed();
606 }
607 if(keyEvent->type() == QEvent::KeyRelease){
608 onSliderPWMReleased();
609 }
610 }
611 if (obj == ui->sliderCurrentOutput){
612 slider = ui->sliderCurrentOutput;
613 if (keyEvent->type() == QEvent::KeyPress){
614 onSliderCurrentPressed();
615 }
616 if (keyEvent->type() == QEvent::KeyRelease){
617 onSliderCurrentReleased();
618 }
619 }
620 if(obj == ui->sliderVelTrajectory_Velocity){
621 slider = ui->sliderVelTrajectory_Velocity;
622 if(keyEvent->type() == QEvent::KeyPress){
623 onSliderVelTrajectory_VelocityPressed();
624 }
625 if(keyEvent->type() == QEvent::KeyRelease){
626 onSliderVelTrajectory_VelocityReleased();
627 }
628 }
629 if(obj == ui->sliderVelTrajectory_Acceleration){
630 slider = ui->sliderVelTrajectory_Acceleration;
631 if(keyEvent->type() == QEvent::KeyPress){
632 onSliderVelTrajectory_AccelerationPressed();
633 }
634 if(keyEvent->type() == QEvent::KeyRelease){
635 onSliderVelTrajectory_AccelerationPressed();
636 }
637 }
638
639 if (slider == nullptr) {
640 return false;
641 }
642
643
644 if(keyEvent->type() == QEvent::KeyPress){
645 if(key == Qt::Key_Left || key == Qt::Key_Down){
646 slider->setValue(slider->value() - 1);
647 }
648 if(key == Qt::Key_Right || key == Qt::Key_Up){
649 slider->setValue(slider->value() + 1);
650 }
651 if(key == Qt::Key_PageUp){
652 slider->setValue(slider->value() + 10);
653 }
654 if(key == Qt::Key_PageDown){
655 slider->setValue(slider->value() - 10);
656 }
657 }
658
659
660 return true;
661 }
662 return QObject::eventFilter(obj, event);
663
664 } else {
665 // standard event processing
666 return QObject::eventFilter(obj, event);
667 }
668}
669
671{
672 velocityModeEnabled = control;
673 ui->stackedWidget->widget(VELOCITY)->setEnabled(velocityModeEnabled);
674 if(ui->stackedWidget->currentIndex() == VELOCITY && velocityModeEnabled){
675 velocityTimer.start();
676 }
677}
678
680{
681 velocityDirectModeEnabled = control;
682 ui->stackedWidget->widget(VELOCITY_DIR)->setEnabled(velocityDirectModeEnabled);
683 if(ui->stackedWidget->currentIndex() == VELOCITY_DIR && velocityDirectModeEnabled){
684 velocityDirectTimer.start();
685 }
686}
687
689{
690 ui->stackedWidget->widget(MIXED)->setEnabled(control);
691}
692
694{
695 ui->stackedWidget->widget(POSITION_DIR)->setEnabled(control);
696}
697
699{
700 pwmModeEnabled = control;
701 ui->stackedWidget->widget(PWM)->setEnabled(pwmModeEnabled);
702 if(ui->stackedWidget->currentIndex() == PWM && pwmModeEnabled)
703 {
704 pwmTimer.start();
705 }
706}
707
709{
710 currentModeEnabled = control;
711 ui->stackedWidget->widget(CURRENT)->setEnabled(currentModeEnabled);
712 if(ui->stackedWidget->currentIndex() == CURRENT && currentModeEnabled)
713 {
714 currentTimer.start();
715 }
716}
717
719{
720 torqueModeEnabled = control;
721 ui->stackedWidget->widget(TORQUE)->setEnabled(torqueModeEnabled);
722 if(ui->stackedWidget->currentIndex() == TORQUE && torqueModeEnabled)
723 {
724 torqueTimer.start();
725 }
726}
727
729{
730 ui->sliderPosTrajectory_Position->enableViewTargetBox = visible;
731 ui->sliderMixedPosition->enableViewTargetBox = visible;
732}
733
735{
736 ui->sliderPosTrajectory_Position->enableViewTargetValue = visible;
737 ui->sliderMixedPosition->enableViewTargetValue = visible;
738}
739
741{
742 QString pos_metric_revolute("deg");
743 QString trq_metric_revolute("Nm");
744 QString trq_metric_revolute_title("Torque:");
745 QString vel_metric_revolute("deg/s");
746 QString pos_metric_prism("m");
747 QString trq_metric_prism("N");
748 QString trq_metric_prism_title("Force:");
749 QString vel_metric_prism("m/s");
750
752 {
753 ui->labelIdlevelUnits->setText(vel_metric_revolute);
754 ui->labelPositionvelUnits->setText(vel_metric_revolute);
755 ui->labelPositionDirvelUnits->setText(vel_metric_revolute);
756 ui->labelMixedvelUnits->setText(vel_metric_revolute);
757 ui->labelTorquevelUnits->setText(vel_metric_revolute);
758 ui->labelPWMvelUnits->setText(vel_metric_revolute);
759 ui->labelCurrentvelUnits->setText(vel_metric_revolute);
760 ui->labelVelocityvelUnits->setText(vel_metric_revolute);
761 ui->labelVelocityDirvelUnits->setText(vel_metric_revolute);
762
763 ui->labelIdleTorque->setText(trq_metric_revolute_title);
764 ui->labelPositionTorque->setText(trq_metric_revolute_title);
765 ui->labelPositionDirTorque->setText(trq_metric_revolute_title);
766 ui->labelMixedTorque->setText(trq_metric_revolute_title);
767 ui->labelTorqueTorque->setText(trq_metric_revolute_title);
768 ui->labelPWMTorque->setText(trq_metric_revolute_title);
769 ui->labelCurrentTorque->setText(trq_metric_revolute_title);
770 ui->labelVelocityTorque->setText(trq_metric_revolute_title);
771 ui->labelVelocityDirTorque->setText(trq_metric_revolute_title);
772
773 ui->labelIdleposUnits->setText(pos_metric_revolute);
774 ui->labelPositionposUnits->setText(pos_metric_revolute);
775 ui->labelPositionDirposUnits->setText(pos_metric_revolute);
776 ui->labelMixedposUnits->setText(pos_metric_revolute);
777 ui->labelTorqueposUnits->setText(pos_metric_revolute);
778 ui->labelPWMposUnits->setText(pos_metric_revolute);
779 ui->labelCurrentposUnits->setText(pos_metric_revolute);
780 ui->labelVelocityposUnits->setText(pos_metric_revolute);
781 ui->labelVelocityDirposUnits->setText(pos_metric_revolute);
782 ui->labelFaultposUnits->setText(pos_metric_revolute);
783
784 //ui->labelIdleMotorPosUnits->setText(pos_metric_revolute);
785 //ui->labelFaultMotorPosUnits->setText(pos_metric_revolute);
786
787 ui->labelIdletrqUnits->setText(trq_metric_revolute);
788 ui->labelPositiontrqUnits->setText(trq_metric_revolute);
789 ui->labelPositionDirtrqUnits->setText(trq_metric_revolute);
790 ui->labelMixedtrqUnits->setText(trq_metric_revolute);
791 ui->labelTorquetrqUnits->setText(trq_metric_revolute);
792 ui->labelPWMtrqUnits->setText(trq_metric_revolute);
793 ui->labelCurrenttrqUnits->setText(pos_metric_revolute);
794 ui->labelVelocitytrqUnits->setText(trq_metric_revolute);
795 ui->labelVelocityDirtrqUnits->setText(trq_metric_revolute);
796 }
798 {
799 ui->labelIdlevelUnits->setText(vel_metric_prism);
800 ui->labelPositionvelUnits->setText(vel_metric_prism);
801 ui->labelPositionDirvelUnits->setText(vel_metric_prism);
802 ui->labelMixedvelUnits->setText(vel_metric_prism);
803 ui->labelTorquevelUnits->setText(vel_metric_prism);
804 ui->labelPWMvelUnits->setText(vel_metric_prism);
805 ui->labelCurrentvelUnits->setText(vel_metric_prism);
806 ui->labelVelocityvelUnits->setText(vel_metric_prism);
807 ui->labelVelocityDirvelUnits->setText(vel_metric_prism);
808
809 ui->labelIdleTorque->setText(trq_metric_prism_title);
810 ui->labelPositionTorque->setText(trq_metric_prism_title);
811 ui->labelPositionDirTorque->setText(trq_metric_prism_title);
812 ui->labelMixedTorque->setText(trq_metric_prism_title);
813 ui->labelTorqueTorque->setText(trq_metric_prism_title);
814 ui->labelPWMTorque->setText(trq_metric_prism_title);
815 ui->labelCurrentTorque->setText(trq_metric_prism_title);
816 ui->labelVelocityTorque->setText(trq_metric_prism_title);
817 ui->labelVelocityDirTorque->setText(vel_metric_prism);
818
819 ui->labelIdleposUnits->setText(pos_metric_prism);
820 ui->labelPositionposUnits->setText(pos_metric_prism);
821 ui->labelPositionDirposUnits->setText(pos_metric_prism);
822 ui->labelMixedposUnits->setText(pos_metric_prism);
823 ui->labelTorqueposUnits->setText(pos_metric_prism);
824 ui->labelPWMposUnits->setText(pos_metric_prism);
825 ui->labelCurrentposUnits->setText(pos_metric_prism);
826 ui->labelVelocityposUnits->setText(pos_metric_prism);
827 ui->labelVelocityDirposUnits->setText(pos_metric_prism);
828 ui->labelFaultposUnits->setText(pos_metric_prism);
829
830 //ui->labelIdleMotorPosUnits->setText(pos_metric_prism);
831 //ui->labelFaultMotorPosUnits->setText(pos_metric_prism);
832
833 ui->labelIdletrqUnits->setText(trq_metric_prism);
834 ui->labelPositiontrqUnits->setText(trq_metric_prism);
835 ui->labelPositionDirtrqUnits->setText(trq_metric_prism);
836 ui->labelMixedtrqUnits->setText(trq_metric_prism);
837 ui->labelTorquetrqUnits->setText(trq_metric_prism);
838 ui->labelPWMtrqUnits->setText(trq_metric_prism);
839 ui->labelCurrenttrqUnits->setText(trq_metric_prism);
840 ui->labelVelocitytrqUnits->setText(trq_metric_prism);
841 ui->labelVelocityDirtrqUnits->setText(trq_metric_prism);
842 }
843 else
844 {
845 yFatal("Unspecified joint type");
846 }
847}
848
850{
851 joint_motorPositionVisible = visible;
852 ui->editIdleMotorPos->setVisible(visible);
853 ui->editPositionMotorPos->setVisible(visible);
854 ui->editPositionDirMotorPos->setVisible(visible);
855 ui->editMixedMotorPos->setVisible(visible);
856 ui->editTorqueMotorPos->setVisible(visible);
857 ui->editPWMMotorPos->setVisible(visible);
858 ui->editCurrentMotorPos->setVisible(visible);
859 ui->editVelocityMotorPos->setVisible(visible);
860 ui->editVelocityDirMotorPos->setVisible(visible);
861 ui->editFaultMotorPos->setVisible(visible);
862
863 ui->labelIdleMotorPos->setVisible(visible);
864 ui->labelPositionMotorPos->setVisible(visible);
865 ui->labelPositionDirMotorPos->setVisible(visible);
866 ui->labelMixedMotorPos->setVisible(visible);
867 ui->labelTorqueMotorPos->setVisible(visible);
868 ui->labelPWMMotorPos->setVisible(visible);
869 ui->labelCurrentMotorPos->setVisible(visible);
870 ui->labelVelocityMotorPos->setVisible(visible);
871 ui->labelVelocityDirMotorPos->setVisible(visible);
872 ui->labelFaultMotorPos->setVisible(visible);
873
874 ui->labelIdleMotorPosUnits->setVisible(visible);
875 ui->labelPositionMotorPosUnits->setVisible(visible);
876 ui->labelPositionDirMotorPosUnits->setVisible(visible);
877 ui->labelMixedMotorPosUnits->setVisible(visible);
878 ui->labelTorqueMotorPosUnits->setVisible(visible);
879 ui->labelPWMMotorPosUnits->setVisible(visible);
880 ui->labelCurrentMotorPosUnits->setVisible(visible);
881 ui->labelVelocityMotorPosUnits->setVisible(visible);
882 ui->labelVelocityDirMotorPosUnits->setVisible(visible);
883 ui->labelFaultMotorPosUnits->setVisible(visible);
884
885 if (!visible) {
886 ui->editIdleMotorPos->setMinimumHeight(0);
887 ui->editPositionMotorPos->setMinimumHeight(0);
888 ui->editPositionDirMotorPos->setMinimumHeight(0);
889 ui->editMixedMotorPos->setMinimumHeight(0);
890 ui->editTorqueMotorPos->setMinimumHeight(0);
891 ui->editPWMMotorPos->setMinimumHeight(0);
892 ui->editCurrentMotorPos->setMinimumHeight(0);
893 ui->editVelocityMotorPos->setMinimumHeight(0);
894 ui->editVelocityDirMotorPos->setMinimumHeight(0);
895 ui->editFaultMotorPos->setMinimumHeight(0);
896
897 ui->labelPositionMotorPos->setMinimumHeight(0);
898 ui->labelPositionMotorPosUnits->setMinimumHeight(0);
899 ui->labelPositionDirMotorPos->setMinimumHeight(0);
900 ui->labelPositionDirMotorPosUnits->setMinimumHeight(0);
901 ui->labelMixedMotorPos->setMinimumHeight(0);
902 ui->labelMixedMotorPosUnits->setMinimumHeight(0);
903 ui->labelTorqueMotorPos->setMinimumHeight(0);
904 ui->labelTorqueMotorPosUnits->setMinimumHeight(0);
905 ui->labelPWMMotorPos->setMinimumHeight(0);
906 ui->labelPWMMotorPosUnits->setMinimumHeight(0);
907 ui->labelCurrentMotorPos->setMinimumHeight(0);
908 ui->labelCurrentMotorPosUnits->setMinimumHeight(0);
909 ui->labelVelocityMotorPos->setMinimumHeight(0);
910 ui->labelVelocityMotorPosUnits->setMinimumHeight(0);
911 ui->labelVelocityDirMotorPos->setMinimumHeight(0);
912 ui->labelVelocityDirMotorPosUnits->setMinimumHeight(0);
913 ui->labelIdleMotorPos->setMinimumHeight(0);
914 ui->labelIdleMotorPosUnits->setMinimumHeight(0);
915 ui->labelFaultMotorPos->setMinimumHeight(0);
916 ui->labelFaultMotorPosUnits->setMinimumHeight(0);
917 }
918 else {
919 ui->editIdleMotorPos->setMinimumHeight(20);
920 ui->editPositionMotorPos->setMinimumHeight(20);
921 ui->editPositionDirMotorPos->setMinimumHeight(20);
922 ui->editMixedMotorPos->setMinimumHeight(20);
923 ui->editTorqueMotorPos->setMinimumHeight(20);
924 ui->editPWMMotorPos->setMinimumHeight(20);
925 ui->editCurrentMotorPos->setMinimumHeight(20);
926 ui->editVelocityMotorPos->setMinimumHeight(20);
927 ui->editVelocityDirMotorPos->setMinimumHeight(20);
928 ui->editFaultMotorPos->setMinimumHeight(20);
929
930 ui->labelPositionMotorPos->setMinimumHeight(20);
931 ui->labelPositionMotorPosUnits->setMinimumHeight(20);
932 ui->labelPositionDirMotorPos->setMinimumHeight(20);
933 ui->labelPositionDirMotorPosUnits->setMinimumHeight(20);
934 ui->labelMixedMotorPos->setMinimumHeight(20);
935 ui->labelMixedMotorPosUnits->setMinimumHeight(20);
936 ui->labelTorqueMotorPos->setMinimumHeight(20);
937 ui->labelTorqueMotorPosUnits->setMinimumHeight(20);
938 ui->labelPWMMotorPos->setMinimumHeight(20);
939 ui->labelPWMMotorPosUnits->setMinimumHeight(20);
940 ui->labelCurrentMotorPos->setMinimumHeight(20);
941 ui->labelCurrentMotorPosUnits->setMinimumHeight(20);
942 ui->labelVelocityMotorPos->setMinimumHeight(20);
943 ui->labelVelocityMotorPosUnits->setMinimumHeight(20);
944 ui->labelVelocityDirMotorPos->setMinimumHeight(20);
945 ui->labelVelocityDirMotorPosUnits->setMinimumHeight(20);
946 ui->labelIdleMotorPos->setMinimumHeight(20);
947 ui->labelIdleMotorPosUnits->setMinimumHeight(20);
948 ui->labelFaultMotorPos->setMinimumHeight(20);
949 ui->labelFaultMotorPosUnits->setMinimumHeight(20);
950 }
951}
952
954{
955 joint_dutyVisible = visible;
956 //ui->editIdleDuty->setVisible(visible);
957 //ui->editPositionDuty->setVisible(visible);
958 //ui->editPositionDirDuty->setVisible(visible);
959 // ui->editMixedDuty->setVisible(visible);
960 ui->editTorqueDuty->setVisible(visible);
961 ui->editCurrentDuty->setVisible(visible);
962 //ui->editPWMDuty->setVisible(visible);
963 //ui->editDutyDuty->setVisible(visible);
964 //ui->editVelocityDuty->setVisible(visible);
965
966 //ui->labelIdleDuty->setVisible(visible);
967 //ui->labelIdleDutyUnits->setVisible(visible);
968 //ui->labelPositionDuty->setVisible(visible);
969 //ui->labelPositionDutyUnits->setVisible(visible);
970 //ui->labelPositionDirDuty->setVisible(visible);
971 //ui->labelPositionDirDutyUnits->setVisible(visible);
972 //ui->labelMixedDuty->setVisible(visible);
973 //ui->labelMixedDutyUnits->setVisible(visible);
974 ui->labelTorqueDuty->setVisible(visible);
975 ui->labelTorqueDutyUnits->setVisible(visible);
976 //ui->labelPWMDuty->setVisible(visible);
977 ui->labelCurrentDuty->setVisible(visible);
978 //ui->labelPWMDutyUnits->setVisible(visible);
979 ui->labelCurrentDutyUnits->setVisible(visible);
980 //ui->labelVelocityDuty->setVisible(visible);
981 //ui->labelVelocityDutyUnits->setVisible(visible);
982
983
984 if (!visible) {
985 //ui->editIdleDuty->setMinimumHeight(0);
986 //ui->editPositionDuty->setMinimumHeight(0);
987 //ui->editPositionDirDuty->setMinimumHeight(0);
988 //ui->editMixedDuty->setMinimumHeight(0);
989 //ui->editTorqueDuty->setMinimumHeight(0);
990 //ui->editPWMDuty->setMinimumHeight(0);
991 //ui->editDutyDuty->setMinimumHeight(0);
992 //ui->editVelocityDuty->setMinimumHeight(0);
993
994 //ui->labelPositionDuty->setMinimumHeight(0);
995 //ui->labelPositionDutyUnits->setMinimumHeight(0);
996 //ui->labelPositionDirDuty->setMinimumHeight(0);
997 //ui->labelPositionDirDutyUnits->setMinimumHeight(0);
998 //ui->labelMixedDuty->setMinimumHeight(0);
999 //ui->labelMixedDutyUnits->setMinimumHeight(0);
1000 ui->labelTorqueDuty->setMinimumHeight(0);
1001 ui->labelTorqueDutyUnits->setMinimumHeight(0);
1002 //ui->labelPWMDuty->setMinimumHeight(0);
1003 //ui->labelPWMDutyUnits->setMinimumHeight(0);
1004 ui->labelCurrentDuty->setMinimumHeight(0);
1005 ui->labelCurrentDutyUnits->setMinimumHeight(0);
1006 //ui->labelVelocityDuty->setMinimumHeight(0);
1007 //ui->labelVelocityDutyUnits->setMinimumHeight(0);
1008 //ui->labelIdleDuty->setMinimumHeight(0);
1009 //ui->labelIdleDutyUnits->setMinimumHeight(0);
1010 }
1011 else {
1012 //ui->editIdleDuty->setMinimumHeight(20);
1013 //ui->editPositionDuty->setMinimumHeight(20);
1014 //ui->editPositionDirDuty->setMinimumHeight(20);
1015 //ui->editMixedDuty->setMinimumHeight(20);
1016 ui->editTorqueDuty->setMinimumHeight(20);
1017 //ui->editPWMDuty->setMinimumHeight(20);
1018 ui->editCurrentDuty->setMinimumHeight(20);
1019 //ui->editVelocityDuty->setMinimumHeight(20);
1020
1021 //ui->labelPositionDuty->setMinimumHeight(20);
1022 //ui->labelPositionDutyUnits->setMinimumHeight(20);
1023 //ui->labelPositionDirDuty->setMinimumHeight(20);
1024 //ui->labelPositionDirDutyUnits->setMinimumHeight(20);
1025 //ui->labelMixedDuty->setMinimumHeight(20);
1026 //ui->labelMixedDutyUnits->setMinimumHeight(20);
1027 ui->labelTorqueDuty->setMinimumHeight(20);
1028 ui->labelTorqueDutyUnits->setMinimumHeight(20);
1029 //ui->labelPWMDuty->setMinimumHeight(20);
1030 //ui->labelPWMDutyUnits->setMinimumHeight(20);
1031 ui->labelCurrentDuty->setMinimumHeight(20);
1032 ui->labelCurrentDutyUnits->setMinimumHeight(20);
1033 //ui->labelVelocityDuty->setMinimumHeight(20);
1034 //ui->labelVelocityDutyUnits->setMinimumHeight(20);
1035 //ui->labelIdleDuty->setMinimumHeight(20);
1036 //ui->labelIdleDutyUnits->setMinimumHeight(20);
1037 }
1038}
1039
1041{
1042 joint_currentVisible = visible;
1043 ui->editIdleCurrent->setVisible(visible);
1044 ui->editPositionCurrent->setVisible(visible);
1045 ui->editPositionDirCurrent->setVisible(visible);
1046 ui->editMixedCurrent->setVisible(visible);
1047 ui->editTorqueCurrent->setVisible(visible);
1048 ui->editPWMCurrent->setVisible(visible);
1049 //ui->editCurrentCurrent->setVisible(visible);
1050 ui->editVelocityCurrent->setVisible(visible);
1051 ui->editVelocityDirCurrent->setVisible(visible);
1052
1053 ui->labelIdleCurrent->setVisible(visible);
1054 ui->labelIdleCurrentUnits->setVisible(visible);
1055 ui->labelPositionCurrent->setVisible(visible);
1056 ui->labelPositionCurrentUnits->setVisible(visible);
1057 ui->labelPositionDirCurrent->setVisible(visible);
1058 ui->labelPositionDirCurrentUnits->setVisible(visible);
1059 ui->labelMixedCurrent->setVisible(visible);
1060 ui->labelMixedCurrentUnits->setVisible(visible);
1061 ui->labelTorqueCurrent->setVisible(visible);
1062 ui->labelTorqueCurrentUnits->setVisible(visible);
1063 ui->labelPWMCurrent->setVisible(visible);
1064 //ui->labelCurrentCurrent->setVisible(visible);
1065 ui->labelPWMCurrentUnits->setVisible(visible);
1066 //ui->labelCurrentCurrentUnits->setVisible(visible);
1067 ui->labelVelocityCurrent->setVisible(visible);
1068 ui->labelVelocityCurrentUnits->setVisible(visible);
1069 ui->labelVelocityDirCurrent->setVisible(visible);
1070 ui->labelVelocityDirCurrentUnits->setVisible(visible);
1071
1072 if (!visible) {
1073 ui->editIdleCurrent->setMinimumHeight(0);
1074 ui->editPositionCurrent->setMinimumHeight(0);
1075 ui->editPositionDirCurrent->setMinimumHeight(0);
1076 ui->editMixedCurrent->setMinimumHeight(0);
1077 ui->editTorqueCurrent->setMinimumHeight(0);
1078 ui->editPWMCurrent->setMinimumHeight(0);
1079 //ui->editCurrentCurrent->setMinimumHeight(0);
1080 ui->editVelocityCurrent->setMinimumHeight(0);
1081 ui->editVelocityDirCurrent->setMinimumHeight(0);
1082
1083 ui->labelPositionCurrent->setMinimumHeight(0);
1084 ui->labelPositionCurrentUnits->setMinimumHeight(0);
1085 ui->labelPositionDirCurrent->setMinimumHeight(0);
1086 ui->labelPositionDirCurrentUnits->setMinimumHeight(0);
1087 ui->labelMixedCurrent->setMinimumHeight(0);
1088 ui->labelMixedCurrentUnits->setMinimumHeight(0);
1089 ui->labelTorqueCurrent->setMinimumHeight(0);
1090 ui->labelTorqueCurrentUnits->setMinimumHeight(0);
1091 ui->labelPWMCurrent->setMinimumHeight(0);
1092 ui->labelPWMCurrentUnits->setMinimumHeight(0);
1093 //ui->labelCurrentCurrent->setMinimumHeight(0);
1094 //ui->labelCurrentCurrentUnits->setMinimumHeight(0);
1095 ui->labelVelocityCurrent->setMinimumHeight(0);
1096 ui->labelVelocityCurrentUnits->setMinimumHeight(0);
1097 ui->labelVelocityDirCurrent->setMinimumHeight(0);
1098 ui->labelVelocityDirCurrentUnits->setMinimumHeight(0);
1099 ui->labelIdleCurrent->setMinimumHeight(0);
1100 ui->labelIdleCurrentUnits->setMinimumHeight(0);
1101 }
1102 else {
1103 ui->editIdleCurrent->setMinimumHeight(20);
1104 ui->editPositionCurrent->setMinimumHeight(20);
1105 ui->editPositionDirCurrent->setMinimumHeight(20);
1106 ui->editMixedCurrent->setMinimumHeight(20);
1107 ui->editTorqueCurrent->setMinimumHeight(20);
1108 ui->editPWMCurrent->setMinimumHeight(20);
1109 //ui->editCurrentCurrent->setMinimumHeight(20);
1110 ui->editVelocityCurrent->setMinimumHeight(20);
1111 ui->editVelocityDirCurrent->setMinimumHeight(20);
1112
1113 ui->labelPositionCurrent->setMinimumHeight(20);
1114 ui->labelPositionCurrentUnits->setMinimumHeight(20);
1115 ui->labelPositionDirCurrent->setMinimumHeight(20);
1116 ui->labelPositionDirCurrentUnits->setMinimumHeight(20);
1117 ui->labelMixedCurrent->setMinimumHeight(20);
1118 ui->labelMixedCurrentUnits->setMinimumHeight(20);
1119 ui->labelTorqueCurrent->setMinimumHeight(20);
1120 ui->labelTorqueCurrentUnits->setMinimumHeight(20);
1121 ui->labelPWMCurrent->setMinimumHeight(20);
1122 ui->labelPWMCurrentUnits->setMinimumHeight(20);
1123 //ui->labelCurrentCurrent->setMinimumHeight(20);
1124 //ui->labelCurrentCurrentUnits->setMinimumHeight(20);
1125 ui->labelVelocityCurrent->setMinimumHeight(20);
1126 ui->labelVelocityCurrentUnits->setMinimumHeight(20);
1127 ui->labelVelocityDirCurrent->setMinimumHeight(20);
1128 ui->labelVelocityDirCurrentUnits->setMinimumHeight(20);
1129 ui->labelIdleCurrent->setMinimumHeight(20);
1130 ui->labelIdleCurrentUnits->setMinimumHeight(20);
1131 }
1132}
1133
1135{
1136 joint_speedVisible = visible;
1137 ui->editIdleSpeed->setVisible(visible);
1138 ui->editPositionSpeed->setVisible(visible);
1139 ui->editPositionDirSpeed->setVisible(visible);
1140 ui->editMixedSpeed->setVisible(visible);
1141 ui->editTorqueSpeed->setVisible(visible);
1142 ui->editPWMSpeed->setVisible(visible);
1143 ui->editCurrentSpeed->setVisible(visible);
1144 ui->editVelocitySpeed->setVisible(visible);
1145 ui->editVelocityDirSpeed->setVisible(visible);
1146
1147 ui->labelIdleSpeed->setVisible(visible);
1148 ui->labelIdlevelUnits->setVisible(visible);
1149 ui->labelPositionSpeed->setVisible(visible);
1150 ui->labelPositionvelUnits->setVisible(visible);
1151 ui->labelPositionDirSpeed->setVisible(visible);
1152 ui->labelPositionDirvelUnits->setVisible(visible);
1153 ui->labelMixedSpeed->setVisible(visible);
1154 ui->labelMixedvelUnits->setVisible(visible);
1155 ui->labelTorqueSpeed->setVisible(visible);
1156 ui->labelTorquevelUnits->setVisible(visible);
1157 ui->labelPWMSpeed->setVisible(visible);
1158 ui->labelCurrentSpeed->setVisible(visible);
1159 ui->labelPWMvelUnits->setVisible(visible);
1160 ui->labelCurrentvelUnits->setVisible(visible);
1161 ui->labelVelocitySpeed->setVisible(visible);
1162 ui->labelVelocityDirSpeed->setVisible(visible);
1163 ui->labelVelocityvelUnits->setVisible(visible);
1164 ui->labelVelocityDirvelUnits->setVisible(visible);
1165
1166 if(!visible){
1167 ui->editIdleSpeed->setMinimumHeight(0);
1168 ui->editPositionSpeed->setMinimumHeight(0);
1169 ui->editPositionDirSpeed->setMinimumHeight(0);
1170 ui->editMixedSpeed->setMinimumHeight(0);
1171 ui->editTorqueSpeed->setMinimumHeight(0);
1172 ui->editPWMSpeed->setMinimumHeight(0);
1173 ui->editCurrentSpeed->setMinimumHeight(0);
1174 ui->editVelocitySpeed->setMinimumHeight(0);
1175 ui->editVelocityDirSpeed->setMinimumHeight(0);
1176
1177 ui->labelPositionSpeed->setMinimumHeight(0);
1178 ui->labelPositionvelUnits->setMinimumHeight(0);
1179 ui->labelPositionDirSpeed->setMinimumHeight(0);
1180 ui->labelPositionDirvelUnits->setMinimumHeight(0);
1181 ui->labelMixedSpeed->setMinimumHeight(0);
1182 ui->labelMixedvelUnits->setMinimumHeight(0);
1183 ui->labelTorqueSpeed->setMinimumHeight(0);
1184 ui->labelTorquevelUnits->setMinimumHeight(0);
1185 ui->labelPWMSpeed->setMinimumHeight(0);
1186 ui->labelPWMvelUnits->setMinimumHeight(0);
1187 ui->labelCurrentSpeed->setMinimumHeight(0);
1188 ui->labelCurrentvelUnits->setMinimumHeight(0);
1189 ui->labelVelocitySpeed->setMinimumHeight(0);
1190 ui->labelVelocityvelUnits->setMinimumHeight(0);
1191 ui->labelIdleSpeed->setMinimumHeight(0);
1192 ui->labelIdlevelUnits->setMinimumHeight(0);
1193 }else{
1194 ui->editIdleSpeed->setMinimumHeight(20);
1195 ui->editPositionSpeed->setMinimumHeight(20);
1196 ui->editPositionDirSpeed->setMinimumHeight(20);
1197 ui->editMixedSpeed->setMinimumHeight(20);
1198 ui->editTorqueSpeed->setMinimumHeight(20);
1199 ui->editPWMSpeed->setMinimumHeight(20);
1200 ui->editCurrentSpeed->setMinimumHeight(20);
1201 ui->editVelocitySpeed->setMinimumHeight(20);
1202 ui->editVelocityDirSpeed->setMinimumHeight(20);
1203
1204 ui->labelPositionSpeed->setMinimumHeight(20);
1205 ui->labelPositionvelUnits->setMinimumHeight(20);
1206 ui->labelPositionDirSpeed->setMinimumHeight(20);
1207 ui->labelPositionDirvelUnits->setMinimumHeight(20);
1208 ui->labelMixedSpeed->setMinimumHeight(20);
1209 ui->labelMixedvelUnits->setMinimumHeight(20);
1210 ui->labelTorqueSpeed->setMinimumHeight(20);
1211 ui->labelTorquevelUnits->setMinimumHeight(20);
1212 ui->labelPWMSpeed->setMinimumHeight(20);
1213 ui->labelPWMvelUnits->setMinimumHeight(20);
1214 ui->labelCurrentSpeed->setMinimumHeight(20);
1215 ui->labelCurrentvelUnits->setMinimumHeight(20);
1216 ui->labelVelocitySpeed->setMinimumHeight(20);
1217 ui->labelVelocityDirSpeed->setMinimumHeight(20);
1218 ui->labelVelocityvelUnits->setMinimumHeight(20);
1219 ui->labelVelocityDirvelUnits->setMinimumHeight(20);
1220 ui->labelIdleSpeed->setMinimumHeight(20);
1221 ui->labelIdlevelUnits->setMinimumHeight(20);
1222 }
1223}
1224
1226{
1227 double positionSliderStep = 1 / (fabs(m_min_position - m_max_position) / 100.0);
1228 ui->sliderMixedPosition->setSliderStep(positionSliderStep);
1229 ui->sliderPosTrajectory_Position->setSliderStep(positionSliderStep);
1230 ui->sliderDirectPosition->setSliderStep(positionSliderStep);
1231 ui->sliderMixedPosition->setIsDouble(true);
1232 ui->sliderPosTrajectory_Position->setIsDouble(true);
1233 ui->sliderDirectPosition->setIsDouble(true);
1234 int sliderMin = m_min_position*positionSliderStep;
1235 int sliderMax = m_max_position*positionSliderStep;
1236 ui->sliderMixedPosition->setRange(sliderMin, sliderMax);
1237 ui->sliderPosTrajectory_Position->setRange(sliderMin, sliderMax);
1238 ui->sliderDirectPosition->setRange(sliderMin, sliderMax);
1239 ui->sliderMixedPosition->resetTarget();
1240 ui->sliderPosTrajectory_Position->resetTarget();
1241 ui->sliderDirectPosition->resetTarget();
1242}
1243
1245{
1246 double positionSliderStep = 1 / value;
1247 ui->sliderMixedPosition->setSliderStep(positionSliderStep);
1248 ui->sliderPosTrajectory_Position->setSliderStep(positionSliderStep);
1249 ui->sliderDirectPosition->setSliderStep(positionSliderStep);
1250 ui->sliderMixedPosition->setIsDouble(true);
1251 ui->sliderPosTrajectory_Position->setIsDouble(true);
1252 ui->sliderDirectPosition->setIsDouble(true);
1253 int sliderMin = m_min_position*positionSliderStep;
1254 int sliderMax = m_max_position*positionSliderStep;
1255 ui->sliderMixedPosition->setRange(sliderMin, sliderMax);
1256 ui->sliderPosTrajectory_Position->setRange(sliderMin, sliderMax);
1257 ui->sliderDirectPosition->setRange(sliderMin, sliderMax);
1258 ui->sliderMixedPosition->resetTarget();
1259 ui->sliderPosTrajectory_Position->resetTarget();
1260 ui->sliderDirectPosition->resetTarget();
1261}
1262
1264{
1265 if (fabs(m_max_position - m_min_position) < 1.0)
1266 {
1267 yError("Unable to set integer position slider");
1268 return;
1269 }
1270 double positionSliderStep = 1;
1271 ui->sliderMixedPosition->setSliderStep(positionSliderStep);
1272 ui->sliderPosTrajectory_Position->setSliderStep(positionSliderStep);
1273 ui->sliderDirectPosition->setSliderStep(positionSliderStep);
1274 ui->sliderMixedPosition->setIsDouble(false);
1275 ui->sliderPosTrajectory_Position->setIsDouble(false);
1276 ui->sliderDirectPosition->setIsDouble(false);
1277 int sliderMin = m_min_position;
1278 int sliderMax = m_max_position;
1279 ui->sliderMixedPosition->setRange(sliderMin, sliderMax);
1280 ui->sliderPosTrajectory_Position->setRange(sliderMin, sliderMax);
1281 ui->sliderDirectPosition->setRange(sliderMin, sliderMax);
1282 ui->sliderMixedPosition->resetTarget();
1283 ui->sliderPosTrajectory_Position->resetTarget();
1284 ui->sliderDirectPosition->resetTarget();
1285}
1286
1288{
1289 double velocitySliderStep = 1 / (fabs(-m_max_velocity - m_max_velocity) / 100.0); //note that we are using -max_velocity
1290 ui->sliderPosTrajectory_Velocity->setSliderStep(velocitySliderStep);
1291 ui->sliderPosTrajectory_Velocity->setIsDouble(true);
1292 ui->sliderVelTrajectory_Velocity->setSliderStep(velocitySliderStep);
1293 ui->sliderVelTrajectory_Velocity->setIsDouble(true);
1294 int sliderMin = -m_max_velocity*velocitySliderStep;
1295 int sliderMax = m_max_velocity*velocitySliderStep;
1296 ui->sliderPosTrajectory_Velocity->setRange(0, sliderMax);
1297 ui->sliderVelTrajectory_Velocity->setRange(sliderMin, sliderMax);
1298 int v = ui->sliderVelTrajectory_Velocity->value();
1299 if (v > sliderMax) {}
1300 if (v < sliderMin) {}
1302}
1303
1305{
1306 double velocitySliderStep = 1 / value;
1307 ui->sliderPosTrajectory_Velocity->setSliderStep(velocitySliderStep);
1308 ui->sliderPosTrajectory_Velocity->setIsDouble(true);
1309 ui->sliderVelTrajectory_Velocity->setSliderStep(velocitySliderStep);
1310 ui->sliderVelTrajectory_Velocity->setIsDouble(true);
1311 int sliderMin = -m_max_velocity*velocitySliderStep;
1312 int sliderMax = m_max_velocity*velocitySliderStep;
1313 ui->sliderPosTrajectory_Velocity->setRange(0, sliderMax);
1314 ui->sliderVelTrajectory_Velocity->setRange(sliderMin, sliderMax);
1315 int v = ui->sliderVelTrajectory_Velocity->value();
1316 if (v > sliderMax) {}
1317 if (v < sliderMin) {}
1319}
1320
1322{
1323 if (fabs(m_max_velocity) < 1.0)
1324 {
1325 yError("Unable to set integer velocity slider");
1326 return;
1327 }
1328 double velocitySliderStep = 1;
1329 ui->sliderPosTrajectory_Velocity->setSliderStep(velocitySliderStep);
1330 ui->sliderPosTrajectory_Velocity->setIsDouble(false);
1331 ui->sliderVelTrajectory_Velocity->setSliderStep(velocitySliderStep);
1332 ui->sliderVelTrajectory_Velocity->setIsDouble(false);
1333 int sliderMin = -m_max_velocity;
1334 int sliderMax = m_max_velocity;
1335 ui->sliderPosTrajectory_Velocity->setRange(0, sliderMax);
1336 ui->sliderVelTrajectory_Velocity->setRange(sliderMin, sliderMax);
1337 int v = ui->sliderVelTrajectory_Velocity->value();
1338 if (v > sliderMax) {}
1339 if (v < sliderMin) {}
1341}
1342
1344{
1345 double accelerationSliderStep = 1 / (fabs(-m_max_acceleration - m_max_acceleration) / 100.0); //note that we are using -max_velocity
1346 ui->sliderVelTrajectory_Acceleration->setSliderStep(accelerationSliderStep);
1347 ui->sliderVelTrajectory_Acceleration->setIsDouble(true);
1348 int sliderMin = 0;
1349 int sliderMax = m_max_acceleration*accelerationSliderStep;
1350 ui->sliderVelTrajectory_Acceleration->setRange(sliderMin, sliderMax);
1351 int v = ui->sliderVelTrajectory_Acceleration->value();
1352 if (v > sliderMax) {}
1353 if (v < sliderMin) {}
1354 setVelTrajectory_ReferenceAcceleration(m_ref_VelTrajectory_acceleration);
1355}
1356
1358{
1359 double accelerationSliderStep = 1 / value;
1360 ui->sliderVelTrajectory_Acceleration->setSliderStep(accelerationSliderStep);
1361 ui->sliderVelTrajectory_Acceleration->setIsDouble(true);
1362 int sliderMin = 0;
1363 int sliderMax = m_max_acceleration*accelerationSliderStep;
1364 ui->sliderVelTrajectory_Acceleration->setRange(0, sliderMax);
1365 int v = ui->sliderVelTrajectory_Acceleration->value();
1366 if (v > sliderMax) {}
1367 if (v < sliderMin) {}
1368 setVelTrajectory_ReferenceAcceleration(m_ref_VelTrajectory_acceleration);
1369}
1370
1372{
1373 if (fabs(m_max_acceleration) < 1.0)
1374 {
1375 yError("Unable to set integer acceleration slider");
1376 return;
1377 }
1378 double accelerationSliderStep = 1;
1379 ui->sliderVelTrajectory_Acceleration->setSliderStep(accelerationSliderStep);
1380 ui->sliderVelTrajectory_Acceleration->setIsDouble(false);
1381 int sliderMin = -m_max_acceleration;
1382 int sliderMax = m_max_acceleration;
1383 ui->sliderVelTrajectory_Velocity->setRange(0, sliderMax);
1384 int v = ui->sliderVelTrajectory_Acceleration->value();
1385 if (v > sliderMax) {}
1386 if (v < sliderMin) {}
1387 setVelTrajectory_ReferenceAcceleration(m_ref_VelTrajectory_acceleration);
1388}
1389
1391{
1392 double torqueSliderStep = 1 / (fabs(-m_max_torque - m_max_torque) / 100.0); //note that we are using -max_velocity
1393 ui->sliderTorqueTorque->setSliderStep(torqueSliderStep);
1394 ui->sliderTorqueTorque->setIsDouble(true);
1395 int sliderMin = -m_max_torque*torqueSliderStep; //note that we are using -max_torque
1396 int sliderMax = m_max_torque*torqueSliderStep;
1397 ui->sliderTorqueTorque->setRange(sliderMin, sliderMax);
1398 int v = ui->sliderTorqueTorque->value();
1399 if (v > sliderMax) {}
1400 if (v < sliderMin) {}
1401 setRefTorque(m_ref_torque);
1402}
1403
1405{
1406 double torqueSliderStep = 1 / value;
1407 ui->sliderTorqueTorque->setSliderStep(torqueSliderStep);
1408 ui->sliderTorqueTorque->setIsDouble(true);
1409 int sliderMin = -m_max_torque*torqueSliderStep; //note that we are using -max_torque
1410 int sliderMax = m_max_torque*torqueSliderStep;
1411 ui->sliderTorqueTorque->setRange(sliderMin, sliderMax);
1412 int v = ui->sliderTorqueTorque->value();
1413 if (v > sliderMax) {}
1414 if (v < sliderMin) {}
1415 setRefTorque(m_ref_torque);
1416}
1417
1419{
1420 if (fabs(m_max_torque) < 1.0)
1421 {
1422 yError("Unable to set integer torque slider");
1423 return;
1424 }
1425 double torqueSliderStep = 1;
1426 ui->sliderTorqueTorque->setSliderStep(torqueSliderStep);
1427 ui->sliderTorqueTorque->setIsDouble(false);
1428 int sliderMin = -m_max_torque; //note that we are using -max_torque
1429 int sliderMax = m_max_torque;
1430 ui->sliderTorqueTorque->setRange(sliderMin, sliderMax);
1431 int v = ui->sliderTorqueTorque->value();
1432 if (v > sliderMax) {}
1433 if (v < sliderMin) {}
1434 setRefTorque(m_ref_torque);
1435}
1436
1438{
1439 double currentSliderStep = 1 / (fabs(-m_max_current - m_max_current) / 100.0); //note that we are using -max_velocity
1440 ui->sliderCurrentOutput->setSliderStep(currentSliderStep);
1441 ui->sliderCurrentOutput->setIsDouble(true);
1442 int sliderMin = -m_max_current*currentSliderStep; //note that we are using -max_current
1443 int sliderMax = m_max_current*currentSliderStep;
1444 ui->sliderCurrentOutput->setRange(sliderMin, sliderMax);
1445 int v = ui->sliderCurrentOutput->value();
1446 if (v > sliderMax) {}
1447 if (v < sliderMin) {}
1448 setRefCurrent(m_ref_current);
1449}
1450
1452{
1453 double currentSliderStep = 1 / value;
1454 ui->sliderCurrentOutput->setSliderStep(currentSliderStep);
1455 ui->sliderCurrentOutput->setIsDouble(true);
1456 int sliderMin = -m_max_current*currentSliderStep; //note that we are using -max_current
1457 int sliderMax = m_max_current*currentSliderStep;
1458 ui->sliderCurrentOutput->setRange(sliderMin, sliderMax);
1459 int v = ui->sliderCurrentOutput->value();
1460 if (v > sliderMax) {}
1461 if (v < sliderMin) {}
1462 setRefCurrent(m_ref_current);
1463}
1464
1466{
1467 if (fabs(m_max_velocity) < 1.0)
1468 {
1469 yError("Unable to set integer velocity slider");
1470 return;
1471 }
1472 double currentSliderStep = 1;
1473 ui->sliderCurrentOutput->setSliderStep(currentSliderStep);
1474 ui->sliderCurrentOutput->setIsDouble(false);
1475 int sliderMin = -m_max_current; //note that we are using -max_current
1476 int sliderMax = m_max_current;
1477 ui->sliderCurrentOutput->setRange(sliderMin, sliderMax);
1478 int v = ui->sliderCurrentOutput->value();
1479 if (v > sliderMax) {}
1480 if (v < sliderMin) {}
1481 setRefCurrent(m_ref_current);
1482}
1483
1484/* void JointItem::enableTrajectoryVelocitySliderDoubleAuto()
1485{
1486 double trajectoryVelocitySliderStep = 1 / (fabs(0 - m_max_trajectory_velocity) / 100.0); //note that we are using 0
1487 ui->sliderPosTrajectory_Velocity->setSliderStep(trajectoryVelocitySliderStep);
1488 ui->sliderPosTrajectory_Velocity->setIsDouble(true);
1489 int sliderMin = 0 * trajectoryVelocitySliderStep; //note that we are using 0
1490 int sliderMax = m_max_trajectory_velocity*trajectoryVelocitySliderStep;
1491 ui->sliderPosTrajectory_Velocity->setRange(sliderMin, sliderMax);
1492 int v = ui->sliderPosTrajectory_Velocity->value();
1493 if (v > sliderMax) {}
1494 if (v < sliderMin) {}
1495 setPosTrajectory_ReferenceSpeed(ref_trajectory_velocity);
1496}
1497
1498void JointItem::enablePosTrajectoryVelocitySliderDoubleValue(double value)
1499{
1500 double trajectoryVelocitySliderStep = 1 / value;
1501 ui->sliderPosTrajectory_Velocity->setSliderStep(trajectoryVelocitySliderStep);
1502 ui->sliderPosTrajectory_Velocity->setIsDouble(true);
1503 int sliderMin = 0 * trajectoryVelocitySliderStep; //note that we are using 0
1504 int sliderMax = m_max_trajectory_velocity*trajectoryVelocitySliderStep;
1505 ui->sliderPosTrajectory_Velocity->setRange(sliderMin, sliderMax);
1506 int v = ui->sliderPosTrajectory_Velocity->value();
1507 if (v > sliderMax) {}
1508 if (v < sliderMin) {}
1509 setPosTrajectory_ReferenceSpeed(ref_trajectory_velocity);
1510}
1511
1512void JointItem::disableTrajectoryVelocitySliderDouble()
1513{
1514 int sliderMin = 0; //note that we are using 0
1515 int sliderMax = max_trajectory_velocity;
1516 double trajectoryVelocitySliderStep = 1;
1517 ui->sliderPosTrajectory_Velocity->setSliderStep(trajectoryVelocitySliderStep);
1518 ui->sliderPosTrajectory_Velocity->setRange(sliderMin, sliderMax);
1519 ui->sliderPosTrajectory_Velocity->setIsDouble(false);
1520 int v = ui->sliderPosTrajectory_Velocity->value();
1521 if (v > sliderMax) {}
1522 if (v < sliderMin) {}
1523 setPosTrajectory_ReferenceSpeed(m_ref_trajectory_velocity);
1524}
1525*/
1526
1527
1529{
1530 ui->sliderMixedPosition->number_of_decimals=num;
1531 ui->sliderPosTrajectory_Position->number_of_decimals = num;
1532 ui->sliderDirectPosition->number_of_decimals = num;
1533 ui->sliderMixedPosition->number_of_decimals = num;
1534 ui->sliderPosTrajectory_Position->number_of_decimals = num;
1535 ui->sliderDirectPosition->number_of_decimals = num;
1536}
1538{
1539 ui->sliderMixedVelocity->number_of_decimals=num;
1540 ui->sliderPosTrajectory_Velocity->number_of_decimals = num;
1541 ui->sliderVelTrajectory_Velocity->number_of_decimals = num;
1542 ui->sliderVelocityDirectVelocityDirect->number_of_decimals = num;
1543}
1545{
1546 ui->sliderVelTrajectory_Acceleration->number_of_decimals = num;
1547}
1549{
1550 ui->sliderTorqueTorque->number_of_decimals = num;
1551}
1553{
1554 ui->sliderCurrentOutput->number_of_decimals = num;
1555}
1556
1559 bool enable_calib_all)
1560{
1561 Q_UNUSED(debug_param_enabled);
1562 Q_UNUSED(speedview_param_enabled);
1563
1564 enableCalib = enable_calib_all;
1565 if (!enable_calib_all){
1566 ui->buttonCalib->setEnabled(false);
1567 }
1568
1569 connect(ui->stackedWidget, SIGNAL(currentChanged(int)), this, SLOT(onStackedWidgetChanged(int)));
1570}
1571
1573{
1574 disconnect(ui->comboMode,SIGNAL(currentIndexChanged(int)),this,SLOT(onModeChanged(int)));
1575 disconnect(ui->comboInteraction,SIGNAL(currentIndexChanged(int)),this,SLOT(onInteractionChanged(int)));
1576
1577 disconnect(ui->sliderPosTrajectory_Position,SIGNAL(sliderPressed()),this,SLOT(onSliderPosTrajectory_PositionPressed()));
1578 disconnect(ui->sliderPosTrajectory_Position,SIGNAL(sliderReleased()),this,SLOT(onSliderPosTrajectory_PositionReleased()));
1579
1580 disconnect(ui->sliderPosTrajectory_Velocity, SIGNAL(sliderPressed()), this, SLOT(onSliderPosTrajectory_VelocityPressed()));
1581 disconnect(ui->sliderPosTrajectory_Velocity, SIGNAL(sliderReleased()), this, SLOT(onSliderPosTrajectory_VelocityReleased()));
1582
1583 disconnect(ui->sliderVelTrajectory_Velocity,SIGNAL(sliderPressed()),this,SLOT(onSliderVelTrajectory_VelocityPressed()));
1584 disconnect(ui->sliderVelTrajectory_Velocity,SIGNAL(sliderReleased()),this,SLOT(onSliderVelTrajectory_VelocityReleased()));
1585
1586 disconnect(ui->sliderVelTrajectory_Acceleration, SIGNAL(sliderPressed()), this, SLOT(onSliderVelTrajectory_AccelerationPressed()));
1587 disconnect(ui->sliderVelTrajectory_Acceleration, SIGNAL(sliderReleased()), this, SLOT(onSliderVelTrajectory_AccelerationReleased()));
1588
1589 disconnect(ui->sliderTorqueTorque,SIGNAL(sliderPressed()),this,SLOT(onSliderTorquePressed()));
1590 disconnect(ui->sliderTorqueTorque,SIGNAL(sliderReleased()),this,SLOT(onSliderTorqueReleased()));
1591
1592 disconnect(ui->sliderPWMOutput, SIGNAL(sliderPressed()), this, SLOT(onSliderPWMPressed()));
1593 disconnect(ui->sliderPWMOutput, SIGNAL(sliderReleased()), this, SLOT(onSliderPWMReleased()));
1594
1595 disconnect(ui->sliderCurrentOutput, SIGNAL(sliderPressed()), this, SLOT(onSliderCurrentPressed()));
1596 disconnect(ui->sliderCurrentOutput, SIGNAL(sliderReleased()), this, SLOT(onSliderCurrentPressed()));
1597
1598 disconnect(ui->sliderDirectPosition, SIGNAL(sliderPressed()), this, SLOT(onSliderDirectPositionPressed()));
1599 disconnect(ui->sliderDirectPosition, SIGNAL(sliderReleased()), this, SLOT(onSliderDirectPositionReleased()));
1600
1601 disconnect(ui->sliderMixedPosition,SIGNAL(sliderPressed()),this,SLOT(onSliderMixedPositionPressed()));
1602 disconnect(ui->sliderMixedPosition,SIGNAL(sliderReleased()),this,SLOT(onSliderMixedPositionReleased()));
1603
1604 disconnect(ui->sliderMixedVelocity, SIGNAL(sliderPressed()), this, SLOT(onSliderMixedVelocityPressed()));
1605 disconnect(ui->sliderMixedVelocity, SIGNAL(sliderReleased()), this, SLOT(onSliderMixedVelocityReleased()));
1606
1607 disconnect(ui->buttonHome,SIGNAL(clicked()),this,SLOT(onHomeClicked()));
1608 disconnect(ui->buttonIdle,SIGNAL(clicked()),this,SLOT(onIdleClicked()));
1609 disconnect(ui->buttonRun,SIGNAL(clicked()),this,SLOT(onRunClicked()));
1610 disconnect(ui->buttonPid,SIGNAL(clicked()),this,SLOT(onPidClicked()));
1611 disconnect(ui->buttonCalib,SIGNAL(clicked()),this,SLOT(onCalibClicked()));
1612 delete ui;
1613}
1614
1616{
1617 return jointIndex;
1618}
1619
1620void JointItem::installFilter()
1621{
1622 auto* filter = new WheelEventFilter();
1623 filter->setParent(this);
1624 ui->comboMode->installEventFilter(filter);
1625 ui->comboInteraction->installEventFilter(filter);
1626
1627 ui->sliderMixedPosition->installEventFilter(filter);
1628 ui->sliderMixedVelocity->installEventFilter(filter);
1629 ui->sliderDirectPosition->installEventFilter(filter);
1630 ui->sliderPosTrajectory_Position->installEventFilter(filter);
1631 ui->sliderPosTrajectory_Velocity->installEventFilter(filter);
1632 ui->sliderTorqueTorque->installEventFilter(filter);
1633}
1634
1635
1636void JointItem::onStackedWidgetChanged(int index)
1637{
1638 if(index == VELOCITY)
1639 {
1640 if(velocityModeEnabled)
1641 {
1642 velocityTimer.start();
1643 }
1644 }
1645 else if(index == VELOCITY_DIR)
1646 {
1647 if(velocityDirectModeEnabled)
1648 {
1649 velocityDirectTimer.start();
1650 }
1651 }
1652 else if(index == PWM)
1653 {
1654 if(pwmModeEnabled)
1655 {
1656 pwmTimer.start();
1657 }
1658 }
1659 else if(index == CURRENT)
1660 {
1661 if(currentModeEnabled)
1662 {
1663 currentTimer.start();
1664 }
1665 }
1666 else if(index == TORQUE)
1667 {
1668 if(torqueModeEnabled)
1669 {
1670 torqueTimer.start();
1671 }
1672 }
1673 else
1674 {
1675 if(velocityModeEnabled)
1676 {
1677 velocityTimer.stop();
1678 lastVelocity = 0;
1679 updateSliderVelTrajectoryVelocity(0);
1680 }
1681 if(velocityDirectModeEnabled)
1682 {
1683 velocityDirectTimer.stop();
1684 lastVelocityDirect = 0;
1685 updateSliderVelocityDirect(0);
1686 }
1687 if(pwmModeEnabled)
1688 {
1689 pwmTimer.stop();
1690 lastPwm = 0;
1691 updateSliderPWM(0);
1692 }
1693 if(currentModeEnabled)
1694 {
1695 currentTimer.stop();
1696 lastCurrent = 0;
1697 updateSliderCurrent(0);
1698 }
1699 if(torqueModeEnabled)
1700 {
1701 torqueTimer.stop();
1702 lastTorque = 0;
1703 updateSliderTorque(0);
1704 }
1705 }
1706}
1707
1708void JointItem::onModeChanged(int index)
1709{
1710 // Stop all timers, the correct one will be enabled by onStackedWidgetChanged()
1711 velocityTimer.stop();
1712 velocityDirectTimer.stop();
1713 pwmTimer.stop();
1714 currentTimer.stop();
1715 torqueTimer.stop();
1716 Q_UNUSED(index);
1717 int mode = ui->comboMode->currentData(Qt::UserRole).toInt();
1718 emit changeMode(mode,this);
1719}
1720
1721
1722void JointItem::onInteractionChanged(int index)
1723{
1724 emit changeInteraction(index,this);
1725}
1726
1727void JointItem::setJointName(QString name)
1728{
1729 jointName = name;
1730}
1731
1733{
1734 return jointName;
1735}
1736
1737void JointItem::onSliderVelTrajectory_VelocityPressed()
1738{
1739 sliderVelTrajectory_VelocityPressed = true;
1740}
1741
1742void JointItem::onSliderVelTrajectory_VelocityReleased()
1743{
1744 lastVelocity = (double)ui->sliderVelTrajectory_Velocity->value() / ui->sliderVelTrajectory_Velocity->getSliderStep();
1745 sliderVelTrajectory_VelocityPressed = false;
1746}
1747
1748void JointItem::onSliderVelocityDirectPressed()
1749{
1750 sliderVelocityDirectPressed = true;
1751}
1752
1753void JointItem::onSliderVelocityDirectReleased()
1754{
1755 lastVelocityDirect = (double)ui->sliderVelocityDirectVelocityDirect->value() / ui->sliderVelocityDirectVelocityDirect->getSliderStep();
1756 sliderVelocityDirectPressed = false;
1757}
1758
1759
1760void JointItem::onSliderMixedVelocityPressed()
1761{
1762 sliderMixedVelocityPressed = true;
1763}
1764
1765void JointItem::onSliderMixedVelocityReleased()
1766{
1767 lastVelocity = ui->sliderMixedVelocity->value();
1768
1769 if (ui->sliderMixedVelocity->getIsDouble())
1770 {
1771 double val = ui->sliderMixedVelocity->value();
1772 emit sliderMixedVelocityCommand(val / ui->sliderMixedVelocity->getSliderStep(), jointIndex);
1773 }
1774 else
1775 {
1776 emit sliderMixedVelocityCommand(ui->sliderMixedVelocity->value(), jointIndex);
1777 }
1778
1779 sliderMixedVelocityPressed = false;
1780}
1781
1782
1783void JointItem::onVelocityTimer()
1784{
1785 if(velocityModeEnabled)
1786 {
1787 emit sliderVelTrajectoryVelocityCommand(lastVelocity,jointIndex);
1788 }
1789}
1790
1791void JointItem::onVelocityDirectTimer()
1792{
1793 if(velocityDirectModeEnabled)
1794 {
1795 emit sliderVelocityDirectCommand(lastVelocityDirect,jointIndex);
1796 }
1797}
1798
1799void JointItem::onPwmTimer()
1800{
1801 if(pwmModeEnabled)
1802 {
1803 emit sliderPWMCommand(lastPwm,jointIndex);
1804 }
1805}
1806
1807void JointItem::onCurrentTimer()
1808{
1809 if(currentModeEnabled)
1810 {
1811 emit sliderCurrentCommand(lastCurrent,jointIndex);
1812 }
1813}
1814
1815void JointItem::onTorqueTimer()
1816{
1817 if(torqueModeEnabled)
1818 {
1819 emit sliderTorqueCommand(lastTorque, jointIndex);
1820 }
1821}
1822
1823void JointItem::onSliderPosTrajectory_PositionPressed()
1824{
1825 sliderPosTrajectory_PositionPressed = true;
1826}
1827
1828void JointItem::onSliderPosTrajectory_PositionReleased()
1829{
1830 if (ui->sliderPosTrajectory_Position->getIsDouble())
1831 {
1832 double val = ui->sliderPosTrajectory_Position->value();
1833 emit sliderPosTrajectoryPositionCommand(val / ui->sliderPosTrajectory_Position->getSliderStep(), jointIndex);
1834 updateTrajectoryPositionTarget(val / ui->sliderPosTrajectory_Position->getSliderStep());
1835 }
1836 else
1837 {
1838 double val = ui->sliderPosTrajectory_Position->value();
1839 emit sliderPosTrajectoryPositionCommand(val, jointIndex);
1840 updateTrajectoryPositionTarget(val);
1841 }
1842 sliderPosTrajectory_PositionPressed = false;
1843 motionDone = false;
1844}
1845
1846void JointItem::onSliderMixedPositionPressed()
1847{
1848 sliderMixedPositionPressed = true;
1849}
1850
1851void JointItem::onSliderMixedPositionReleased()
1852{
1853 if (ui->sliderMixedPosition->getIsDouble())
1854 {
1855 double val = ui->sliderMixedPosition->value();
1856 emit sliderMixedPositionCommand(val / ui->sliderMixedPosition->getSliderStep(), jointIndex);
1857 updateMixedPositionTarget(val / ui->sliderMixedPosition->getSliderStep());
1858 }
1859 else
1860 {
1861 double val = ui->sliderMixedPosition->value();
1862 emit sliderMixedPositionCommand(val, jointIndex);
1863 updateMixedPositionTarget(val);
1864 }
1865
1866 sliderMixedPositionPressed = false;
1867 motionDone = false;
1868}
1869
1870void JointItem::onSliderDirectPositionPressed()
1871{
1872 sliderDirectPositionPressed = true;
1873}
1874
1875void JointItem::onSliderDirectPositionReleased()
1876{
1877 double ref_direct_position = (double)ui->sliderDirectPosition->value() / ui->sliderDirectPosition->getSliderStep();
1878 emit sliderDirectPositionCommand(ref_direct_position, jointIndex);
1879 sliderDirectPositionPressed = false;
1880 motionDone = false;
1881}
1882
1883void JointItem::onSliderPosTrajectory_VelocityPressed()
1884{
1885 sliderPosTrajectory_VelocityPressed = true;
1886}
1887
1888void JointItem::onSliderPosTrajectory_VelocityReleased()
1889{
1890 m_ref_PosTrajectory_velocity = (double)ui->sliderPosTrajectory_Velocity->value() / ui->sliderPosTrajectory_Velocity->getSliderStep();
1891 emit sliderPosTrajectoryVelocityCommand(m_ref_PosTrajectory_velocity, jointIndex);
1892 sliderPosTrajectory_VelocityPressed = false;
1893}
1894
1895void JointItem::onSliderVelTrajectory_AccelerationPressed()
1896{
1897 sliderVelTrajectory_AccelerationPressed = true;
1898}
1899
1900void JointItem::onSliderVelTrajectory_AccelerationReleased()
1901{
1902 m_ref_VelTrajectory_acceleration = (double)ui->sliderVelTrajectory_Acceleration->value() / ui->sliderVelTrajectory_Acceleration->getSliderStep();
1903 emit sliderVelTrajectoryAccelerationCommand(m_ref_VelTrajectory_acceleration, jointIndex);
1904 sliderVelTrajectory_AccelerationPressed = false;
1905}
1906
1907void JointItem::onSliderPWMPressed()
1908{
1909 sliderPWMPressed = true;
1910}
1911
1912void JointItem::onSliderPWMReleased()
1913{
1914 lastPwm = (double)ui->sliderPWMOutput->value() / ui->sliderPWMOutput->getSliderStep();
1915 sliderPWMPressed = false;
1916}
1917
1918void JointItem::onSliderCurrentPressed()
1919{
1920 sliderCurrentPressed = true;
1921}
1922
1923void JointItem::onSliderCurrentReleased()
1924{
1925 lastCurrent = (double)ui->sliderCurrentOutput->value() / ui->sliderCurrentOutput->getSliderStep();
1926 sliderCurrentPressed = false;
1927}
1928
1929void JointItem::onSliderTorquePressed()
1930{
1931 sliderTorquePressed = true;
1932}
1933
1934void JointItem::onSliderTorqueReleased()
1935{
1936 lastTorque = (double)ui->sliderTorqueTorque->value() / ui->sliderTorqueTorque->getSliderStep();
1937 sliderTorquePressed = false;
1938}
1939
1940
1942{
1943 //this function is mainly used used by the sequencer
1944 double pos = (double)ui->sliderPosTrajectory_Position->value() / ui->sliderPosTrajectory_Position->getSliderStep();
1945 if (fabs(pos) < 1e-6) {
1946 pos = 0;
1947 }
1948 return pos;
1949}
1950
1952{
1953 //this function is mainly used used by the sequencer
1954 double vel = (double)ui->sliderPosTrajectory_Velocity->value() / ui->sliderPosTrajectory_Velocity->getSliderStep();
1955 if (fabs(vel) < 1e-6) {
1956 vel = 0;
1957 }
1958 return vel;
1959}
1960
1962{
1963 ui->BrakeLabel->setText(brk ? "Braked" : "");
1964 if (brk) {
1965 ui->BrakeLabel->setStyleSheet("background-color: black; color: rgb(255, 38, 41); font-weight: bold;");
1966 ui->BrakeLabel->setAlignment(Qt::AlignCenter);
1967 } else {
1968 ui->BrakeLabel->setStyleSheet("background-color: transparent; color: rgb(35, 38, 41); font-weight: normal;");
1969 ui->BrakeLabel->setAlignment(Qt::AlignCenter);
1970 }
1971}
1972
1974{
1975 motionDone = done;
1976 int index = ui->stackedWidget->currentIndex();
1977 if (index == POSITION) {
1978 if(!done){
1979 ui->editPositionJointPos->setStyleSheet("background-color: rgb(255, 38, 41); color: rgb(35, 38, 41);");
1980 }else{
1981 ui->editPositionJointPos->setStyleSheet("background-color: rgb(255, 255, 255); color: rgb(35, 38, 41);");
1982 }
1983 } else if (index == POSITION_DIR) {
1984 if(!done){
1985 ui->editPositionDirJointPos->setStyleSheet("background-color: rgb(255, 38, 41); color: rgb(35, 38, 41);");
1986 }else{
1987 ui->editPositionDirJointPos->setStyleSheet("background-color: rgb(255, 255, 255); color: rgb(35, 38, 41);");
1988 }
1989 } else if (index == MIXED) {
1990 if(!done){
1991 ui->editMixedJointPos->setStyleSheet("background-color: rgb(255, 38, 41); color: rgb(35, 38, 41);");
1992 }else{
1993 ui->editMixedJointPos->setStyleSheet("background-color: rgb(255, 255, 255); color: rgb(35, 38, 41);");
1994 }
1995 }
1996}
1997
1998void JointItem::updateSliderPosTrajectoryPosition(double val)
1999{
2000 if(sliderPosTrajectory_PositionPressed)
2001 {
2002 return;
2003 }
2004 ui->sliderPosTrajectory_Position->setValue(val);
2005}
2006
2007void JointItem::updateSliderPositionDirect(double val)
2008{
2009 if(sliderDirectPositionPressed)
2010 {
2011 return;
2012 }
2013 ui->sliderDirectPosition->setValue(val);
2014}
2015
2016void JointItem::updateSliderMixedPosition(double val)
2017{
2018 if(sliderMixedPositionPressed)
2019 {
2020 return;
2021 }
2022 ui->sliderMixedPosition->setValue(val);
2023}
2024
2025void JointItem::updateSliderPosTrajectoryVelocity(double val)
2026{
2027 if (sliderPosTrajectory_VelocityPressed)
2028 {
2029 return;
2030 }
2031 ui->sliderPosTrajectory_Velocity->setValue(val);
2032}
2033
2034void JointItem::updateSliderVelocityDirect(double val)
2035{
2036 if (sliderVelocityDirectPressed)
2037 {
2038 return;
2039 }
2040 ui->sliderVelocityDirectVelocityDirect->setValue(val);
2041}
2042
2043void JointItem::updateSliderPWM(double val)
2044{
2045 if (sliderPWMPressed) {
2046 return;
2047 }
2048 ui->sliderPWMOutput->setValue(val);
2049}
2050
2051void JointItem::updateSliderCurrent(double val)
2052{
2053 if (sliderCurrentPressed) {
2054 return;
2055 }
2056 ui->sliderCurrentOutput->setValue(val);
2057}
2058
2059void JointItem::updateJointFault(int i, std::string message)
2060{
2061 std::string entryc = std::to_string(i);
2062 QString q1(entryc.c_str());
2063 QString q2(message.c_str());
2064 ui->labelFaultCodeEntry->setText(q1);
2065 ui->labelFaultMessageEntry->setText(q2);
2066}
2067
2068void JointItem::updateSliderTorque(double val)
2069{
2070 if(sliderTorquePressed){
2071 return;
2072 }
2073 ui->sliderTorqueTorque->setValue(val);
2074}
2075
2076void JointItem::updateSliderVelTrajectoryVelocity(double val)
2077{
2078 if (sliderVelTrajectory_VelocityPressed){
2079 return;
2080 }
2081 ui->sliderVelTrajectory_Velocity->setValue(val);
2082}
2083
2084void JointItem::updateSliderVelTrajectoryAcceleration(double val)
2085{
2086 if (sliderVelTrajectory_AccelerationPressed){
2087 return;
2088 }
2089 ui->sliderVelTrajectory_Acceleration->setValue(val);
2090}
2091
2092void JointItem::setRefPWM(double pwmValue)
2093{
2094 if(sliderPWMPressed){
2095 return;
2096 }
2097 if(ui->stackedWidget->currentIndex() == PWM){
2098 updateSliderPWM(pwmValue);
2099 QString sVal;
2100 sVal = QString("%L1").arg(pwmValue, 0, 'f', 3);
2101 ui->editPWMDuty->setText(sVal);
2102 }
2103}
2104
2105void JointItem::setRefCurrent(double currentValue)
2106{
2107 if (sliderCurrentPressed){
2108 return;
2109 }
2110 if (ui->stackedWidget->currentIndex() == CURRENT){
2111 updateSliderCurrent(currentValue);
2112 QString sVal;
2113 sVal = QString("%L1").arg(currentValue, 0, 'f', 3);
2114 ui->editCurrentCurrent->setText(sVal);
2115 }
2116}
2117
2119{
2120 QString sVal;
2121 if (ui->sliderPosTrajectory_Position->getIsDouble())
2122 {
2123 double pos = val;
2124 sVal = QString("%L1").arg(pos, 0, 'f', 3);
2125 }
2126 else
2127 {
2128 double pos = floor(val * 10) / 10;
2129 sVal = QString("%1").arg(pos);
2130 }
2131
2132 if(ui->stackedWidget->currentIndex() == IDLE){
2133 ui->editIdleJointPos->setText(sVal);
2134 }
2135
2136 if (ui->stackedWidget->currentIndex() == HW_FAULT) {
2137 ui->editFaultJointPos->setText(sVal);
2138 }
2139
2140 if(ui->stackedWidget->currentIndex() == POSITION){
2141 ui->editPositionJointPos->setText(sVal);
2142 updateSliderPosTrajectoryPosition(val);
2143 }
2144
2145 if(ui->stackedWidget->currentIndex() == POSITION_DIR){
2146 ui->editPositionDirJointPos->setText(sVal);
2147 updateSliderPositionDirect(val);
2148 }
2149
2150 if(ui->stackedWidget->currentIndex() == MIXED){
2151 ui->editMixedJointPos->setText(sVal);
2152 updateSliderMixedPosition(val);
2153 }
2154
2155 if(ui->stackedWidget->currentIndex() == VELOCITY){
2156 ui->editVelocityJointPos->setText(sVal);
2157 }
2158 if(ui->stackedWidget->currentIndex() == VELOCITY_DIR){
2159 ui->editVelocityDirJointPos->setText(sVal);
2160 }
2161 if(ui->stackedWidget->currentIndex() == TORQUE){
2162 ui->editTorqueJointPos->setText(sVal);
2163 }
2164 if(ui->stackedWidget->currentIndex() == PWM){
2165 ui->editPWMJointPos->setText(sVal);
2166 }
2167 if (ui->stackedWidget->currentIndex() == CURRENT){
2168 ui->editCurrentJointPos->setText(sVal);
2169 }
2170
2171}
2172
2174{
2175 if(ui->stackedWidget->currentIndex() == TORQUE){
2176 updateSliderTorque(val);
2177 m_ref_torque = val;
2178 }
2179}
2180
2182{
2183 if (ui->stackedWidget->currentIndex() == VELOCITY){
2184 updateSliderVelTrajectoryVelocity(val);
2185 m_ref_speed = val;
2186 }
2187}
2188
2190{
2191 if (ui->stackedWidget->currentIndex() == VELOCITY){
2192 updateSliderVelTrajectoryAcceleration(val);
2193 m_ref_VelTrajectory_acceleration = val;
2194
2195 if (val < 0.001)
2196 {
2197 ui->groupBox_2->setStyleSheet("background-color:orange; color: rgb(35, 38, 41);");
2198 ui->groupBox_2->setTitle("Acceleration is ZERO!");
2199 }
2200 else
2201 {
2202 ui->groupBox_2->setStyleSheet("background-color:transparent; color: rgb(35, 38, 41);");
2203 ui->groupBox_2->setTitle("Acceleration");
2204 }
2205 }
2206}
2208{
2209 if (ui->stackedWidget->currentIndex() == POSITION){
2210 updateSliderPosTrajectoryVelocity(val);
2211 m_ref_PosTrajectory_velocity = val;
2212
2213 if (val < 0.001)
2214 {
2215 ui->groupBox_12->setStyleSheet("background-color:orange; color: rgb(35, 38, 41);");
2216 ui->groupBox_12->setTitle("Velocity is ZERO!");
2217 }
2218 else
2219 {
2220 ui->groupBox_12->setStyleSheet("background-color:transparent; color: rgb(35, 38, 41);");
2221 ui->groupBox_12->setTitle("Velocity");
2222 }
2223 }
2224}
2225
2227{
2228 if (ui->stackedWidget->currentIndex() == POSITION){
2229 updateTrajectoryPositionTarget(val);
2230 }
2231}
2232
2233void JointItem::setTorque(double val)
2234{
2235 QString sVal = QString("%L1").arg(val,0,'f',3);
2236
2237 if(ui->stackedWidget->currentIndex() == IDLE){
2238 ui->editIdleTorque->setText(sVal);
2239 }
2240
2241 if(ui->stackedWidget->currentIndex() == POSITION){
2242 ui->editPositionTorque->setText(sVal);
2243 }
2244
2245 if(ui->stackedWidget->currentIndex() == POSITION_DIR){
2246 ui->editPositionDirTorque->setText(sVal);
2247 }
2248
2249 if(ui->stackedWidget->currentIndex() == MIXED){
2250 ui->editMixedTorque->setText(sVal);
2251 }
2252
2253 if(ui->stackedWidget->currentIndex() == VELOCITY){
2254 ui->editVelocityTorque->setText(sVal);
2255 }
2256 if(ui->stackedWidget->currentIndex() == VELOCITY_DIR){
2257 ui->editVelocityDirTorque->setText(sVal);
2258 }
2259 if(ui->stackedWidget->currentIndex() == TORQUE){
2260 ui->editTorqueTorque->setText(sVal);
2261 }
2262 if(ui->stackedWidget->currentIndex() == PWM){
2263 ui->editPWMTorque->setText(sVal);
2264 }
2265 if (ui->stackedWidget->currentIndex() == CURRENT){
2266 ui->editCurrentTorque->setText(sVal);
2267 }
2268}
2269
2271{
2272 if (!joint_motorPositionVisible){
2273 return;
2274 }
2275
2276 double mot = val;
2277 QString sVal = QString("%1").arg(mot, 0, 'f', 1);
2278
2279 if (ui->stackedWidget->currentIndex() == HW_FAULT) {
2280 ui->editFaultMotorPos->setText(sVal);
2281 }
2282
2283 if (ui->stackedWidget->currentIndex() == IDLE){
2284 ui->editIdleMotorPos->setText(sVal);
2285 }
2286
2287 if (ui->stackedWidget->currentIndex() == POSITION){
2288 ui->editPositionMotorPos->setText(sVal);
2289 }
2290
2291 if (ui->stackedWidget->currentIndex() == POSITION_DIR) {
2292 ui->editPositionDirMotorPos->setText(sVal);
2293 }
2294
2295 if (ui->stackedWidget->currentIndex() == MIXED) {
2296 ui->editMixedMotorPos->setText(sVal);
2297 }
2298
2299 if (ui->stackedWidget->currentIndex() == VELOCITY) {
2300 ui->editVelocityMotorPos->setText(sVal);
2301 }
2302
2303 if (ui->stackedWidget->currentIndex() == VELOCITY_DIR) {
2304 ui->editVelocityDirMotorPos->setText(sVal);
2305 }
2306
2307 if (ui->stackedWidget->currentIndex() == TORQUE) {
2308 ui->editTorqueMotorPos->setText(sVal);
2309 }
2310
2311 if (ui->stackedWidget->currentIndex() == PWM) {
2312 ui->editPWMMotorPos->setText(sVal);
2313 }
2314
2315 if (ui->stackedWidget->currentIndex() == CURRENT) {
2316 ui->editCurrentMotorPos->setText(sVal);
2317 }
2318}
2319
2321{
2322 if (!joint_dutyVisible) {
2323 return;
2324 }
2325
2326 double mot = val;
2327 QString sVal = QString("%1").arg(mot, 0, 'f', 1);
2328
2329 //if (ui->stackedWidget->currentIndex() == IDLE) {
2330 // ui->editIdleDuty->setText(sVal);
2331 //}
2332
2333 //if (ui->stackedWidget->currentIndex() == POSITION) {
2334 // ui->editPositionDuty->setText(sVal);
2335 //}
2336
2337 //if (ui->stackedWidget->currentIndex() == POSITION_DIR) {
2338 // ui->editPositionDirDuty->setText(sVal);
2339 //}
2340
2341 //if (ui->stackedWidget->currentIndex() == MIXED) {
2342 // ui->editMixedDuty->setText(sVal);
2343 //}
2344
2345 //if (ui->stackedWidget->currentIndex() == VELOCITY) {
2346 // ui->editVelocityDuty->setText(sVal);
2347 //}
2348
2349 if (ui->stackedWidget->currentIndex() == TORQUE) {
2350 ui->editTorqueDuty->setText(sVal);
2351 }
2352
2353 if (ui->stackedWidget->currentIndex() == PWM) {
2354 ui->editPWMDuty->setText(sVal);
2355 }
2356
2357 if (ui->stackedWidget->currentIndex() == CURRENT) {
2358 ui->editCurrentDuty->setText(sVal);
2359 }
2360}
2361
2362void JointItem::setSpeed(double meas)
2363{
2364 if (!joint_speedVisible){
2365 return;
2366 }
2367 //TODO
2368
2369 double speed = meas;
2370 QString sVal = QString("%1").arg(speed,0,'f',1);
2371
2372 if(ui->stackedWidget->currentIndex() == IDLE){
2373 ui->editIdleSpeed->setText(sVal);
2374 }
2375
2376 if(ui->stackedWidget->currentIndex() == POSITION){
2377 ui->editPositionSpeed->setText(sVal);
2378 }
2379
2380 if(ui->stackedWidget->currentIndex() == POSITION_DIR){
2381 ui->editPositionDirSpeed->setText(sVal);
2382 }
2383
2384 if(ui->stackedWidget->currentIndex() == MIXED){
2385 ui->editMixedSpeed->setText(sVal);
2386 }
2387
2388 if(ui->stackedWidget->currentIndex() == VELOCITY){
2389 if(!sliderVelTrajectory_VelocityPressed){
2390 ui->editVelocitySpeed->setText(sVal);
2391 //updateSlider(ui->sliderVelocityVelocity,ui->labelVelocityVelocity,val);
2392 }
2393 }
2394
2395 if(ui->stackedWidget->currentIndex() == VELOCITY_DIR){
2396 if(!sliderVelocityDirectPressed){
2397 ui->editVelocityDirSpeed->setText(sVal);
2398 //updateSlider(ui->sliderVelocityVelocity,ui->labelVelocityVelocity,val);
2399 }
2400 }
2401 if(ui->stackedWidget->currentIndex() == TORQUE){
2402 ui->editTorqueSpeed->setText(sVal);
2403 //updateSliderTorque(val);
2404 }
2405 if(ui->stackedWidget->currentIndex() == PWM){
2406 ui->editPWMSpeed->setText(sVal);
2407 }
2408 if (ui->stackedWidget->currentIndex() == CURRENT){
2409 ui->editCurrentSpeed->setText(sVal);
2410 }
2411
2412}
2413
2414void JointItem::setCurrent(double meas)
2415{
2416 if (!joint_currentVisible) {
2417 return;
2418 }
2419 //TODO
2420
2421 double current = meas;
2422 QString sVal = QString("%1").arg(current, 0, 'f', 3);
2423
2424 if (ui->stackedWidget->currentIndex() == IDLE) {
2425 ui->editIdleCurrent->setText(sVal);
2426 }
2427
2428 if (ui->stackedWidget->currentIndex() == POSITION) {
2429 ui->editPositionCurrent->setText(sVal);
2430 }
2431
2432 if (ui->stackedWidget->currentIndex() == POSITION_DIR) {
2433 ui->editPositionDirCurrent->setText(sVal);
2434 }
2435
2436 if (ui->stackedWidget->currentIndex() == MIXED) {
2437 ui->editMixedCurrent->setText(sVal);
2438 }
2439
2440 if (ui->stackedWidget->currentIndex() == VELOCITY) {
2441 ui->editVelocityCurrent->setText(sVal);
2442 }
2443 if (ui->stackedWidget->currentIndex() == VELOCITY_DIR) {
2444 ui->editVelocityDirCurrent->setText(sVal);
2445 }
2446 if (ui->stackedWidget->currentIndex() == TORQUE) {
2447 ui->editTorqueCurrent->setText(sVal);
2448 }
2449 if (ui->stackedWidget->currentIndex() == PWM) {
2450 ui->editPWMCurrent->setText(sVal);
2451 }
2452 if (ui->stackedWidget->currentIndex() == CURRENT) {
2453 ui->editCurrentCurrent->setText(sVal);
2454 }
2455
2456}
2457
2458
2459
2460
2461void JointItem::setJointInternalInteraction(int interaction)
2462{
2463 disconnect(ui->comboInteraction,SIGNAL(currentIndexChanged(int)),this,SLOT(onInteractionChanged(int)));
2464 ui->comboInteraction->setCurrentIndex(interaction);
2465 connect(ui->comboInteraction,SIGNAL(currentIndexChanged(int)),this,SLOT(onInteractionChanged(int)));
2466}
2467
2468void JointItem::setJointInternalState(int mode)
2469{
2470 disconnect(ui->comboMode,SIGNAL(currentIndexChanged(int)),this,SLOT(onModeChanged(int)));
2471 ui->comboMode->setCurrentIndex(mode);
2472 connect(ui->comboMode,SIGNAL(currentIndexChanged(int)),this,SLOT(onModeChanged(int)));
2473
2474 ui->stackedWidget->setCurrentIndex(mode);
2475 if(ui->stackedWidget->widget(mode)){
2476 QVariant variant = ui->comboMode->itemData(mode,Qt::BackgroundRole);
2477 QColor c;
2478 switch(internalState)
2479 {
2480 case Disconnected:
2481 c = disconnectColor;
2482 break;
2483 case HwFault:
2484 ui->groupBox->setTitle(QString("JOINT %1 (%2) - HARDWARE FAULT").arg(jointIndex).arg(jointName));
2485 c = hwFaultColor;
2486 ui->stackedWidget->setEnabled(false);
2487 //ui->buttonsContainer->setEnabled(false);
2488 ui->buttonHome->setEnabled(false);
2489 ui->buttonCalib->setEnabled(false);
2490 ui->buttonRun->setEnabled(false);
2491 ui->comboMode->setEnabled(false);
2492 ui->comboInteraction->setEnabled(false);
2493 ui->buttonIdle->setEnabled(true);
2494 ui->buttonPid->setEnabled(true);
2495 break;
2496 case Unknown:
2497 case NotConfigured:
2498 case Configured:
2499 case CalibDone:
2500 case Calibrating:
2501 c = calibratingColor;
2502 break;
2503
2504 default:{
2505 enableAll();
2506 c = variant.value<QColor>();
2507 if(ui->groupBox->title() != QString("JOINT %1 (%2)").arg(jointIndex).arg(jointName))
2508 {
2509 ui->groupBox->setTitle(QString("JOINT %1 (%2)").arg(jointIndex).arg(jointName));
2510 }
2511 ui->stackedWidget->setEnabled(true);
2512 ui->buttonsContainer->setEnabled(true);
2513 break;
2514 }
2515 }
2516
2517 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2518 }
2519}
2520
2522{
2523 if(internalInteraction == interaction){
2524 return;
2525 }
2526
2527 internalInteraction = interaction;
2528
2529 switch (internalInteraction) {
2530 case Stiff:
2531 setJointInternalInteraction(STIFF);
2532 break;
2533 case COMPLIANT:
2534 setJointInternalInteraction(COMPLIANT);
2535 break;
2536 default:
2537 break;
2538 }
2539}
2540
2542{
2543 return internalState;
2544}
2545
2547{
2548 if(internalState == newState){
2549 return;
2550 }
2551
2552 internalState = newState;
2553
2554 switch (internalState) {
2555 case Unknown:{
2556 ui->groupBox->setTitle(QString("JOINT %1 (%2) - UNKNOWN").arg(jointIndex).arg(jointName));
2557 ui->stackedWidget->setEnabled(false);
2558 ui->buttonsContainer->setEnabled(false);
2559
2560 int index = ui->stackedWidget->currentIndex();
2561 if(ui->stackedWidget->widget(index)){
2562 QColor c = calibratingColor;
2563 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2564 }
2565 break;
2566 }
2567 case Configured:{
2568 ui->groupBox->setTitle(QString("JOINT %1 (%2) - CONFIGURED").arg(jointIndex).arg(jointName));
2569 ui->stackedWidget->setEnabled(true);
2570 ui->buttonsContainer->setEnabled(true);
2571
2572 int index = ui->stackedWidget->currentIndex();
2573 if(ui->stackedWidget->widget(index)){
2574 QColor c = calibratingColor;
2575 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2576 }
2577 break;
2578 }
2579
2580 case NotConfigured:{
2581 ui->groupBox->setTitle(QString("JOINT %1 (%2) - NOT CONFIGURED").arg(jointIndex).arg(jointName));
2582 ui->stackedWidget->setEnabled(false);
2583 //activating only calib button
2584 if(enableCalib)
2585 {
2586
2587 ui->buttonsContainer->setEnabled(true);
2588 ui->buttonIdle->setEnabled(false);
2589 ui->buttonPid->setEnabled(true);
2590 ui->buttonHome->setEnabled(false);
2591 ui->buttonCalib->setEnabled(true);
2592 ui->buttonRun->setEnabled(false);
2593 ui->comboMode->setEnabled(false);
2594 ui->comboInteraction->setEnabled(false);
2595 }
2596 //nothing must be activated
2597 else
2598 {
2599 ui->buttonsContainer->setEnabled(false);
2600 }
2601
2602 int index = ui->stackedWidget->currentIndex();
2603 if(ui->stackedWidget->widget(index)){
2604 QColor c = calibratingColor;
2605 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2606 }
2607 break;
2608 }
2609
2610 case CalibDone:{
2611 ui->groupBox->setTitle(QString("JOINT %1 (%2) - CALIBRATING DONE").arg(jointIndex).arg(jointName));
2612 ui->stackedWidget->setEnabled(true);
2613 ui->buttonsContainer->setEnabled(true);
2614
2615 int index = ui->stackedWidget->currentIndex();
2616 if(ui->stackedWidget->widget(index)){
2617 QColor c = calibratingColor;
2618 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2619 }
2620 break;
2621 }
2622 case Calibrating:{
2623 ui->groupBox->setTitle(QString("JOINT %1 (%2) - CALIBRATING").arg(jointIndex).arg(jointName));
2624 ui->stackedWidget->setEnabled(false);
2625 ui->buttonsContainer->setEnabled(false);
2626
2627 int index = ui->stackedWidget->currentIndex();
2628 if(ui->stackedWidget->widget(index)){
2629 QColor c = calibratingColor;
2630 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2631 }
2632 break;
2633 }
2634 case HwFault:{
2635 setJointInternalState(HW_FAULT);
2636 break;
2637 }
2638 case Disconnected:{
2639 ui->groupBox->setTitle(QString("JOINT %1 (%2) - DISCONNECTED").arg(jointIndex).arg(jointName));
2640 ui->stackedWidget->setEnabled(false);
2641 ui->buttonsContainer->setEnabled(false);
2642
2643 int index = ui->stackedWidget->currentIndex();
2644 if(ui->stackedWidget->widget(index)){
2645 QColor c = disconnectColor;
2646 setStyleSheet(QString("font: 8pt; background-color: rgb(%1,%2,%3); color: rgb(35, 38, 41);").arg(c.red()).arg(c.green()).arg(c.blue()));
2647 }
2648 break;
2649 }
2650 case Idle:{
2651 setJointInternalState(IDLE);
2652 break;
2653 }
2654 case Position:{
2655 setJointInternalState(POSITION);
2656 break;
2657 }
2658 case PositionDirect:{
2659 setJointInternalState(POSITION_DIR);
2660 break;
2661 }
2662 case Mixed:{
2663 setJointInternalState(MIXED);
2664 break;
2665 }
2666 case Velocity:{
2667 setJointInternalState(VELOCITY);
2668 break;
2669 }
2670 case VelocityDirect:{
2671 setJointInternalState(VELOCITY_DIR);
2672 break;
2673 }
2674 case Torque:{
2675 setJointInternalState(TORQUE);
2676 break;
2677 }
2678 case Pwm:{
2679 setJointInternalState(PWM);
2680 break;
2681 }
2682 case Current:{
2683 setJointInternalState(CURRENT);
2684 break;
2685 }
2686 default:
2687 break;
2688 }
2689
2690}
2691
2692void JointItem::enableAll()
2693{
2694 ui->stackedWidget->setEnabled(true);
2695 ui->buttonsContainer->setEnabled(true);
2696 ui->buttonIdle->setEnabled(true);
2697 ui->buttonPid->setEnabled(true);
2698 ui->buttonHome->setEnabled(true);
2699 if(enableCalib){
2700 ui->buttonCalib->setEnabled(true);
2701 }
2702 ui->buttonRun->setEnabled(true);
2703 ui->comboMode->setEnabled(true);
2704 ui->comboInteraction->setEnabled(true);
2705
2706}
2707
2708void JointItem::setPWMRange(double min, double max)
2709{
2710 ui->sliderPWMOutput->setRange(min,max);
2711}
2712
2713void JointItem::setCurrentRange(double min, double max)
2714{
2715 if (min < max)
2716 {
2717 m_min_current = min;
2718 m_max_current = max;
2719 }
2720 else
2721 {
2722 //Error
2723 }
2724 ui->sliderCurrentOutput->setRange(min, max);
2725}
2726
2727void JointItem::setPositionRange(double min, double max)
2728{
2729 m_min_position = 1;
2730 m_max_position = 2;
2731 if(min < max)
2732 {
2733 m_min_position = min;
2734 m_max_position = max;
2735 }
2736 else
2737 {
2738 //Error
2739 }
2740}
2741
2742void JointItem::setVelocityRange(double min, double max)
2743{
2744 m_min_velocity = -100;
2745 m_max_velocity = 100;
2746 if (min < max)
2747 {
2748 m_min_velocity = min;
2749 m_max_velocity = max;
2750 }
2751 else
2752 {
2753 //Error
2754 }
2755}
2756
2757void JointItem::setAccelerationRange(double min, double max)
2758{
2759 m_min_acceleration = -100;
2760 m_max_acceleration = 100;
2761 if (min < max)
2762 {
2763 m_min_acceleration = min;
2764 m_max_acceleration = max;
2765 }
2766 else
2767 {
2768 //Error
2769 }
2770}
2771
2773{
2774 m_max_torque = 5;
2775 if (max >= 0)
2776 {
2777 m_max_torque = max;
2778 }
2779 else
2780 {
2781 //Error
2782 }
2783}
2784
2785void JointItem::onCalibClicked()
2786{
2787 if (this->internalState == Velocity)
2788 {
2789 velocityTimer.stop();
2790 }
2791 if (this->internalState == VelocityDirect)
2792 {
2793 velocityDirectTimer.stop();
2794 }
2795 else if(this->internalState == Pwm)
2796 {
2797 pwmTimer.stop();
2798 }
2799 else if(this->internalState == Current)
2800 {
2801 currentTimer.stop();
2802 }
2803 else if(this->internalState == Torque)
2804 {
2805 torqueTimer.stop();
2806 }
2807 emit calibClicked(this);
2808}
2809
2810void JointItem::onHomeClicked()
2811{
2812 home();
2813}
2814
2815void JointItem::onIdleClicked()
2816{
2817 idle();
2818}
2819
2820void JointItem::onRunClicked()
2821{
2822 run();
2823}
2824
2825void JointItem::onPidClicked()
2826{
2827 showPID();
2828}
2829
2831{
2832 ui->sliderMixedPosition->setEnabled(false);
2833 ui->sliderMixedVelocity->setEnabled(false);
2834 ui->sliderPWMOutput->setEnabled(false);
2835 ui->sliderCurrentOutput->setEnabled(false);
2836 ui->sliderDirectPosition->setEnabled(false);
2837 ui->sliderPosTrajectory_Position->setEnabled(false);
2838 ui->sliderPosTrajectory_Velocity->setEnabled(false);
2839 ui->sliderTorqueTorque->setEnabled(false);
2840
2841}
2842
2844{
2845 ui->sliderMixedPosition->setEnabled(true);
2846 ui->sliderMixedVelocity->setEnabled(true);
2847 ui->sliderPWMOutput->setEnabled(true);
2848 ui->sliderCurrentOutput->setEnabled(true);
2849 ui->sliderDirectPosition->setEnabled(true);
2850 ui->sliderPosTrajectory_Position->setEnabled(true);
2851 ui->sliderPosTrajectory_Velocity->setEnabled(true);
2852 ui->sliderTorqueTorque->setEnabled(true);
2853}
2854
2855
2856bool WheelEventFilter::eventFilter(QObject *obj, QEvent *event)
2857{
2858 if (event->type() == QEvent::Wheel) {
2859 return true;
2860 } else {
2861 // standard event processing
2862 return QObject::eventFilter(obj, event);
2863 }
2864}
FeatureMode mode
#define yError(...)
Definition Log.h:361
#define yFatal(...)
Definition Log.h:382
int SIGNAL(int pid, int signum)
void setMotorPosition(double meas)
void viewPositionTargetValue(bool)
void setVelocityRange(double min, double max)
void setDutyVisible(bool)
void sliderVelocityDirectCommand(double val, int jointIndex)
void sequenceActivated()
void updateJointFault(int i, std::string message)
void disableAccelerationSliderDouble()
void enableControlPositionDirect(bool control)
void enableVelocitySliderDoubleAuto()
void setCurrentsVisible(bool)
void setUnits(yarp::dev::JointTypeEnum t)
void setPositionRange(double min, double max)
void enableControlMixed(bool control)
JointState getJointState()
void resetTarget()
Definition jointitem.cpp:23
void enablePositionSliderDoubleValue(double value)
void sliderVelTrajectoryAccelerationCommand(double val, int jointIndex)
void sliderCurrentCommand(double val, int jointIndex)
void enableAccelerationSliderDoubleValue(double value)
void enableCurrentSliderDoubleValue(double value)
void viewPositionTargetBox(bool)
void setJointState(JointState)
void sliderPosTrajectoryPositionCommand(double val, int jointIndex)
void enableControlPWM(bool control)
void disablePositionSliderDouble()
void setNumberOfAccelerationSliderDecimals(size_t num)
void disableCurrentSliderDouble()
void enableTorqueSliderDoubleValue(double value)
void homeClicked(JointItem *joint)
static QString JointState2String(JointState mode)
void setPosition(double val)
void sliderPWMCommand(double val, int jointIndex)
void enableControlVelocityDirect(bool control)
void setCurrentRange(double min, double max)
void setJointName(QString name)
void pidClicked(JointItem *joint)
QString getJointName()
void setPWMRange(double min, double max)
void updateMotionDone(bool done)
void setRefCurrent(double ref)
void setNumberOfCurrentSliderDecimals(size_t num)
@ InteractionStarting
Definition jointitem.h:35
double getTrajectoryVelocityValue()
void setVelTrajectory_ReferenceSpeed(double ref)
void setSpeed(double val)
void enableCurrentSliderDoubleAuto()
bool eventFilter(QObject *obj, QEvent *event) override
JointItem(int index, std::vector< yarp::dev::SelectableControlModeEnum > available_modes, QWidget *parent=0)
int getJointIndex()
void sliderMixedPositionCommand(double val, int jointIndex)
void sliderDirectPositionCommand(double val, int jointIndex)
void setJointInteraction(JointInteraction interaction)
void calibClicked(JointItem *joint)
void runClicked(JointItem *joint)
void setMotorPositionVisible(bool)
void enableControlVelocity(bool control)
void setNumberOfTorqueSliderDecimals(size_t num)
void setDutyCycles(double duty)
double getTrajectoryPositionValue()
void sliderPosTrajectoryVelocityCommand(double val, int jointIndex)
void setCurrent(double meas)
static yarp::dev::ControlModeEnum JointState2Mode(JointState mode)
void idle()
Definition jointitem.cpp:79
void disableVelocitySliderDouble()
void setPosTrajectory_ReferenceSpeed(double ref)
void updateBraked(bool brk)
void sliderVelTrajectoryVelocityCommand(double val, int jointIndex)
void setRefPWM(double ref)
static QColor JointState2Color(JointState mode)
void run()
Definition jointitem.cpp:54
void sliderTorqueCommand(double val, int jointIndex)
void enableControlCurrent(bool control)
void setEnabledOptions(bool debug_param_enabled, bool speedview_param_enabled, bool enable_calib_all)
void setAccelerationRange(double min, double max)
void sequenceStopped()
void changeMode(int mode, JointItem *joint)
void enableTorqueSliderDoubleAuto()
void setVelTrajectory_ReferenceAcceleration(double ref)
void setSpeedVisible(bool)
void showPID()
void home()
Definition jointitem.cpp:29
void setNumberOfPositionSliderDecimals(size_t num)
@ PositionDirect
Definition jointitem.h:33
@ Disconnected
Definition jointitem.h:34
@ StateStarting
Definition jointitem.h:34
@ VelocityDirect
Definition jointitem.h:33
@ Calibrating
Definition jointitem.h:34
@ NotConfigured
Definition jointitem.h:34
void enableVelocitySliderDoubleValue(double value)
void enablePositionSliderDoubleAuto()
void disableTorqueSliderDouble()
void setPosTrajectory_ReferencePosition(double ref)
void enableAccelerationSliderDoubleAuto()
void enableControlTorque(bool control)
void setTorque(double meas)
void setNumberOfVelocitySliderDecimals(size_t num)
void sliderMixedVelocityCommand(double val, int jointIndex)
void idleClicked(JointItem *joint)
void setTorqueRange(double max)
void setRefTorque(double ref)
void changeInteraction(int interaction, JointItem *joint)
bool eventFilter(QObject *obj, QEvent *event) override
bool speedview_param_enabled
Definition main.cpp:35
bool debug_param_enabled
Definition main.cpp:34
bool enable_calib_all
Definition main.cpp:36
#define STIFF
Definition jointitem.h:25
#define COMPLIANT
Definition jointitem.h:26
Definition aboutdlg.h:11
SelectableControlModeEnum
const QColor velocityDirectColor
const QColor idleColor
const QColor disconnectColor
const QColor hwFaultColor
const QColor torqueColor
const QColor positionColor
const QColor pwmColor
const QColor positionDirectColor
const QColor mixedColor
const QColor velocityColor
const QColor calibratingColor
const QColor currentColor