예제 #1
0
    def __init__(self, window, parent=None):
        super(GraphPrefDialog, self).__init__()

        self.dialog_layout = QtGui.QFormLayout()
        self.setLayout(self.dialog_layout)
        self.ratio = 8.325  # For 1 second

        self.window = window

        self.temp_title = QtGui.QLabel("Graph Setup")
        self.scale_title = QtGui.QLabel("RoC Graph Axis Setup")
        self.newfont = QtGui.QFont()
        self.newfont.setBold(True)
        self.newfont.setPointSize(10)
        self.temp_title.setFont(self.newfont)
        self.scale_title.setFont(self.newfont)

        self.scale_slider = QtGui.QSlider(QtCore.Qt.Horizontal)
        self.scale_slider.setTickPosition(QtGui.QSlider.TicksBothSides)
        self.scale_slider.setSingleStep(1)
        self.scale_slider.setValue(self.window.scale)
        self.scale_slider.setTickInterval(1)
        self.scale_slider.setRange(0.5, 10)
        self.scale_slider.valueChanged.connect(self.slider_change)
        self.scale_slider_lable = QtGui.QLabel("Set X-Axis Scale")
        self.scale_slider_val = QtGui.QLabel(str(self.window.scale))

        self.yrange_label = QtGui.QLabel("Set Y-Axis Range")
        self.yrange_start_txt = QtGui.QLineEdit(str(self.window.ystart))
        self.yrange_mid_label = QtGui.QLabel("to")
        self.yrange_end_txt = QtGui.QLineEdit(str(self.window.yend))

        regexp = QtCore.QRegExp(
            '[+-]?\\d*\\.?\\d+')  # regex expression from 0 - 100
        self.validator = QtGui.QRegExpValidator(regexp)
        self.yrange_start_txt.setValidator(self.validator)
        self.yrange_end_txt.setValidator(self.validator)

        self.yrange_start_txt.textChanged.connect(self.range_change)
        self.yrange_end_txt.textChanged.connect(self.range_change)

        self.legend_cb = QtGui.QCheckBox('Show Legend', self)

        if (self.window.showLegend == "True"):
            self.legend_cb.setChecked(True)
        else:
            self.legend_cb.setChecked(False)

        self.legend_cb.stateChanged.connect(self.checkbox_change_leg)

        self.int_cb = QtGui.QCheckBox('Interactive Graphs', self)

        if (self.window.int == "True"):
            self.int_cb.setChecked(True)
        else:
            self.int_cb.setChecked(False)

        self.int_cb.stateChanged.connect(self.checkbox_change_int)

        self.initUI()
예제 #2
0
    def __init__(self, window, gas_or_air, parent):
        super(BorderLessDiaglogs, self).__init__(parent)
        self.setWindowFlags(QtCore.Qt.FramelessWindowHint
                            | QtCore.Qt.WindowStaysOnTopHint)

        self.window = window
        self.gas_or_air = gas_or_air
        #set font size
        self.font = QtGui.QFont()
        self.font.setPointSize(16)
        #set placeholder text and resize
        self.text = QtGui.QLineEdit("", self)
        self.text.setFont(self.font)
        self.text.setPlaceholderText("Enter Level")
        self.text.setMinimumSize(120, 20)

        #ensure user can only enter doubles
        regexp = QtCore.QRegExp(
            '^0*(?:[1-9][0-9]?|100)$')  # regex expression from 0 - 100
        self.validator = QtGui.QRegExpValidator(regexp)
        self.text.setValidator(self.validator)
        self.resize(self.text.width(), self.text.height())

        # Connecting key events to functions
        self.connect(
            QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Escape), self),
            QtCore.SIGNAL('activated()'), self.Exit)
        self.connect(
            QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Return), self),
            QtCore.SIGNAL('activated()'), self.Return)
        self.installEventFilter(self)

        self.setFocus()
        self.show()
