00001 import serial
00002 import threading
00003 from BAL.protocol.packages.motor_to_takeover import REVERSE, NORMAL
00004 from GUI.Schemes.takeoverConfig import Ui_Dialog
00005 from PyQt4.QtGui import *
00006 from BAL.protocol.protocol_handler import ProtocolHandler
00007 from BAL.protocol.packages.clib_status import CANCEL, SAVE, RESET
00008 from GUI.calib_help_win import CalibHelp
00009
00010 __author__ = 'caja'
00011
00012 FORWARD_TAB = 1
00013 TURN_TAB = 2
00014
00015
00016 class MainWindow(QDialog, Ui_Dialog):
00017 def __init__(self, parent=None):
00018 super(MainWindow, self).__init__(parent)
00019 self.setupUi(self)
00020 try:
00021 QMessageBox.warning(self, 'Warning',
00022 'This Gui is for advance user only, If not use correctly it can damage the robot.\n When this Gui thurn on the RiCBoad will stop its functionality until you exit the gui.')
00023 self._protocol_handler = ProtocolHandler('RiCBoard')
00024 self._protocol_handler.in_config_mode()
00025 self._forwardClib = True
00026 self._turnClib = True
00027
00028 self._old_forward_slide_max = 2000
00029 self._old_forward_slide_mid = 1500
00030 self._old_forward_slide_min = 1000
00031 self._old_turn_slide_max = 2000
00032 self._old_turn_slide_mid = 1500
00033 self._old_turn_slide_min = 1000
00034
00035 self.finished.connect(self.on_close)
00036 self.saveBT.clicked.connect(self.on_save)
00037 self.loadBT.clicked.connect(self.on_load)
00038 self.leftClib.clicked.connect(self.on_forward_clib)
00039 self.leftSet.clicked.connect(self.on_forward_set)
00040 self.rightClib.clicked.connect(self.on_turn_clib)
00041 self.rightSet.clicked.connect(self.on_turn_set)
00042 self.leftClibSp.rangeChanged.connect(self.on_forward_range_change)
00043 self.leftClibSp.valueChanged.connect(self.on_forward_slide_value_change)
00044 self.righClibSp.rangeChanged.connect(self.on_turn_range_change)
00045 self.righClibSp.valueChanged.connect(self.on_turn_slide_value_change)
00046
00047 self.forwardHelpB.clicked.connect(self.on_help_calib)
00048 self.turnHelpB.clicked.connect(self.on_help_calib)
00049
00050 except serial.SerialException:
00051 QMessageBox.critical(self, "Error ",
00052 "can not connect to the device, please check if its connected to the computer.")
00053
00054 def on_help_calib(self):
00055 help_calib = CalibHelp()
00056 help_calib.show()
00057 help_calib.exec_()
00058
00059 def on_close(self, code):
00060 if self._protocol_handler.is_forward_clib():
00061 self._protocol_handler.send_clib_status(CANCEL)
00062 self._protocol_handler.set_forward_clib(False)
00063
00064 if self._protocol_handler.is_turn_clib():
00065 self._protocol_handler.send_clib_status(CANCEL)
00066 self._protocol_handler.set_turn_clib(False)
00067
00068 self._protocol_handler.in_config_mode()
00069
00070 def on_save(self):
00071 try:
00072 ch = self.takeoverCH.value()
00073 listen_mode = (self.takeoverCb.currentIndex() + 1)
00074 value = int(self.takeoverLe.text())
00075 status = self.takeoverEnable.isChecked()
00076 self._protocol_handler.send_channel_to_takeover_pkg(ch, listen_mode, value, status)
00077 forward_rev = NORMAL
00078 turn_rev = NORMAL
00079 if self.reverseCheckBox.isChecked():
00080 forward_rev = REVERSE
00081 if self.reverseCheckBox_2.isChecked():
00082 turn_rev = REVERSE
00083 self._protocol_handler.send_motor_to_takeover(self.rCChannelSpinBox.value(), self.maxCommandSpinBox.value(),
00084 int(self.pinLineEdit.text()), FORWARD_TAB,
00085 self.leftClibSp.minimum(), self.leftClibSp.value(),
00086 self.leftClibSp.maximum(), False,
00087 self.deadbandDoubleSpinBox.value(), forward_rev)
00088 self._protocol_handler.send_motor_to_takeover(self.rCChannelSpinBox_2.value(),
00089 self.maxCommandSpinBox_2.value(),
00090 int(self.pinLineEdit_2.text()), TURN_TAB,
00091 self.righClibSp.minimum(), self.righClibSp.value(),
00092 self.righClibSp.maximum(), False,
00093 self.deadbandDoubleSpinBox_2.value(), turn_rev)
00094 QMessageBox.information(self, 'Info', 'Write is done.')
00095
00096 except ValueError:
00097 QMessageBox.critical(self, "Error ", "Invalid value.")
00098
00099 def on_load(self):
00100 self._protocol_handler.send_read_param()
00101 if self._protocol_handler.got_done():
00102 res_takeover = self._protocol_handler.load_channel_to_takeover()
00103 self.takeoverCH.setValue(res_takeover.get_channel())
00104 self.takeoverCb.setCurrentIndex(res_takeover.get_listen_mode() - 1)
00105 self.takeoverLe.setText(str(res_takeover.get_value()))
00106 self.takeoverEnable.setChecked(res_takeover.get_status())
00107
00108 res_forward = self._protocol_handler.load_motor_to_takeover()
00109 self.rCChannelSpinBox.setValue(res_forward.get_channel())
00110 self.maxCommandSpinBox.setValue(res_forward.get_max_command())
00111 self.pinLineEdit.setText(str(res_forward.get_pin()))
00112 self.deadbandDoubleSpinBox.setValue(res_forward.get_deadband())
00113 self.leftClibSp.setMaximum(res_forward.get_max_joystick())
00114 self.leftClibSp.setMinimum(res_forward.get_min_joystick())
00115 self.leftClibSp.setValue(res_forward.get_mid_joystick())
00116 self.reverseCheckBox.setChecked(res_forward.is_reverse())
00117 self._old_forward_slide_max = res_forward.get_max_joystick()
00118 self._old_forward_slide_mid = res_forward.get_mid_joystick()
00119 self._old_forward_slide_min = res_forward.get_min_joystick()
00120 res_turn = self._protocol_handler.load_motor_to_takeover()
00121 self.rCChannelSpinBox_2.setValue(res_turn.get_channel())
00122 self.maxCommandSpinBox_2.setValue(res_turn.get_max_command())
00123 self.pinLineEdit_2.setText(str(res_turn.get_pin()))
00124 self.deadbandDoubleSpinBox_2.setValue(res_turn.get_deadband())
00125 self.righClibSp.setMaximum(res_turn.get_max_joystick())
00126 self.righClibSp.setMinimum(res_turn.get_min_joystick())
00127 self.righClibSp.setValue(res_turn.get_mid_joystick())
00128 self.reverseCheckBox_2.setChecked(res_turn.is_reverse())
00129 self._old_turn_slide_max = res_turn.get_max_joystick()
00130 self._old_turn_slide_mid = res_turn.get_mid_joystick()
00131 self._old_turn_slide_min = res_turn.get_min_joystick()
00132 QMessageBox.information(self, 'Done', 'Done reading the configuration')
00133 else:
00134 QMessageBox.critical(self, 'Error', 'RiCBoard now responding.'
00135 '\nPlease power off the robot and turn it back on.'
00136 '\nFor support contact this email: tom@robotican.net')
00137
00138 def on_forward_clib(self):
00139 if self._forwardClib:
00140 rev_forward = NORMAL
00141 if self.reverseCheckBox.isChecked():
00142 rev_forward = REVERSE
00143 try:
00144 threading.Thread(target=self._protocol_handler.send_motor_to_takeover_and_clib, args=(
00145 self.rCChannelSpinBox.value(), self.maxCommandSpinBox.value(), int(self.pinLineEdit.text()),
00146 FORWARD_TAB, 2000, 1000, True, self.deadbandDoubleSpinBox.value(), rev_forward,
00147 self.leftClibSp)).start()
00148 except ValueError:
00149 QMessageBox.critical(self, "Error ", "Invalid value.")
00150 self.leftClib.setText("Cancel")
00151 else:
00152 self.leftClibSp.setMaximum(self._old_forward_slide_max)
00153 self.leftClibSp.setMinimum(self._old_forward_slide_min)
00154 self.leftClibSp.setValue(self._old_forward_slide_mid)
00155 self.leftClib.setText("Calibration")
00156 self._protocol_handler.send_clib_status(CANCEL)
00157 self._forwardClib = not self._forwardClib
00158
00159 def on_forward_set(self):
00160 if not self._forwardClib:
00161 self._old_forward_slide_max = self.leftClibSp.maximum()
00162 self._old_forward_slide_mid = self.leftClibSp.value()
00163 self._old_forward_slide_min = self.leftClibSp.minimum()
00164 self._protocol_handler.send_clib_status(SAVE)
00165 self.leftClib.setText("Calibration")
00166 QMessageBox.information(self, 'Info', 'Calibration is done')
00167 self._forwardClib = True
00168
00169 def on_turn_clib(self):
00170 if self._turnClib:
00171 rev_turn = NORMAL
00172 if self.reverseCheckBox_2.isChecked():
00173 rev_turn = REVERSE
00174 try:
00175 threading.Thread(target=self._protocol_handler.send_motor_to_takeover_and_clib, args=(
00176 self.rCChannelSpinBox_2.value(), self.maxCommandSpinBox_2.value(), int(self.pinLineEdit_2.text()),
00177 TURN_TAB, 2000, 1000, True, self.deadbandDoubleSpinBox_2.value(), rev_turn, self.righClibSp)).start()
00178 except ValueError:
00179 QMessageBox.critical(self, "Error ", "Invalid value.")
00180 self.rightClib.setText("Cancel")
00181 else:
00182 self.righClibSp.setMaximum(self._old_turn_slide_max)
00183 self.righClibSp.setMinimum(self._old_turn_slide_min)
00184 self.righClibSp.setValue(self._old_turn_slide_mid)
00185 self.rightClib.setText("Calibration")
00186 self._protocol_handler.send_clib_status(CANCEL)
00187 self._turnClib = not self._turnClib
00188
00189 def on_turn_set(self):
00190 if not self._turnClib:
00191 self._old_turn_slide_max = self.righClibSp.maximum()
00192 self._old_turn_slide_mid = self.righClibSp.value()
00193 self._old_turn_slide_min = self.righClibSp.minimum()
00194 self._protocol_handler.send_clib_status(SAVE)
00195 self.rightClib.setText("Calibration")
00196 QMessageBox.information(self, 'Info', 'Calibration is done')
00197 self._turnClib = True
00198
00199 def on_forward_range_change(self, min_slide, max_slide):
00200 self.leftMax.setText("Max: {0}".format(str(max_slide)))
00201 self.leftMin.setText("Min: {0}".format(str(min_slide)))
00202
00203 def on_forward_slide_value_change(self, value):
00204 self.leftMid.setText("Mid: {0}".format(str(value)))
00205
00206 def on_turn_range_change(self, min_slide, max_slide):
00207 self.rightMax.setText("Max: {0}".format(str(max_slide)))
00208 self.rightMin.setText("Min: {0}".format(str(min_slide)))
00209
00210 def on_turn_slide_value_change(self, value):
00211 self.rightMid.setText("Mid: {0}".format(str(value)))