def motor_controller(self):
'''
Sets up the GUI in the middle of the Screen to control the motors.
Uses self._motorValues to determine which motors are present.
'''
i = 0
for k, v in sorted(self._currentGoals.items()):
group = QGroupBox()
slider = QSlider(Qt.Horizontal)
slider.setTickInterval(1)
slider.setMinimum(-181)
slider.setMaximum(181)
slider.valueChanged.connect(self.slider_update)
self._sliders[k] = slider
textfield = QLineEdit()
textfield.setText('0')
textfield.textEdited.connect(self.textfield_update)
self._textFields[k] = textfield
label = QLabel()
label.setText(k)
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(self._sliders[k])
layout.addWidget(self._textFields[k])
group.setLayout(layout)
self._widget.motorControlLayout.addWidget(group, i / 5, i % 5)
i = i+1
def __init__(self, check_state_changed_callback, topic_name, parent=None, is_topic = False):
super(TreeWidgetItem, self).__init__(parent)
self._check_state_changed_callback = check_state_changed_callback
self._topic_name = topic_name
self.setCheckState(CHECK_COLUMN, Qt.Unchecked)
self._is_topic = is_topic
self._slider = QSlider(Qt.Horizontal)
self._hbox = QHBoxLayout()
self._min_label = QLabel("min")
self._max_label = QLabel("max")
self._hbox.addWidget(self._min_label)
self._hbox.addWidget(self._slider)
self._hbox.addWidget(self._max_label)
tree = self.treeWidget()
widget = QWidget()
widget.setLayout(self._hbox)
# tree.setItemWidget(self, 3, widget)
self.setTextAlignment(self._column_names.index("min"), Qt.AlignRight | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("max"), Qt.AlignLeft | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("value"), Qt.AlignHCenter | Qt.AlignVCenter)
self.setTextAlignment(self._column_names.index("type"), Qt.AlignHCenter | Qt.AlignVCenter)
self.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable )
self._slider.valueChanged.connect(self.sliderValueChanged)
def paintEvent(self, event):
QSlider.paintEvent(self, event)
curr_value = str(self.value())
round_value = round(float(curr_value), 4)
painter = QPainter(self)
painter.setPen(QPen(QtCore.Qt.white))
font_metrics = QFontMetrics(self.font())
font_width = font_metrics.boundingRect(str(round_value)).width()
font_height = font_metrics.boundingRect(str(round_value)).height()
rect = self.geometry()
if self.orientation() == QtCore.Qt.Horizontal:
horizontal_x_pos = rect.width() - font_width - 5
horizontal_y_pos = rect.height() * 0.75
painter.drawText(QtCore.QPoint(horizontal_x_pos, horizontal_y_pos),
str(round_value))
self.x = self.value()
else:
pass
painter.drawRect(rect)
def __init__(self, title, jsp, num_rows=0):
super(JointStatePublisherGui, self).__init__()
self.jsp = jsp
self.joint_map = {}
self.vlayout = QVBoxLayout(self)
self.scrollable = QWidget()
self.gridlayout = QGridLayout()
self.scroll = QScrollArea()
self.scroll.setWidgetResizable(True)
font = QFont("Helvetica", 9, QFont.Bold)
### Generate sliders ###
sliders = []
for name in self.jsp.joint_list:
if name not in self.jsp.free_joints:
continue
joint = self.jsp.free_joints[name]
if joint['min'] == joint['max']:
continue
joint_layout = QVBoxLayout()
row_layout = QHBoxLayout()
label = QLabel(name)
label.setFont(font)
row_layout.addWidget(label)
display = QLineEdit("0.00")
display.setAlignment(Qt.AlignRight)
display.setFont(font)
display.setReadOnly(True)
row_layout.addWidget(display)
joint_layout.addLayout(row_layout)
slider = QSlider(Qt.Horizontal)
slider.setFont(font)
slider.setRange(0, RANGE)
slider.setValue(RANGE / 2)
joint_layout.addWidget(slider)
self.joint_map[name] = {
'slidervalue': 0,
'display': display,
'slider': slider,
'joint': joint
}
# Connect to the signal provided by QSignal
slider.valueChanged.connect(
lambda event, name=name: self.onValueChangedOne(name))
sliders.append(joint_layout)
# Determine number of rows to be used in grid
self.num_rows = num_rows
# if desired num of rows wasn't set, default behaviour is a vertical layout
if self.num_rows == 0:
self.num_rows = len(sliders) # equals VBoxLayout
# Generate positions in grid and place sliders there
self.positions = self.generate_grid_positions(len(sliders),
self.num_rows)
for item, pos in zip(sliders, self.positions):
self.gridlayout.addLayout(item, *pos)
# Set zero positions read from parameters
self.center()
# Synchronize slider and displayed value
self.sliderUpdate(None)
# Set up a signal for updating the sliders based on external joint info
self.sliderUpdateTrigger.connect(self.updateSliders)
self.scrollable.setLayout(self.gridlayout)
self.scroll.setWidget(self.scrollable)
self.vlayout.addWidget(self.scroll)
# Buttons for randomizing and centering sliders and
# Spinbox for on-the-fly selecting number of rows
self.randbutton = QPushButton('Randomize', self)
self.randbutton.clicked.connect(self.randomize_event)
self.vlayout.addWidget(self.randbutton)
self.ctrbutton = QPushButton('Center', self)
self.ctrbutton.clicked.connect(self.center_event)
self.vlayout.addWidget(self.ctrbutton)
self.maxrowsupdown = QSpinBox()
self.maxrowsupdown.setMinimum(1)
self.maxrowsupdown.setMaximum(len(sliders))
self.maxrowsupdown.setValue(self.num_rows)
self.maxrowsupdown.valueChanged.connect(self.reorggrid_event)
self.vlayout.addWidget(self.maxrowsupdown)
self.setLayout(self.vlayout)
def __init__(self, title, jsp, num_rows=0):
super(JointStatePublisherGui, self).__init__()
font = QFont("Helvetica", 9, QFont.Bold)
self.hlayout = QHBoxLayout(self)
vlayout = QVBoxLayout()
glayout = QGridLayout()
right_l_lauout = QVBoxLayout()
self.listVeiw = QListWidget()
self.checkbox = []
self.value_line_edit = []
self.sliders = []
self.positions = []
self.progressbars = []
self.value_last = []
speed_max = enviromnt_conf['joint_speed']
slider_max = speed_max * 1000
position_max = enviromnt_conf['joint_max_position']
progress_max = position_max * 1000
#create joints widget
for i in range(0, num_rows):
if config[i][0]:
g_in_g = QGridLayout()
checkbox = QCheckBox(config[i][1])
checkbox.setFont(font)
self.checkbox.append(checkbox)
value_line_edit = QLineEdit()
value_line_edit.setFont(font)
value_line_edit.setText("0.0")
self.value_line_edit.append(value_line_edit)
display_lable = QLabel()
display_lable.setFont(font)
display_lable.setText("Position:")
position_label = QLabel()
position_label.setFont(font)
position_label.setText("0.0")
self.positions.append(position_label)
position_progress_bar = QProgressBar()
position_progress_bar.setMaximum(progress_max)
position_progress_bar.setMinimum(-progress_max)
position_progress_bar.setValue(0)
self.progressbars.append(position_progress_bar)
slider = QSlider()
slider.setMaximum(slider_max)
slider.setMinimum(-slider_max)
slider.setOrientation(Qt.Horizontal)
slider.valueChanged.connect(self.slider_value_changed)
self.sliders.append(slider)
g_in_g.addWidget(checkbox, 0, 0)
g_in_g.addWidget(value_line_edit, 0, 1)
g_in_g.addWidget(display_lable, 0, 2)
g_in_g.addWidget(position_label, 0, 3)
g_in_g.addWidget(slider, 1, 0, 1, 2)
g_in_g.addWidget(position_progress_bar, 1, 2, 1, 2)
glayout.addLayout(g_in_g, i, 0)
#create v layout
self.import_Btn = QPushButton('Import')
self.import_Btn.setFont(font)
self.import_Btn.clicked.connect(self.import_Btn_clecked)
self.export_Btn = QPushButton('Export')
self.export_Btn.setFont(font)
self.export_Btn.clicked.connect(self.export_Btn_clicked)
self.start_Btn = QPushButton("Start")
self.start_Btn.setFont(font)
self.start_Btn.clicked.connect(self.start_Btn_clicked)
self.reset_Btn = QPushButton('Reset')
self.reset_Btn.setFont(font)
self.reset_Btn.clicked.connect(self.reset_Btn_clicked)
self.record_Btn = QPushButton('Record')
self.record_Btn.setFont(font)
self.record_Btn.clicked.connect(self.record_Btn_clicked)
self.replay_Btn = QPushButton('Repaly')
self.replay_Btn.setFont(font)
self.replay_Btn.clicked.connect(self.replay_Btn_clicked)
self.delete_Btn = QPushButton("Delete")
self.delete_Btn.setFont(font)
self.delete_Btn.clicked.connect(self.delete_Btn_clicked)
self.debug_Btn = QPushButton("Debug")
self.debug_Btn.setFont(font)
self.debug_Btn.clicked.connect(self.debug_Btn_clicked)
vlayout.addWidget(self.import_Btn)
vlayout.addWidget(self.export_Btn)
vlayout.addWidget(self.start_Btn)
vlayout.addWidget(self.reset_Btn)
vlayout.addWidget(self.record_Btn)
vlayout.addWidget(self.delete_Btn)
vlayout.addWidget(self.replay_Btn)
vlayout.addWidget(self.debug_Btn)
self.master_url = QLineEdit("http://192.168.0.91:11311")
self.master_url.setFont(font)
self.master_ip = QLineEdit("192.168.0.91")
self.master_ip.setFont(font)
self.listVeiw.clicked.connect(self.listVeiw_clicked)
self.listVeiw.currentRowChanged.connect(
self.listVeiw_itemSelectionChanged)
self.description = QTextEdit("")
self.description.setFont(font)
#self.description.setGeometry(0,100,100,500)
right_l_lauout.addWidget(self.master_url)
right_l_lauout.addWidget(self.master_ip)
right_l_lauout.addWidget(self.listVeiw)
right_l_lauout.addWidget(self.description)
right_l_lauout.setStretch(0, 1)
right_l_lauout.setStretch(1, 1)
right_l_lauout.setStretch(2, 3)
right_l_lauout.setStretch(3, 1)
self.num_rows = len(self.checkbox)
self.hlayout.addLayout(glayout)
self.hlayout.addLayout(vlayout)
self.hlayout.addLayout(right_l_lauout)
self.setLayout(self.hlayout)
self.callback_start = None
self.callback_pause = None
self.callback_record = None
self.callback_reset = None
self.callback_replay = None
self.callback_replay_stop = None
self.callback_delete = None
self.callback_debug = None
self.callback_import = None
self.callback_export = None
self.callback_list_clicked = None
self.listVeiw_isClicked = False
self.listVeiw_current_item = 0
self.listVeiw_len = 0
self.f = QFileDialog()
def init_sliders(self):
sliderbox = self._widget.findChild(QLayout, 'Sliders')
graph_button = QPushButton()
graph_button.setCheckable(True)
graph_button.setText("Graph Off")
graph_button.toggle()
graph_button.clicked.connect(self.set_graph_state)
self.graph_button = graph_button
firstCol = QVBoxLayout()
firstCol.addWidget(graph_button)
sliderbox.addLayout(firstCol)
self.sliders = []
all_rows_layout = QVBoxLayout()
chan_idx = 0
for num_channels_row in self.settings['num_channels']:
row_layout = QHBoxLayout()
for i in range(num_channels_row):
idx = chan_idx * 1
slider_group = {
'slider_p': None,
'number_p': None,
'slider_v': None,
'number_v': None,
'on_off': None
}
layout_cluster = QVBoxLayout()
slider_cluster = QHBoxLayout()
label = QLabel()
label.setText("Chan. %d" % (idx + 1))
label.setAlignment(Qt.AlignCenter)
layout_cluster.addWidget(label)
for j in range(2):
layout = QVBoxLayout()
layout.setAlignment(Qt.AlignHCenter)
slider = QSlider(Qt.Vertical)
slider.setMinimum(0)
slider.setMaximum(255)
slider.setValue(
self.settings['valve_offsets'][chan_idx][j])
slider.setTickPosition(QSlider.TicksRight)
slider.setTickInterval(5)
spinbox = QSpinBox()
spinbox.setRange(0, 255)
spinbox.setValue(
self.settings['valve_offsets'][chan_idx][j])
slider.valueChanged.connect(spinbox.setValue)
spinbox.valueChanged.connect(slider.setValue)
cb_function_curr = lambda value, idx=idx: self.send_slider_value(
idx, value)
slider.valueChanged.connect(cb_function_curr)
label = QLabel()
label.setAlignment(Qt.AlignCenter)
if j == 0:
slider_group['slider_p'] = slider
slider_group['number_p'] = spinbox
label.setText("P")
else:
slider_group['slider_v'] = slider
slider_group['number_v'] = spinbox
label.setText("V")
labelmax = QLabel()
labelmax.setAlignment(Qt.AlignCenter)
labelmax.setText("255")
labelmin = QLabel()
labelmin.setAlignment(Qt.AlignCenter)
labelmin.setText("0")
layout.addWidget(label)
layout.addWidget(labelmax)
layout.addWidget(slider, Qt.AlignHCenter)
layout.addWidget(labelmin)
layout.addWidget(spinbox, Qt.AlignHCenter)
layout.setAlignment(slider, Qt.AlignHCenter)
layout.setAlignment(spinbox, Qt.AlignHCenter)
slider_cluster.addLayout(layout)
on_button = QPushButton()
on_button.setCheckable(True)
on_button.setText("Off")
if self.settings['channel_states'][chan_idx]:
on_button.toggle()
on_button.setText("On")
on_button.clicked.connect(
lambda state, idx=idx: self.send_channel_state(idx, state))
slider_group['on_off'] = on_button
layout_cluster.addLayout(slider_cluster)
layout_cluster.addWidget(on_button)
row_layout.addLayout(layout_cluster)
row_layout.addSpacing(20)
self.sliders.append(slider_group)
chan_idx += 1
all_rows_layout.addLayout(row_layout)
sliderbox.addLayout(all_rows_layout)
def init_sliders(self):
sliderbox = self._widget.findChild(QLayout, 'Sliders')
firstCol = QVBoxLayout()
graph_button = QPushButton()
graph_button.setCheckable(True)
graph_button.setText("Graph Off")
graph_button.toggle()
graph_button.clicked.connect(self.set_graph_state)
reset_button = QPushButton()
reset_button.setCheckable(False)
reset_button.setText("Reset")
reset_button.clicked.connect(self.set_reset)
self.graph_button = graph_button
self.reset_button = reset_button
firstCol.addWidget(graph_button)
firstCol.addWidget(reset_button)
firstCol.setAlignment(graph_button, Qt.AlignVCenter)
firstCol.setAlignment(reset_button, Qt.AlignVCenter)
zero_button = QPushButton()
zero_button.setCheckable(False)
zero_button.setText("Set All Zero")
zero_button.clicked.connect(self.set_pressure_zero)
self.zero_button = zero_button
firstCol.addWidget(zero_button)
firstCol.setAlignment(zero_button, Qt.AlignVCenter)
transition_box = QVBoxLayout()
label = QLabel()
label.setAlignment(Qt.AlignCenter)
label.setText("Transition Time")
spinbox = QDoubleSpinBox()
spinbox.setMinimum(0)
spinbox.setMaximum(10)
spinbox.setValue(self.settings['transitions'])
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
spinbox.setSuffix(" sec")
spinbox.valueChanged.connect(self.set_transition_value)
transition_box.addWidget(label)
transition_box.addWidget(spinbox)
transition_box.setAlignment(label, Qt.AlignBottom)
transition_box.setAlignment(spinbox, Qt.AlignTop)
firstCol.addLayout(transition_box)
self.sliders = []
sliderbox.addLayout(firstCol)
all_rows_layout = QVBoxLayout()
chan_idx = 0
for num_channels_row in self.settings['num_channels']:
row_layout = QHBoxLayout()
for i in range(num_channels_row):
idx = chan_idx * 1
slider_group = {'slider': None, 'number': None, 'on_off': None}
layout_cluster = QVBoxLayout()
layout = QVBoxLayout()
layout.setAlignment(Qt.AlignHCenter)
slider = QSlider(Qt.Vertical)
slider.setMinimum(self.settings['min_pressure'][idx] * 10.0)
slider.setMaximum(self.settings['max_pressure'][idx] * 10.0)
slider.setValue(0)
slider.setTickPosition(QSlider.TicksRight)
slider.setTickInterval(20)
spinbox = QDoubleSpinBox()
spinbox.setMinimum(self.settings['min_pressure'][idx])
spinbox.setMaximum(self.settings['max_pressure'][idx])
spinbox.setValue(0)
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
cb_function_curr = lambda value, idx=idx, slider=False: self.send_slider_value(
idx, value, slider)
cb_function_curr2 = lambda value, idx=idx, slider=True: self.send_slider_value(
idx, value, slider)
slider.valueChanged.connect(cb_function_curr2)
spinbox.valueChanged.connect(cb_function_curr)
labelmax = QLabel()
labelmax.setAlignment(Qt.AlignCenter)
labelmax.setText("%0.1f" %
(self.settings['max_pressure'][idx]))
labelmin = QLabel()
labelmin.setAlignment(Qt.AlignCenter)
labelmin.setText("%0.1f" %
(self.settings['min_pressure'][idx]))
layout.addWidget(labelmax)
layout.addWidget(slider)
layout.addWidget(labelmin)
layout.addWidget(spinbox)
layout.setAlignment(slider, Qt.AlignHCenter)
layout.setAlignment(spinbox, Qt.AlignHCenter)
label = QLabel()
label.setText("Chan. %d" % (chan_idx + 1))
label.setAlignment(Qt.AlignCenter)
layout_cluster.addWidget(label)
layout_cluster.addLayout(layout)
slider_group['slider'] = slider
slider_group['number'] = spinbox
on_button = QPushButton()
on_button.setCheckable(True)
on_button.setText("Off")
if self.settings['channel_states'][idx]:
on_button.toggle()
on_button.setText("On")
on_button.clicked.connect(
lambda state, idx=idx: self.send_channel_state(idx, state))
slider_group['on_off'] = on_button
layout_cluster.addWidget(on_button)
row_layout.addLayout(layout_cluster)
row_layout.addSpacing(20)
self.sliders.append(slider_group)
chan_idx += 1
all_rows_layout.addLayout(row_layout)
sliderbox.addLayout(all_rows_layout)
def __init__(self, title, jsp, num_rows=0):
super(JointStatePublisherGui, self).__init__()
self.jsp = jsp
self.joint_map = {}
self.vlayout = QVBoxLayout(self)
self.gridlayout = QGridLayout()
font = QFont("Helvetica", 9, QFont.Bold)
### Generate sliders ###
sliders = []
for name in self.jsp.joint_list:
if name not in self.jsp.free_joints:
continue
joint = self.jsp.free_joints[name]
if joint['min'] == joint['max']:
continue
joint_layout = QVBoxLayout()
row_layout = QHBoxLayout()
label = QLabel(name)
label.setFont(font)
row_layout.addWidget(label)
display = QLineEdit("0.00")
display.setAlignment(Qt.AlignRight)
display.setFont(font)
display.setReadOnly(True)
row_layout.addWidget(display)
joint_layout.addLayout(row_layout)
slider = QSlider(Qt.Horizontal)
slider.setFont(font)
slider.setRange(0, RANGE)
slider.setValue(RANGE/2)
joint_layout.addWidget(slider)
self.joint_map[name] = {'slidervalue': 0, 'display': display,
'slider': slider, 'joint': joint}
# Connect to the signal provided by QSignal
slider.valueChanged.connect(self.onValueChanged)
sliders.append(joint_layout)
# Determine number of rows to be used in grid
self.num_rows = num_rows
# if desired num of rows wasn't set, default behaviour is a vertical layout
if self.num_rows == 0:
self.num_rows = len(sliders) # equals VBoxLayout
# Generate positions in grid and place sliders there
self.positions = self.generate_grid_positions(len(sliders), self.num_rows)
for item, pos in zip(sliders, self.positions):
self.gridlayout.addLayout(item, *pos)
# Set zero positions read from parameters
self.center()
# Synchronize slider and displayed value
self.sliderUpdate(None)
# Set up a signal for updating the sliders based on external joint info
self.sliderUpdateTrigger.connect(self.updateSliders)
self.vlayout.addLayout(self.gridlayout)
# Buttons for randomizing and centering sliders and
# Spinbox for on-the-fly selecting number of rows
self.randbutton = QPushButton('Randomize', self)
self.randbutton.clicked.connect(self.randomize_event)
self.vlayout.addWidget(self.randbutton)
self.ctrbutton = QPushButton('Center', self)
self.ctrbutton.clicked.connect(self.center_event)
self.vlayout.addWidget(self.ctrbutton)
self.maxrowsupdown = QSpinBox()
self.maxrowsupdown.setMinimum(1)
self.maxrowsupdown.setMaximum(len(sliders))
self.maxrowsupdown.setValue(self.num_rows)
self.maxrowsupdown.lineEdit().setReadOnly(True) # don't edit it by hand to avoid weird resizing of window
self.maxrowsupdown.valueChanged.connect(self.reorggrid_event)
self.vlayout.addWidget(self.maxrowsupdown)
def init_sliders(self):
sliderbox = self._widget.findChild(QLayout, 'Sliders')
graph_button = QPushButton()
graph_button.setCheckable(True)
graph_button.setText("Graph Off")
graph_button.toggle()
graph_button.clicked.connect(self.set_graph_state)
self.graph_button = graph_button
firstCol = QVBoxLayout()
firstCol.addWidget(graph_button)
sliderbox.addLayout(firstCol)
self.sliders = []
all_rows_layout = QVBoxLayout()
chan_idx = 0
for num_channels_row in self.settings['num_channels']:
row_layout = QHBoxLayout()
for i in range(num_channels_row):
idx = chan_idx * 1
slider_group = {
'slider_p': None,
'number_p': None,
'slider_i': None,
'number_i': None,
'slider_d': None,
'number_d': None,
'on_off': None
}
layout_cluster = QVBoxLayout()
slider_cluster = QHBoxLayout()
label = QLabel()
label.setText("Chan. %d" % (idx + 1))
label.setAlignment(Qt.AlignCenter)
layout_cluster.addWidget(label)
for j in range(3):
layout = QVBoxLayout()
layout.setAlignment(Qt.AlignHCenter)
if j == 0:
maxrange = 1.0
elif j == 1:
maxrange = 10
elif j == 2:
maxrange = 10
slider = QSlider(Qt.Vertical)
slider.setMinimum(0)
slider.setMaximum(maxrange * 100)
slider.setValue(self.settings['pid_gains'][chan_idx][j] *
100)
slider.setTickPosition(QSlider.TicksRight)
slider.setTickInterval(maxrange / 100.0)
spinbox = QDoubleSpinBox()
spinbox.setMinimum(0)
spinbox.setMaximum(maxrange)
spinbox.setValue(self.settings['pid_gains'][chan_idx][j])
spinbox.setDecimals(2)
spinbox.setSingleStep(maxrange / 100.0)
cb_function_number = lambda value, idx=idx, gain_idx=j, slider=False: self.send_slider_value(
idx, gain_idx, value, slider)
cb_function_slider = lambda value, idx=idx, gain_idx=j, slider=True: self.send_slider_value(
idx, gain_idx, value, slider)
slider.valueChanged.connect(cb_function_slider)
spinbox.valueChanged.connect(cb_function_number)
label = QLabel()
label.setAlignment(Qt.AlignCenter)
if j == 0:
slider_group['slider_p'] = slider
slider_group['number_p'] = spinbox
label.setText("P")
elif j == 1:
slider_group['slider_i'] = slider
slider_group['number_i'] = spinbox
label.setText("I")
elif j == 2:
slider_group['slider_d'] = slider
slider_group['number_d'] = spinbox
label.setText("D")
labelmax = QLabel()
labelmax.setAlignment(Qt.AlignCenter)
labelmax.setText("%0.1f" % (maxrange))
labelmin = QLabel()
labelmin.setAlignment(Qt.AlignCenter)
labelmin.setText("0")
layout.addWidget(label)
layout.addWidget(labelmax)
layout.addWidget(slider, Qt.AlignHCenter)
layout.addWidget(labelmin)
layout.addWidget(spinbox, Qt.AlignHCenter)
layout.setAlignment(slider, Qt.AlignHCenter)
layout.setAlignment(spinbox, Qt.AlignHCenter)
slider_cluster.addLayout(layout)
on_button = QPushButton()
on_button.setCheckable(True)
on_button.setText("Off")
if self.settings['channel_states'][chan_idx]:
on_button.toggle()
on_button.setText("On")
on_button.clicked.connect(
lambda state, idx=idx: self.send_channel_state(idx, state))
slider_group['on_off'] = on_button
layout_cluster.addLayout(slider_cluster)
layout_cluster.addWidget(on_button)
row_layout.addLayout(layout_cluster)
row_layout.addSpacing(20)
self.sliders.append(slider_group)
chan_idx += 1
all_rows_layout.addLayout(row_layout)
sliderbox.addLayout(all_rows_layout)
def __init__(self, content):
super(SliderPublisher, self).__init__()
content = content.replace('\t', ' ')
# get message types
self.publishers = {}
self.values = {}
pkgs = []
# to keep track of key ordering in the yaml file
order = []
old = []
for topic, info in yaml.load(content).items():
pkg, msg = info['type'].split('/')
pkgs.append(__import__(pkg, globals(), locals(), ['msg']))
self.publishers[topic] = Publisher(topic,
getattr(pkgs[-1].msg,
msg), info)
order.append((topic, []))
for key in info:
self.values[key] = info[key]
order[-1][1].append((content.find(' ' + key + ':'), key))
old.append((content.find(' ' + key + ':'), key))
for bound in ['min', 'max']:
self.values[key][bound] = float(self.values[key][bound])
self.values[key]['val'] = 0
order[-1][1].sort()
order.sort(key=lambda x: x[1][0][0])
# build sliders - thanks joint_state_publisher
sliderUpdateTrigger = Signal()
self.vlayout = QVBoxLayout(self)
self.gridlayout = QGridLayout()
font = QFont("Helvetica", 9, QFont.Bold)
topic_font = QFont("Helvetica", 10, QFont.Bold)
sliders = []
self.key_map = {}
y = 0
for topic, keys in order:
topic_layout = QVBoxLayout()
label = QLabel(topic)
label.setFont(topic_font)
topic_layout.addWidget(label)
self.gridlayout.addLayout(topic_layout, *(y, 0))
y += 1
for idx, key in keys:
key_layout = QVBoxLayout()
row_layout = QHBoxLayout()
label = QLabel(key)
label.setFont(font)
row_layout.addWidget(label)
display = QLineEdit("0.00")
display.setAlignment(Qt.AlignRight)
display.setFont(font)
display.setReadOnly(True)
row_layout.addWidget(display)
key_layout.addLayout(row_layout)
slider = QSlider(Qt.Horizontal)
slider.setFont(font)
slider.setRange(0, RANGE)
slider.setValue(RANGE / 2)
key_layout.addWidget(slider)
self.key_map[key] = {
'slidervalue': 0,
'display': display,
'slider': slider
}
slider.valueChanged.connect(self.onValueChanged)
self.gridlayout.addLayout(key_layout, *(y, 0))
y += 1
#sliders.append(key_layout)
# Generate positions in grid and place sliders there
#self.positions = [(y,0) for y in range(len(sliders))]
#for item, pos in zip(sliders, self.positions):
# self.gridlayout.addLayout(item, *pos)
self.vlayout.addLayout(self.gridlayout)
self.ctrbutton = QPushButton('Center', self)
self.ctrbutton.clicked.connect(self.center)
self.vlayout.addWidget(self.ctrbutton)
self.center(1)
def init_sliders(self):
sliderbox = self._widget.findChild(QLayout,'Sliders')
firstCol = QVBoxLayout()
graph_button=QPushButton()
graph_button.setCheckable(True)
graph_button.setText("Graph Off")
graph_button.toggle()
graph_button.clicked.connect(self.set_graph_state)
self.graph_button = graph_button
reset_button=QPushButton()
reset_button.setCheckable(False)
reset_button.setText("Reset")
reset_button.clicked.connect(self.set_reset)
self.graph_button = graph_button
self.reset_button = reset_button
firstCol.addWidget(graph_button)
firstCol.addWidget(reset_button)
firstCol.addWidget(graph_button)
firstCol.setAlignment(graph_button,Qt.AlignVCenter)
zero_button=QPushButton()
zero_button.setCheckable(False)
zero_button.setText("Set All Zero")
zero_button.clicked.connect(self.set_pressure_zero)
self.zero_button = zero_button
firstCol.addWidget(zero_button)
firstCol.setAlignment(zero_button,Qt.AlignVCenter)
transition_box = QVBoxLayout()
label = QLabel()
label.setAlignment(Qt.AlignCenter)
label.setText("Transition Time")
spinbox = QDoubleSpinBox()
spinbox.setMinimum(0)
spinbox.setMaximum(10)
spinbox.setValue(self.settings['transitions'])
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
spinbox.setSuffix(" sec")
spinbox.valueChanged.connect(self.set_transition_value)
transition_box.addWidget(label)
transition_box.addWidget(spinbox)
transition_box.setAlignment(label,Qt.AlignBottom)
transition_box.setAlignment(spinbox,Qt.AlignTop)
firstCol.addLayout(transition_box)
self.sliders = []
sliderbox.addLayout(firstCol)
all_rows_layout = QVBoxLayout()
g_idx = 0
for row in self.settings['gui_config']:
num_groups_row = len(row)
row_layout = QHBoxLayout()
for gr_idx, s_group in enumerate(row):
g_channels = s_group['channels']
g_layout = s_group['layout']
if 'horiz' in g_layout:
group_layout = QHBoxLayout()
else:
group_layout = QVBoxLayout()
control_group = {'sliders': [], 'on_off': None}
label = QLabel()
label.setText("Group. %d"%(g_idx+1))
label.setAlignment(Qt.AlignCenter)
group_layout.addWidget(label)
for c_idx, s_idx in enumerate(g_channels):
idx = s_idx*1
slider_group={'slider':None, 'number':None}
layout_cluster = QVBoxLayout()
labelfirst = QLabel()
labelfirst.setAlignment(Qt.AlignCenter)
labellast = QLabel()
labellast.setAlignment(Qt.AlignCenter)
layout = QVBoxLayout()
if 'diff' in g_layout and c_idx == 0:
sublayout=QHBoxLayout()
layout.setAlignment(Qt.AlignVCenter)
slider = QSlider(Qt.Horizontal)
slider.setMinimum(-100)
slider.setMaximum(100)
slider.setValue(0)
slider.setTickPosition(QSlider.TicksRight)
slider.setTickInterval(20)
spinbox = QDoubleSpinBox()
spinbox.setMinimum(-10)
spinbox.setMaximum(10)
spinbox.setValue(0)
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
labellast.setText("%0.1f"%(10)) # These are flipped becasue of order
labelfirst.setText("%0.1f"%(-10))
max_label = labellast
min_label = labelfirst
else:
layout.setAlignment(Qt.AlignHCenter)
slider = QSlider(Qt.Vertical)
slider.setMinimum(self.settings['min_pressure'][idx]*10.0)
slider.setMaximum(self.settings['max_pressure'][idx]*10.0)
slider.setValue(0)
slider.setTickPosition(QSlider.TicksRight)
slider.setTickInterval(20)
spinbox = QDoubleSpinBox()
spinbox.setMinimum(self.settings['min_pressure'][idx])
spinbox.setMaximum(self.settings['max_pressure'][idx])
spinbox.setValue(0)
spinbox.setDecimals(1)
spinbox.setSingleStep(0.1)
labelfirst.setText("%0.1f"%(self.settings['max_pressure'][idx]))
labellast.setText("%0.1f"%(self.settings['min_pressure'][idx]))
max_label = labelfirst
min_label = labellast
cb_function_number = lambda value, g_idx=g_idx, s_idx=c_idx, slider=False: self.send_slider_value(g_idx,s_idx,value,slider)
cb_function_slider = lambda value, g_idx=g_idx, s_idx=c_idx, slider=True: self.send_slider_value(g_idx,s_idx,value,slider)
slider.valueChanged.connect(cb_function_slider)
spinbox.valueChanged.connect(cb_function_number)
if 'diff' in g_layout and c_idx == 0:
sublayout.addWidget(labelfirst)
sublayout.addWidget(slider)
sublayout.addWidget(labellast)
layout.addWidget(spinbox)
layout.addLayout(sublayout)
else:
layout.addWidget(labelfirst)
layout.addWidget(slider)
layout.addWidget(labellast)
layout.addWidget(spinbox)
layout.setAlignment(slider, Qt.AlignHCenter)
layout.setAlignment(spinbox, Qt.AlignHCenter)
layout_cluster.addLayout(layout)
slider_group['slider'] = slider
slider_group['number'] = spinbox
slider_group['max_label'] = max_label
slider_group['min_label'] = min_label
control_group['sliders'].append(slider_group)
group_layout.addLayout(layout_cluster)
on_button=QPushButton()
on_button.setCheckable(True)
on_button.setText("Off")
if self.settings['channel_states'][idx]:
on_button.toggle()
on_button.setText("On")
on_button.clicked.connect(lambda state, g_idx=g_idx: self.send_channel_state(g_idx,state))
group_layout.addWidget(on_button)
row_layout.addLayout(group_layout)
row_layout.addSpacing(20)
control_group['on_off'] = on_button
self.sliders.append(control_group)
g_idx+=1
all_rows_layout.addLayout(row_layout)
sliderbox.addLayout(all_rows_layout)
def createSlider(self, minimum, maximum, default_value, tick_interval):
"""
Create a QtSlider with specified properties
Parameters:
@param minimum Minimum value for slider
@param maximum Maximum value for slider
@param default_value Initial value the slider is set to
@param tick_inverval Integer value specifying difference between
successive ticks
@return Slider value
"""
slider = QSlider(Qt.Horizontal)
slider.setMinimum(minimum)
slider.setMaximum(maximum)
slider.setValue(default_value)
slider.setTickPosition(QSlider.TicksBelow)
slider.setTickInterval(tick_interval)
return slider
def createEditor(self, parent, option, index):
print option
print index.column()
indices = [2, 3, 4]
if index.column() not in indices:
return None
print "create_edit"
if index.column() == 3:
widget = QWidget(parent)
slider = QSlider(Qt.Horizontal, widget)
text_edit = QLineEdit(widget)
text_edit.setFocus()
text_edit.selectAll()
text_edit.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
hbox = QVBoxLayout()
# slider.setMinimumWidth(400)
# hbox.setMargin(0);
hbox.setContentsMargins(2,1,2,1);
# min_label = QLabel("min")
# max_label = QLabel("max")
# vbox.addWidget(min_label)
hbox.addWidget(slider)
hbox.addWidget(text_edit)
# vbox.addWidget(max_label)
widget.setLayout(hbox)
# widget.setMinimumWidth(400)
slider.setMinimumHeight(32)
text_edit.setMinimumHeight(36)
widget.setMinimumHeight(80)
widget.setAutoFillBackground(True)
widget.setStyleSheet(".QWidget { background:rgb(200, 200, 200); margin:0px; border:1px solid rgb(170, 170, 170); }")
# parent.setMinimumWidth(300)
row = index.row()
imin = index.sibling(row, self._column_names.index("min"))
imax = index.sibling(row, self._column_names.index("max"))
smin = index.model().data(imin, Qt.EditRole)
smax = index.model().data(imax, Qt.EditRole)
fmin = 0
fmax = 100
def isFloat(s):
try:
float(s)
return True
except:
return False
if isFloat(smin):
fmin = float(smin)
if isFloat(smax):
fmax = float(smax)
print fmin, fmax
slider.setMinimum(int(fmin * 100))
slider.setMaximum(int(fmax * 100))
slider.setMouseTracking(True)
@Slot(int)
def sliderValueChanged(value):
text_edit.setText(str(float(value)/100.))
print "slider value changed to %d" % value
text_edit.setFocus()
text_edit.selectAll()
pass
@Slot()
def sliderDown():
print "slider pressed"
@Slot()
def sliderUp():
print "slider released"
@Slot()
def editingFinished():
text = text_edit.text()
value = float(text)
nvalue = value
nvalue = min(nvalue, fmax)
nvalue = max(nvalue, fmin)
# print "nvalue is", nvalue
if value != nvalue:
text_edit.setText(str(nvalue))
svalue = int(nvalue*100)
print "text changed to %s" % text
print "nvalue is", nvalue
print "svalue is %d" % svalue
slider.blockSignals(True)
slider.setSliderPosition(svalue)
slider.blockSignals(False)
pass
@Slot(str)
def lineEditTextChanged(text):
# text_edit.setText(str(value))
# slider.setSliderDown(True)
# slider.sliderPressed.emit()
print "setSliderDown"
if not isFloat(text):
return
value = float(text)
nvalue = value
# nvalue = min(nvalue, fmax)
# nvalue = max(nvalue, fmin)
# print "nvalue is", nvalue
if value != nvalue:
text_edit.setText(str(nvalue))
svalue = int(nvalue*100)
print "text changed to %s" % text
print "nvalue is", nvalue
print "svalue is %d" % svalue
slider.blockSignals(True)
slider.setSliderPosition(svalue)
slider.blockSignals(False)
pass
slider.valueChanged.connect(sliderValueChanged)
slider.sliderPressed.connect(sliderDown)
slider.sliderReleased.connect(sliderUp)
text_edit.textChanged.connect(lineEditTextChanged)
text_edit.editingFinished.connect(editingFinished)
text_edit.selectAll()
text_edit.setFocus()
rx = QRegExp("^-?([1-9]\d*|0)(\.\d*)?$")
v = QRegExpValidator(rx)
text_edit.setValidator(v)
widget.setFocusProxy(text_edit)
edt = widget
else:
edt = QLineEdit(parent)
if index.column() == 2:
edt.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
elif index.column() == 4:
edt.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
rx = QRegExp("^-?([1-9]\d*|0)(\.\d*)?$")
v = QRegExpValidator(rx);
edt.setValidator(v)
# edt.setInputMask("#00000000")
return edt
def __init__(self, node_ns, controller, urdf=None, *args, **kwargs):
super(JointPositionControllerWidget, self).__init__(*args, **kwargs)
self._controller = controller
self._urdf = urdf
loadUi('Controller.ui', self)
self.controller_name.setText(controller.name)
self.controller_type.setText(controller.type)
controller_ns = rospy.resolve_name(controller.name, node_ns)
joint_name_widget = QLabel()
joint_position_widget = QLineEdit()
joint_position_widget.setReadOnly(True)
joint_position_widget.setAlignment(Qt.AlignRight)
joint_position_widget.setText(str(0.0))
extras_layout = QGridLayout()
extras_layout.addWidget(joint_name_widget, 0, 0)
extras_layout.addWidget(joint_position_widget, 0, 1)
extras = QWidget()
extras.setLayout(extras_layout)
self.layout().addWidget(extras)
slider_range = (0, 10000)
limits = {'min': 0.0, 'max': 3.14}
if self._urdf is not None:
joint_name = next(iter([
resource
for interface in controller.claimed_resources
if interface.hardware_interface == \
'hardware_interface::PositionJointInterface'
for resource in interface.resources
]), None)
if joint_name is not None:
joint_name_widget.setText(joint_name)
joint_limit = self._urdf.xpath(
'/robot/joint[@name=$name]/limit', name=joint_name)
if joint_limit:
l = joint_limit[0]
limits = {
'min': float(joint_limit[0].get('lower')),
'max': float(joint_limit[0].get('upper'))
}
pub = rospy.Publisher(controller_ns + '/command',
std_msgs.msg.Float64,
queue_size=10)
def on_value_changed(value):
value = limits['min'] + value / float(
slider_range[1] - slider_range[0]) * (limits['max'] -
limits['min'])
joint_position_widget.setText(str(value))
pub.publish(value)
slider = QSlider(Qt.Horizontal)
slider.setRange(slider_range[0], slider_range[1])
slider.valueChanged.connect(on_value_changed)
extras_layout.addWidget(slider, 1, 0, 1, 2)