예제 #3
0
    def _initialise_gui_widgets(self):
        """
        Create all the widgets for the window.
        """
        # # Main widget
        self.main_widget = QtGui.QWidget()

        # # Address label
        self.address_label = QtGui.QLabel("Server:")
        self.address_label.setAlignment(QtCore.Qt.AlignRight
                                        | QtCore.Qt.AlignVCenter)

        # # Address bar
        self.address_bar = QtGui.QLineEdit()

        # Create a regex validator for the IP address
        ip_values = "(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])"
        ip_regex = QtCore.QRegExp("^" + ip_values + "\\." + ip_values + "\\." +
                                  ip_values + "\\." + ip_values + "$")
        ip_validator = QtGui.QRegExpValidator(ip_regex, self)

        self.address_bar.setValidator(ip_validator)
        self.address_bar.setText("192.168.42.1")

        # # Port bar
        self.port_bar = QtGui.QLineEdit()
        self.port_bar.setValidator(QtGui.QIntValidator())
        self.port_bar.setText("12345")

        # # Connect button
        self.connect_button = QtGui.QPushButton("&Connect")
        self.connect_button.clicked.connect(self._toggle_connect)

        # # Plot widgets
        self.plot_widgets = {
            'accelerometer': plt.UpdatingPlotWidget(title='Accelerometer'),
            'magnetometer': plt.UpdatingPlotWidget(title='Magnetometer'),
            'gyroscope': plt.UpdatingPlotWidget(title='Gyroscope'),
            'barometer': plt.UpdatingPlotWidget(title='Barometer'),
            'gps-pos': plt.UpdatingPlotWidget(title='GPS Position')
        }

        for name, widget in self.plot_widgets.items():
            if name == 'barometer':
                widget.add_item('altitude', pen='k')
                widget.add_item('filtered', pen='r')
                widget.add_item('altitude_gps', pen='b')
                self.filter1 = KalmanFilter(x_prior=0,
                                            P_prior=2,
                                            A=1,
                                            B=0,
                                            H=1,
                                            Q=0.005,
                                            R=1.02958)
            elif name == 'gps-pos':
                widget.add_item('position', symbol='o')
            else:
                widget.add_item('x', pen='r')
                widget.add_item('y', pen='g')
                widget.add_item('z', pen='b')
예제 #4
0
    def __init__(self):
        super(TemplateBaseClass, self).__init__()

        # Create the main window
        self.ui = WindowTemplate()
        self.ui.setupUi(self)
        self.setFont(QtGui.QFont('Arial', 10))

        # Fill beam_id and bit_select combobox
        for i in range(1, 20):
            self.ui.cbo_beamid.addItem('%d' % i)
        self.ui.cbo_beamid.setCurrentIndex(-1)
        for r in roach_list:
            self.ui.cbo_roach.addItem(r)
        self.ui.cbo_roach.setCurrentIndex(-1)

        # Connect signal/slots
        self.ui.cbo_roach.currentIndexChanged.connect(self.on_board_change)
        self.ui.edt_noisecal_delay.editingFinished.connect(
            self.on_noisecal_delay_change)
        self.ui.edt_noisecal_on.editingFinished.connect(
            self.on_noisecal_on_change)
        self.ui.edt_noisecal_off.editingFinished.connect(
            self.on_noisecal_off_change)
        self.ui.rb_unit0.toggled.connect(self.on_unit_change)
        self.ui.rb_unit1.toggled.connect(self.on_unit_change)
        self.ui.cb_tvg.stateChanged.connect(self.on_tvg_change)
        self.ui.spn_rfgain0.valueChanged.connect(self.on_rfgain_change)
        self.ui.spn_rfgain1.valueChanged.connect(self.on_rfgain_change)
        self.ui.cbo_beamid.currentIndexChanged.connect(self.on_beamid_change)
        self.ui.edt_fftshift.editingFinished.connect(self.on_fftshift_change)
        self.ui.edt_dgain0.editingFinished.connect(self.on_digital_gain_change)
        self.ui.edt_dgain1.editingFinished.connect(self.on_digital_gain_change)
        self.ui.spn_acclen.valueChanged.connect(self.on_acclen_change)
        self.ui.cbo_bitsel_0.currentIndexChanged.connect(self.on_bitsel_change)
        self.ui.cbo_bitsel_1.currentIndexChanged.connect(self.on_bitsel_change)
        self.ui.cbo_bitsel_2.currentIndexChanged.connect(self.on_bitsel_change)
        self.ui.cbo_bitsel_3.currentIndexChanged.connect(self.on_bitsel_change)
        self.ui.edt_dest_ip_0.editingFinished.connect(self.on_dest_ip_change)
        self.ui.edt_dest_ip_1.editingFinished.connect(self.on_dest_ip_change)
        self.ui.edt_dest_ip_2.editingFinished.connect(self.on_dest_ip_change)
        self.ui.edt_dest_ip_3.editingFinished.connect(self.on_dest_ip_change)
        self.ui.edt_fabric_ip_0.editingFinished.connect(
            self.on_fabric_ip_change)
        self.ui.edt_fabric_ip_1.editingFinished.connect(
            self.on_fabric_ip_change)
        self.ui.edt_fabric_ip_2.editingFinished.connect(
            self.on_fabric_ip_change)
        self.ui.edt_fabric_ip_3.editingFinished.connect(
            self.on_fabric_ip_change)
        self.ui.btn_reset.clicked.connect(self.on_reset)
        self.ui.btn_arm.clicked.connect(self.on_arm)

        # Input widgets validator
        v = QtGui.QIntValidator(0, 2**48 - 1, self)
        for w in (self.ui.edt_noisecal_delay, self.ui.edt_noisecal_on,
                  self.ui.edt_noisecal_off):
            w.setValidator(v)
        self.ui.edt_fftshift.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('0x[0-9A-Fa-f]{1,8}')))
        v = QtGui.QRegExpValidator(QtCore.QRegExp('0x[0-9A-Fa-f]{1,4}'))
        for w in (self.ui.edt_dgain0, self.ui.edt_dgain1):
            w.setValidator(v)
        v = QtGui.QRegExpValidator(
            QtCore.QRegExp(
                '(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]):\d{1,5}'
            ))
        for i in range(4):
            getattr(self.ui, 'edt_dest_ip_{:d}'.format(i)).setValidator(v)
        for i in range(4):
            getattr(self.ui, 'edt_fabric_ip_{:d}'.format(i)).setValidator(v)

        # Disable all widgets except the Roach board combobox
        interactive_widget_prefixes = ('edt', 'cbo', 'cb', 'rb', 'spn', 'btn')
        for name, obj in vars(self.ui).iteritems():
            is_interactive = False
            for prefix in interactive_widget_prefixes:
                if name.startswith(prefix):
                    is_interactive = True
                    break
            if name != 'cbo_roach' and is_interactive: obj.setDisabled(True)

        self.plotter = Plotter(self.ui.plot_area)
        self.timer_id = 0
        self.fpga = None
        self.unit = 0
        self.prefix = 'u%d_' % self.unit
예제 #5
0
 def setFilterRegExp(self, pattern):
     if isinstance(pattern, str):
         pattern = QtCore.QRegExp(
             pattern, QtCore.Qt.CaseInsensitive,
             QtCore.QRegExp.FixedString)
     super(SearchProxyModel, self).setFilterRegExp(pattern)
예제 #6
0
    def __init__(self):
        # super().__init__(show=True, title="Putzini Tracker")
        super().__init__()

        self.plot_widget = pg.GraphicsLayoutWidget()
        self.top_layout = QtGui.QGridLayout()
        self.setLayout(self.top_layout)
        self.top_layout.addWidget(self.plot_widget)
        self.resize(850 * (1 + int(tilt_fig)), 700)
        self.setWindowTitle('Putzini')
        self.opts = PutziniConfig()

        # START PLOTS ---
        self.pos_coord = self.plot_widget.addPlot(
            title="In-plane (color: angle)", row=0, col=0)
        self.pos_coord.setRange(yRange=self.opts.range_y,
                                xRange=self.opts.range_x)
        self.pos_coord.setAspectLocked(True, ratio=1)
        self.pos_coord.setLabel('left', "Y", units='cm')
        self.pos_coord.setLabel('bottom', "X", units='cm')
        self.all_points = pg.ScatterPlotItem(size=10)
        self.current_point = pg.ScatterPlotItem(size=30)
        self.anchors = {}
        mapimg = imread(self.opts.keepout_img)
        self.map = pg.ImageItem()
        self.map.setImage(image=mapimg.T)
        self.map.setPxMode(False)
        self.map.setRect(
            QtCore.QRect(-mapimg.shape[1] // 2, -mapimg.shape[0] // 2,
                         mapimg.shape[0], mapimg.shape[1]))
        self.pos_coord.addItem(self.map)
        for lbl, x, y in zip(self.opts.anchor_names, self.opts.anchor_x,
                             self.opts.anchor_y):
            self.anchors[lbl] = pg.ScatterPlotItem(size=10, symbol='o')
            self.pos_coord.addItem(self.anchors[lbl])
            self.anchors[lbl].addPoints(x=[x],
                                        y=[y],
                                        brush=None,
                                        pen='k',
                                        pxMode=False,
                                        size=10)
        print(self.anchors)
        self.arka = pg.ScatterPlotItem(size=10, symbol='o', pxMode=False)
        # for lbl, x, y in zip(self.opts.anchor_names, self.opts.anchor_x, self.opts.anchor_y):
        self.pos_coord.addItem(self.current_point)
        self.pos_coord.addItem(self.arka)
        self.pos_coord.addItem(self.all_points)
        self.arka.setData(x=[0],
                          y=[0],
                          size=146,
                          pen=(0, 100, 0),
                          brush=(0, 100, 0))

        if tilt_fig:
            self.tilt_coord = self.plot_widget.addPlot(
                title="Out-of-plane tilt", row=0, col=1)
            self.tilt_coord.setLabel('left', "tilt Y", units='deg')
            self.tilt_coord.setLabel('bottom', "tilt X", units='deg')
            self.tilt_all_points = pg.ScatterPlotItem(size=10)
            self.tilt_current_point = pg.ScatterPlotItem(size=30)
            self.tilt_coord.addItem(self.tilt_current_point)
            self.tilt_coord.addItem(self.tilt_all_points)
        # STOP PLOTS ---

        # START CONTROLS ---
        self.control_layout = QtGui.QFormLayout(verticalSpacing=1)

        self.update_graph = QtGui.QCheckBox('Update Graph')
        self.update_graph.setChecked(True)
        self.control_layout.addRow(self.update_graph)

        self.keep_traces = QtGui.QCheckBox('Keep Traces')
        self.keep_traces.setChecked(False)
        self.control_layout.addRow(self.keep_traces)

        move_command = QtGui.QLineEdit('stop()')
        move_command.returnPressed.connect(
            lambda: self.command('move', move_command.text()))
        self.control_layout.addRow(QtGui.QLabel('Move cmd'), move_command)

        abs_move = QtGui.QLineEdit('0, 0, 50, 10')
        abs_move.setValidator(
            QtGui.QRegExpValidator(
                QtCore.QRegExp('-?\d+,\s*-?\d+,\s*-?\d+,\s*\d+')))
        abs_move.returnPressed.connect(
            lambda: self.command('move', f'moveToPos({abs_move.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Abs move'), abs_move)

        rel_move = QtGui.QLineEdit('0, 0, 50, 10')
        rel_move.setValidator(
            QtGui.QRegExpValidator(
                QtCore.QRegExp('-?\d+,\s*-?\d+,\s*-?\d+,\s*\d+')))
        rel_move.returnPressed.connect(
            lambda: self.command('move', f'moveByPos({rel_move.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Rel move'), rel_move)

        straight_move = QtGui.QLineEdit('0, 50, 10')
        straight_move.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('-?\d+,\s*-?\d+')))
        straight_move.returnPressed.connect(
            lambda: self.command('move', f'moveStraight({rel_move.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Straight move'),
                                   straight_move)

        abs_turn = QtGui.QLineEdit('0, 50')
        abs_turn.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('-?\d+,\s*-?\d+')))
        abs_turn.returnPressed.connect(
            lambda: self.command('move', f'moveToAngle({abs_turn.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Abs turn'), abs_turn)

        rel_turn = QtGui.QLineEdit('0, 50')
        rel_turn.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('-?\d+,\s*-?\d+')))
        rel_turn.returnPressed.connect(
            lambda: self.command('move', f'moveByAngle({rel_turn.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Rel turn'), rel_turn)

        look_at = QtGui.QLineEdit('0, 0, 50')
        look_at.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('-?\d+,\s*-?\d+,\s*-?\d+')))
        look_at.returnPressed.connect(
            lambda: self.command('move', f'lookAtPos({look_at.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Look at'), look_at)

        random_rng = QtGui.QLineEdit(
            f'{self.opts.range_x[0]}, {self.opts.range_x[1]}, {self.opts.range_y[0]}, {self.opts.range_y[1]}'
        )
        random_rng.setValidator(
            QtGui.QRegExpValidator(
                QtCore.QRegExp('-?\d+,\s*-?\d+,\s*-?\d+,\s*-?\d+')))
        self.control_layout.addRow(QtGui.QLabel('Rnd Range'), random_rng)

        random_bf = QtGui.QLineEdit('20, 15, 50, 1')
        random_bf.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('\d+,\s*\d+,\s*\d+,\s*\d')))
        random_bf.returnPressed.connect(lambda: self.command(
            'move', f'moveBackForth({random_bf.text()},{random_rng.text()})'))
        self.control_layout.addRow(QtGui.QLabel('B-F'), random_bf)

        random = QtGui.QLineEdit('50')
        random.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('\d+')))
        random.returnPressed.connect(lambda: self.command(
            'move', f'moveRandom({random.text()},{random_rng.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Zigzag'), random)

        circle = QtGui.QLineEdit('50, 1')  # speed, direction
        circle.setValidator(
            QtGui.QRegExpValidator(QtCore.QRegExp('\d+,\s*\d+')))
        circle.returnPressed.connect(
            lambda: self.command('move', f'moveCircle({circle.text()})'))
        self.control_layout.addRow(QtGui.QLabel('Circle'), circle)

        override = QtGui.QCheckBox('Override Keepout')
        override.stateChanged.connect(
            lambda state: self.client.m_client.publish(
                'putzini/override', '1' if int(state) == 2 else '0'))
        override.setChecked(False)
        self.control_layout.addRow(override)

        stop = pg.QtGui.QPushButton('STOP')
        stop.clicked.connect(lambda: self.command('move', 'stop()'))
        done = pg.QtGui.QPushButton('Set Ready')
        done.clicked.connect(
            lambda: self.client.m_client.publish('putzini/force_idle'))

        self.control_layout.addRow(stop, done)
        # stop.setMaximumWidth(200)

        vac = pg.QtGui.QCheckBox('Vacuum Cleaner')
        vac.stateChanged.connect(lambda state: self.command(
            'vacuum', '1' if int(state) == 2 else '0'))
        vac.setChecked(False)
        self.control_layout.addRow(vac)

        height = pg.SpinBox(value=0)
        # height.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('\d+')))
        height.setOpts(bounds=(0, 130),
                       suffix='mm',
                       step=1,
                       int=True,
                       compactHeight=False)
        height.valueChanged.connect(lambda x: self.command('height', int(x)))
        self.control_layout.addRow(QtGui.QLabel('Height'), height)

        head = pg.SpinBox(value=0)
        # height.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('\d+')))
        head.setOpts(bounds=(0, 255),
                     suffix='stp',
                     step=1,
                     int=True,
                     compactHeight=False)
        head.valueChanged.connect(lambda x: self.command('head', int(x)))
        self.control_layout.addRow(QtGui.QLabel('Head'), head)

        color_fg = pg.ColorButton()
        color_fg.sigColorChanging.connect(lambda ctrl: self.command(
            'lamp', {
                'front': {
                    'r': ctrl.color().red(),
                    'g': ctrl.color().green(),
                    'b': ctrl.color().blue(),
                    'w': ctrl.color().alpha()
                }
            }))
        self.control_layout.addRow(QtGui.QLabel('FG Color'), color_fg)

        color_bg = pg.ColorButton()
        color_bg.sigColorChanging.connect(lambda ctrl: self.command(
            'lamp', {
                'back': {
                    'r': ctrl.color().red(),
                    'g': ctrl.color().green(),
                    'b': ctrl.color().blue()
                }
            }))
        self.control_layout.addRow(QtGui.QLabel('BG Color'), color_bg)

        self.audio_vol = pg.SpinBox(value=10)
        self.audio_vol.setOpts(bounds=(0, 150), step=1)
        self.control_layout.addRow(QtGui.QLabel('Volume'), self.audio_vol)

        audio_1 = QtGui.QLineEdit('New Peeps/curious_1.wav')
        audio_1.returnPressed.connect(lambda: self.command(
            'audio', {
                'folder': audio_1.text().rsplit('/', 1)[0],
                'file': audio_1.text().rsplit('/', 1)[1],
                'loop': 0,
                'vol': int(self.audio_vol.value())
            } if audio_1.text() else 'stop'))
        self.control_layout.addRow(QtGui.QLabel('Audio once'), audio_1)

        audio_loop = QtGui.QLineEdit('New Peeps/curious_1.wav')
        audio_loop.returnPressed.connect(lambda: self.command(
            'audio', {
                'folder': audio_loop.text().rsplit('/', 1)[0],
                'file': audio_loop.text().rsplit('/', 1)[1],
                'loop': 1,
                'vol': int(self.audio_vol.value())
            } if audio_loop.text() else 'stop'))
        self.control_layout.addRow(QtGui.QLabel('Audio loop'), audio_loop)

        # indicators
        self.xpos_indicator = QtGui.QLineEdit(readOnly=True)
        self.control_layout.addRow(QtGui.QLabel('X Position'),
                                   self.xpos_indicator)

        self.ypos_indicator = QtGui.QLineEdit(readOnly=True)
        self.control_layout.addRow(QtGui.QLabel('Y Position'),
                                   self.ypos_indicator)

        self.angle_indicator = QtGui.QLineEdit(readOnly=True)
        self.control_layout.addRow(QtGui.QLabel('Angle'), self.angle_indicator)

        self.battery_indicator = QtGui.QLineEdit(readOnly=True)
        self.control_layout.addRow(QtGui.QLabel('Battery'),
                                   self.battery_indicator)

        self.calibrated_indicator = QtGui.QLineEdit(readOnly=True)
        self.control_layout.addRow(QtGui.QLabel('Calibrated'),
                                   self.calibrated_indicator)

        random.setValidator(QtGui.QRegExpValidator(QtCore.QRegExp('\d+')))
        random.returnPressed.connect(lambda: self.command(
            'move', f'moveRandom({random.text()},{random_rng.text()})'))

        self.last_err = QtGui.QLineEdit(readOnly=True)
        clear = pg.QtGui.QPushButton('Clear Errors')
        clear.clicked.connect(self.last_err.clear)
        self.control_layout.addRow(QtGui.QLabel('Last Error'), clear)
        self.control_layout.addRow(self.last_err)

        self.last_cmd = QtGui.QTextEdit(readOnly=True, width=10)
        self.control_layout.addRow(self.last_cmd)
        self.last_cmd.resize(QtCore.QSize(4, 4))

        self.control_layout.setSizeConstraint(self.control_layout.SetFixedSize)
        self.top_layout.addLayout(self.control_layout, 0, 1)
        # END CONTROLS ---

        self.client = MqttClient(self)
        self.client.stateChanged.connect(self.on_stateChanged)
        self.client.messageSignal.connect(self.on_messageSignal)
        self.client.voltageSignal.connect(self.on_voltageSignal)
        self.client.distancesSignal.connect(self.on_distancesSignal)
        self.client.calibratedSignal.connect(self.on_calibratedSignal)
        self.client.errorSignal.connect(self.on_errorSignal)
        self.client.command_stateSignal.connect(self.on_command_stateSignal)
        self.client.stateSignal.connect(self.on_stateSignal)
        self.client.logsSignal.connect(self.on_logsSignal)

        self.client.hostname = "172.31.1.150"
        self.client.connectToHost()

        self.keyPressEvent = self.key_pressed

        self.last_RT = None
        self.last_distances = None
        self.last_calibrated = None
        self.step_size = 2000