def main():
ser = SerialPort(sys.argv[1], Resolver(), timeout=0)
ser.start()
def thread_loop():
threading.Timer(2.0, thread_loop).start()
ask_for_usage()
time.sleep(0.5)
ask_for_volume()
def ask_for_volume():
# threading.Timer(0.7, ask_for_volume).start()
ser.write(b'zad2')
ser.write(str(show_mixer()).encode())
def ask_for_usage():
# threading.Timer(5.0, ask_for_usage).start()
data = show_host_data()
ser.write(b'C')
ser.write(str(data['cpu']).encode())
ser.write(b'T')
ser.write(str(data['temperature']).encode())
ser.write(b'M')
ser.write(str(data['memory']).encode())
# ask_for_volume()
# ask_for_usage()
thread_loop()
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open('logconfig.yaml', 'r') as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger('app')
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('app_id', None),
('app_ver', 0x03010a00),
('bundle_id', '12345678901234567890123456789012'),
]]
)
if not self.active_info.get('app_id'):
raise TypeError(
'{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('crc16_init', 0x3AA3),
('crc16_poly', 0x18005),
('crc32_init', 0x3AA3),
('crc32_poly', 0x104C11DB7),
('aes256_key', None),
]]
)
if not encrypt_param.get('aes256_key'):
raise TypeError(
'{}.__init__() must pass argument "aes256_key"!'.format(__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('port', '/dev/ttyUSB0'),
('baudrate', 230400),
('read_bytes', 12),
('buffer_queue', self.port_rx_stream_queue),
]]
)
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(
self.port_rx_stream_queue, self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
def __init__(self, master):
tk.Frame.__init__(self)
master.geometry(set_size(master, 520, 450))
master.resizable(False, True)
master.title("自动布线机 v1.0")
self.machine = Machine()
self.gcoder = Gcoder()
self.serialPort = SerialPort() # Initialized when the connector opened
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open('logconfig.yaml', 'r') as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger('app')
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('app_id', None),
('api_level', 0x02),
('app_ver', 0x01),
('bundle_id', '12345678901234567890123456789012'),
]]
)
if not self.active_info.get('app_id'):
raise TypeError(
'{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('crc16_init', 0x3AA3),
('crc16_poly', 0x18005),
('crc32_init', 0x3AA3),
('crc32_poly', 0x104C11DB7),
('aes256_key', None),
]]
)
if not encrypt_param.get('aes256_key'):
raise TypeError(
'{}.__init__() must pass argument "aes256_key"!'.format(__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('port', '/dev/ttyUSB0'),
('baudrate', 230400),
('read_bytes', 12),
('buffer_queue', self.port_rx_stream_queue),
]]
)
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(
self.port_rx_stream_queue, self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
def on_start(self, event):
from TwrLtcConfig import ConfigFrame
from CSVLog import CSVLog
configs = self.TwrLtcConfig()
frame = ConfigFrame(self, configs)
frame.ShowModal()
if configs.get_valid_configs() == True:
# User inputs have passed the basic test Let us proceed with
# those values
# No more error checkings on serial ports are required here
# Let us not have any error checking here
try:
self.twr_data_acq = SerialPort(configs.get_twr_ser_port())
except IOError:
wx.MessageBox("Could not open serial port %s for communicating with the tower " %configs.get_twr_ser_port())
return
try:
self.dmm_data_acq = SerialPort(configs.get_dmm_ser_port(), '9600', stopbits='2')
except IOError:
wx.MessageBox("Could not open serial port %s for communicating with the HP34001A " %configs.get_dmm_ser_port())
self.twr_data.acq.close_port()
return
self.logger = CSVLog(configs.get_log_file())
pro = ProcessCmd(configs.get_cmd_file()) # The commands will be processed and
self.cmds_file = 'cmds_pro.twrcmd'
pro.process(self.cmds_file) # stored in 'cmds_pro.txt' pass
# differnt file name to process() to change this behaviour
del pro
self.logger.write_title(['Sample number', 'Command sent to DAC', \
'Voltages read by DMM', 'Volatges read by TWRLTC'])
self.save_btn.Enable()
self.start_btn.Disable()
acq_thread = DatAcqThread(self)
acq_thread.start()
def __init__(self):
tk.Tk.__init__(self)
self.serial = SerialPort(self)
self.geometry('1000x1200+0+0')
self.title("AT-Tool")
self.config = Config(self)
self.pane = tk.PanedWindow(orient=tk.HORIZONTAL, sashwidth=5)
self.pane.pack(fill=tk.BOTH, expand=1, padx=3, pady=3)
self.serial_terminal = SerialTerminal(self.pane)
self.command_list = CommandList(self.pane)
self.pane.add(self.serial_terminal)
self.pane.add(self.command_list)
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
def change_frequency_init(self):
port_name = self.port_selection.currentText()
frequency = self.frequency_selection.currentText()
self.message.setText("Setting Up Port {}".format(port_name))
port = SerialPort(port_name)
port.write_port("RadiosondeDAS")
self.message.setText("Waiting for Response")
while port.read_port() != "RadiosondeDAS":
pass
port.write_port(frequency)
while port.read_port() != frequency:
pass
self.message.setText("Frequency Set: {}".format(frequency))
def setupSerial(self, comport="COM1", baud=115200, data=8, par="N",
stop=1, xon=None, rts=None, **kwargs):
if(comport in listSerialPorts()) :
self.closeSerial()
#try:
#comport, baud, data, par, stop, xon, rts = []
self.handle = SerialPort("tkTerm", comport, baud, data, par,
stop, xon, rts)
# except Exception as e:
# print("SERIAL PORT ERROR!", e)
# try:
# self.handle = serial.Serial(port=comport, baudrate=baud,
# bytesize=data, parity=par, stopbits=stop, timeout=3.0,
# rtscts=rts, xonxoff=xon, writeTimeout=3.0)
# except Exception as se:
# print("COM PORT ERROR!", se)
self.master.title("tkTerm {}".format(comport))
print(self.handle)
else:
print("NOT AN ACTIVE SERIAL PORT")
class GeigerCOMService(IService, SerialPortHandler):
def __init__(self):
self.serialPort = None
pass
def start(self, config):
self.serialPort = SerialPort(self, config.get('port_address'), Constants.SERIAL_MESSAGE_DELIMITER)
self.serialPort.openPort()
pass
def stop(self):
if(self.serialPort != None):
self.serialPort.abortPort()
pass
def commit(self):
pass
def port_opened(self, SerialPort):
"""When the port is opened."""
print("Port linked!")
pass
def port_read(self, SerialPort, Data):
"""When str data has been recvd."""
#Data starting by "N =" characters
if(Data.startswith(Constants.SERIAL_MESSAGE_HEAD)):
hitsCount = int(Data[Constants.SERIAL_MESSAGE_HEAD:])
hits = HitEntity().set(int(time.time()), hitsCount)
Globals.Application.transact(hits)
pass
def port_closed(self, SerialPort):
"""When the port is closed."""
print("Port closed")
self.serialPort.openPort()
pass
def port_error(self, SerialPort, Error):
"""When error has been encountered."""
pass
def port_abort(self, SerialPort):
"""When the port has been aborted."""
print("Port aborted")
pass
def __init__(self):
super().__init__()
self.setupUi(self)
# 状态栏配置
self.status_label = QtWidgets.QLabel()
self.status_label.setText("Hello word!")
self.statusbar.addWidget(self.status_label)
# 串口配置
self.comboBox = MyCombox(self.centralwidget)
x = 670 + 97
y = 20 + 10
self.comboBox.setGeometry(QtCore.QRect(x, y, 115, 33))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.comboBox.sizePolicy().hasHeightForWidth())
self.comboBox.setSizePolicy(sizePolicy)
self.comboBox.setMinimumSize(QtCore.QSize(0, 30))
self.comboBox.setObjectName("comboBox")
self.comboBox.enter_event_signal.connect(self.onCombox_EnterSlot)
self.serial_port = SerialPort()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox_baudrate.addItem('1200')
self.comboBox_baudrate.addItem('2400')
self.comboBox_baudrate.addItem('4800')
self.comboBox_baudrate.addItem('9600')
self.comboBox_baudrate.addItem('19200')
self.comboBox_baudrate.addItem('38400')
self.comboBox_baudrate.addItem('57600')
self.comboBox_baudrate.addItem('115200')
self.comboBox_baudrate.setCurrentIndex(7)
self.serial_port.baund_rate = QSerialPort.Baud115200
self.comboBox_baudrate.currentIndexChanged.connect(
self.onCombox_baudrate_IncdeChangeSlot)
self.comboBox_stopBit.addItem('1')
self.comboBox_stopBit.addItem('1.5')
self.comboBox_stopBit.addItem('2')
self.comboBox_stopBit.setCurrentIndex(0)
self.comboBox_stopBit.currentIndexChanged.connect(
self.onCombox_stopBit_IncdeChangeSlot)
self.comboBox_dataBit.addItem('5')
self.comboBox_dataBit.addItem('6')
self.comboBox_dataBit.addItem('7')
self.comboBox_dataBit.addItem('8')
self.comboBox_dataBit.setCurrentIndex(3)
self.comboBox_dataBit.currentIndexChanged.connect(
self.onCombox_dataBit_IncdeChangeSlot)
self.comboBox_parity.addItem('无')
self.comboBox_parity.addItem('奇校验')
self.comboBox_parity.addItem('偶校验')
self.comboBox_parity.setCurrentIndex(0)
self.comboBox_parity.currentIndexChanged.connect(
self.onCombox_parity_IncdeChangeSlot)
# 摄像头显示进程配置
self.thread_camera = ThreadCamera()
# 创建定时器，用于定时读取摄像头进程中的图像
self.timer = QTimer(self)
self.timer.setInterval(16)
self.timer.timeout.connect(self.slotTimerTimeout)
# 开关按钮配置
self.pushButton_flag = True
self.pushButton_switch.clicked.connect(self.onPushButton_ClickedSlot)
class Model(Thread):
def __init__(self, **kwargs):
Thread.__init__(self)
# Serial thread
self.serialthread = SerialPort()
# Controller Read/Write variables over serial
self.controller = DistantIO()
# Serial protocol
self.protocol = Protocol()
# Variable manager
self.variable_manager = VariableManager(self)
self.variable_manager.start()
self.running = True;
# Data logger
self.logger = DataLogger()
def get_ports(self):
return self.serialthread.get_ports()
def connect_com(self,COM_port):
# Start serial thread (can run without COM port connected)
if not self.serialthread.isAlive():
self.serialthread.start()
self.serialthread.connect(COM_port,115200)
#Model update running in a thread
def run(self):
while self.running:
if self.serialthread.char_available():
c = self.serialthread.get_char()
if not c is None:
self.protocol.process_rx(c)
if self.protocol.available():
p = self.protocol.get()
# Dump payload if controller is in heavy load ?
pub.sendMessage('new_rx_payload',rxpayload=p)#USED ?
if not p is None:
self.controller.decode(p)
def disconnect_com(self):
self.serialthread.disconnect()
def stop(self):
self.running = False
self.serialthread.stop()
self.variable_manager.stop()
if self.serialthread.isAlive():
self.serialthread.join(0.1)
if self.serialthread.isAlive():
self.serialthread.join(1)
if self.serialthread.isAlive():
print("--- Serial thread not properly joined.")
if self.variable_manager.isAlive():
self.variable_manager.join(0.1)
if self.variable_manager.isAlive():
self.variable_manager.join(1)
self.stop_controller()
def start_controller(self):
#Get command for querying variable table MCU side
cmd = self.controller.encode(cmd='table')
#Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
#Send command
self.serialthread.write(frame)
def stop_controller(self):
#TODO : Tell MCU to stop sending all data
pass
def start_log(self):
self.logger.start()
def stop_log(self):
self.logger.record_all()
def read_var(self, varid):
# Get command
cmd = self.controller.encode(cmd='read',var_id=varid)
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def write_var(self,varid,value):
# Get command
cmd = self.controller.encode(cmd='write',var_id=varid,value=value)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_var(self,varid):
# Get command
cmd = self.controller.encode(cmd='stop',var_id=varid)
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def stop_read_all_vars():
# Get command
cmd = self.controller.encode(cmd='stopall')
if cmd == None:
return
# Feed command to serial protocol payload processor
frame = self.protocol.process_tx(cmd)
# Send command
self.serialthread.write(frame)
def get_var_info(self,varid):
return self.controller.get_var_info(varid)
def __init__(self, xmlserial, verbose=False):
"""
Class constructor
@param portname: Name/path of the serial port
@param speed: Serial baudrate in bps
@param verbose: Print out SWAP traffic (True or False)
"""
# Response to the last AT command sent to the serial modem
self._atresponse = ""
# AT response received from modem
self.__atresponse_received = None
# "Packet received" callback function. To be defined by the parent object
self._ccpacket_received = None
## Hardware version of the serial modem
self.hwversion = None
## Firmware version of the serial modem
self.fwversion = None
try:
# Open serial port
if xmlserial.port.startswith("mqtt"):
self._serport = MQTTPort(xmlserial, verbose)
self._serport.setRxCallback(self._serialPacketReceived)
self.devaddress = 1
self.syncword = 0xc0de
self.hwversion = 1
self.fwversion = 1
self.freq_channel = 70
self._serport.start()
else:
self._serport = SerialPort(xmlserial.port, xmlserial.speed, verbose)
self._serport.setRxCallback(self._serialPacketReceived)
self._serport.start()
# Retrieve modem settings
# Switch to command mode
if not self.goToCommandMode():
raise SwapException("Modem is unable to enter command mode")
# Hardware version
response = self.runAtCommand("ATHV?\n")
if response is None:
raise SwapException("Unable to retrieve Hardware Version from serial modem")
self.hwversion = long(response, 16)
# Firmware version
response = self.runAtCommand("ATFV?\n")
if response is None:
raise SwapException("Unable to retrieve Firmware Version from serial modem")
self.fwversion = long(response, 16)
# Frequency channel
response = self.runAtCommand("ATCH?\n")
if response is None:
raise SwapException("Unable to retrieve Frequency Channel from serial modem")
## Frequency channel of the serial gateway
self.freq_channel = int(response, 16)
# Synchronization word
response = self.runAtCommand("ATSW?\n")
if response is None:
raise SwapException("Unable to retrieve Synchronization Word from serial modem")
## Synchronization word of the serial gateway
self.syncword = int(response, 16)
# Device address
response = self.runAtCommand("ATDA?\n")
if response is None:
raise SwapException("Unable to retrieve Device Address from serial modem")
## Device address of the serial gateway
self.devaddress = int(response, 16)
except:
raise
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.setupUi(self)
# 状态栏配置
self.status_label = QtWidgets.QLabel()
self.status_label.setText("Hello word!")
self.statusbar.addWidget(self.status_label)
# 串口配置
self.comboBox = MyCombox(self.centralwidget)
x = 670 + 97
y = 20 + 10
self.comboBox.setGeometry(QtCore.QRect(x, y, 115, 33))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.comboBox.sizePolicy().hasHeightForWidth())
self.comboBox.setSizePolicy(sizePolicy)
self.comboBox.setMinimumSize(QtCore.QSize(0, 30))
self.comboBox.setObjectName("comboBox")
self.comboBox.enter_event_signal.connect(self.onCombox_EnterSlot)
self.serial_port = SerialPort()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox_baudrate.addItem('1200')
self.comboBox_baudrate.addItem('2400')
self.comboBox_baudrate.addItem('4800')
self.comboBox_baudrate.addItem('9600')
self.comboBox_baudrate.addItem('19200')
self.comboBox_baudrate.addItem('38400')
self.comboBox_baudrate.addItem('57600')
self.comboBox_baudrate.addItem('115200')
self.comboBox_baudrate.setCurrentIndex(7)
self.serial_port.baund_rate = QSerialPort.Baud115200
self.comboBox_baudrate.currentIndexChanged.connect(
self.onCombox_baudrate_IncdeChangeSlot)
self.comboBox_stopBit.addItem('1')
self.comboBox_stopBit.addItem('1.5')
self.comboBox_stopBit.addItem('2')
self.comboBox_stopBit.setCurrentIndex(0)
self.comboBox_stopBit.currentIndexChanged.connect(
self.onCombox_stopBit_IncdeChangeSlot)
self.comboBox_dataBit.addItem('5')
self.comboBox_dataBit.addItem('6')
self.comboBox_dataBit.addItem('7')
self.comboBox_dataBit.addItem('8')
self.comboBox_dataBit.setCurrentIndex(3)
self.comboBox_dataBit.currentIndexChanged.connect(
self.onCombox_dataBit_IncdeChangeSlot)
self.comboBox_parity.addItem('无')
self.comboBox_parity.addItem('奇校验')
self.comboBox_parity.addItem('偶校验')
self.comboBox_parity.setCurrentIndex(0)
self.comboBox_parity.currentIndexChanged.connect(
self.onCombox_parity_IncdeChangeSlot)
# 摄像头显示进程配置
self.thread_camera = ThreadCamera()
# 创建定时器，用于定时读取摄像头进程中的图像
self.timer = QTimer(self)
self.timer.setInterval(16)
self.timer.timeout.connect(self.slotTimerTimeout)
# 开关按钮配置
self.pushButton_flag = True
self.pushButton_switch.clicked.connect(self.onPushButton_ClickedSlot)
# 串口号选择
def onCombox_EnterSlot(self):
if self.pushButton_flag:
index = self.comboBox.currentIndex()
text = self.comboBox.currentText()
self.comboBox.clear()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox.setCurrentIndex(index)
if self.comboBox.currentText() != text:
self.comboBox.setCurrentIndex(0)
# 串口波特率选择
def onCombox_baudrate_IncdeChangeSlot(self):
current_index = self.comboBox_baudrate.currentIndex()
if current_index == 0:
self.serial_port.baund_rate = QSerialPort.Baud1200
elif current_index == 1:
self.serial_port.baund_rate = QSerialPort.Baud2400
elif current_index == 2:
self.serial_port.baund_rate = QSerialPort.Baud4800
elif current_index == 3:
self.serial_port.baund_rate = QSerialPort.Baud9600
elif current_index == 4:
self.serial_port.baund_rate = QSerialPort.Baud19200
elif current_index == 5:
self.serial_port.baund_rate = QSerialPort.Baud38400
elif current_index == 6:
self.serial_port.baund_rate = QSerialPort.Baud57600
elif current_index == 7:
self.serial_port.baund_rate = QSerialPort.Baud115200
# 串口停止位选择
def onCombox_stopBit_IncdeChangeSlot(self):
current_index = self.comboBox_stopBit.currentIndex()
if current_index == 0:
self.serial_port.stop_bits = QSerialPort.OneStop
elif current_index == 1:
self.serial_port.stop_bits = QSerialPort.OneAndHalfStop
elif current_index == 2:
self.serial_port.stop_bits = QSerialPort.TwoStop
# 串口数据位选择
def onCombox_dataBit_IncdeChangeSlot(self):
current_index = self.comboBox_dataBit.currentIndex()
if current_index == 0:
self.serial_port.data_bits = QSerialPort.Data5
elif current_index == 1:
self.serial_port.data_bits = QSerialPort.Data6
elif current_index == 2:
self.serial_port.data_bits = QSerialPort.Data7
elif current_index == 3:
self.serial_port.data_bits = QSerialPort.Data8
# 串口奇偶校验位选择
def onCombox_parity_IncdeChangeSlot(self):
current_index = self.comboBox_parity.currentIndex()
if current_index == 0:
self.serial_port.parity = QSerialPort.NoParity
elif current_index == 1:
self.serial_port.parity = QSerialPort.OddParity
elif current_index == 2:
self.serial_port.parity = QSerialPort.EvenParity
# 定时器到达时间间隔的槽函数
def slotTimerTimeout(self):
if self.thread_camera.img_frame and (not self.thread_camera.end_flag):
self.label_video.setPixmap(
QPixmap.fromImage(self.thread_camera.img_frame))
else:
self.label_video.clear()
# 按钮按下动作
def onPushButton_ClickedSlot(self):
if self.pushButton_flag:
port_name = self.comboBox.currentText()
if port_name != '':
self.serial_port.setPort(self.serial_port.port[port_name])
self.serial_port.open(QSerialPort.ReadWrite)
self.serial_port.setBaudRate(self.serial_port.baund_rate)
self.serial_port.setStopBits(self.serial_port.stop_bits)
self.serial_port.setDataBits(self.serial_port.data_bits)
self.serial_port.setParity(self.serial_port.parity)
self.pushButton_flag = False
self.pushButton_switch.setStyleSheet(
"border-image: url(:/on/on.png);")
self.comboBox.setEnabled(False)
self.comboBox_baudrate.setEnabled(False)
self.comboBox_stopBit.setEnabled(False)
self.comboBox_dataBit.setEnabled(False)
self.comboBox_parity.setEnabled(False)
self.thread_camera.end_flag = False
self.thread_camera.start()
self.timer.start()
self.lineEdit_ip.setReadOnly(True)
self.lineEdit_telephone.setReadOnly(True)
else:
QMessageBox.warning(None, "Warning!", "Cannot detect serial!")
else:
self.serial_port.close()
self.pushButton_flag = True
self.pushButton_switch.setStyleSheet(
"border-image: url(:/off/off.png);")
self.comboBox.setEnabled(True)
self.comboBox_baudrate.setEnabled(True)
self.comboBox_stopBit.setEnabled(True)
self.comboBox_dataBit.setEnabled(True)
self.comboBox_parity.setEnabled(True)
self.timer.stop()
self.thread_camera.end_flag = True
self.label_video.clear()
self.lineEdit_ip.setReadOnly(False)
self.lineEdit_telephone.setReadOnly(False)
class Parser:
__serialPort = None
__parsedInput = None
__serialReadSize = None
# Name: Parameterized constructor
# Description: Parser class parameterized constructor which takes in baud rate and timeout
# values which are used to create a SerialPort object
# Parameters: Takes in two ints which are the baud rate and timeout value needed in the
# constructor of the SerialPort object
# Return: None
def __init__(self, baudRate, timeOut, readinSize):
self.__serialReadSize = readinSize
# SerialPort object created with baud rate and timeout values passed into the constructor
self.__serialPort = SerialPort(baudRate, timeOut, readinSize)
# Name: getSerialInput
# Description: Parser class method which continually reads in from the serial port through
# the SerialPort object and formats and concatenates the portions of the input,
# removing artifacts added by PySerial and checking for a decimal point
# Parameters: None
# Return: Returns a list containing the value from the receiver as a string and char
# indicating what type of value it is
def getSerialInput(self):
dotBool = False
# for reading in an entire line at a time from the serial port
if self.__serialReadSize == 1:
# reads in an entire line from the serial port
inputValue = str(self.__serialPort.serialRead())
# leading and trailing characters are parsed off the line and the outputList is built
# from the parsed line
outputList = [inputValue[2]]
outputString = inputValue[3:-4]
outputString = outputString.replace('\\', "")
outputList.append(outputString)
# for reading in data from the serial port one byte at a time
if read.__serialReadSize == 0:
# grabbing the first portion of the input, which enters in the format: b'1'
# where 1 is the value coming in, the final values being: b'\', b'r', b'\', b'n'
# which, along with the 'b', and ''' chars, are removed
inputValue = str(self.__serialPort.serialRead())
inputValue.split("'")
value = ""
# while the first '\' char of the carriage return, \r\n, has not been encountered, the
# the first char in the string is retained and outputList is built from each one
while inputValue[2] != "\\":
# skips errant, additional '.' chars if they are present in the input
if inputValue[2] == '.':
if not dotBool:
dotBool = True
value += inputValue[2]
else:
value += inputValue[2]
inputValue = str(self.__serialPort.serialRead())
inputValue.split("'")
# a list is built from the input, making the first char in the input the first
# element in the list which is a control char which marks whether the input is a
# voltage, with a 'v', or as a proximity reading, with any char from 'a' to 'n'
# and the second element the input value itself
if len(value) > 1:
outputList = [str(value[0]), str(value[1:])]
else:
outputList = value
inputValue = str(self.__serialPort.serialRead())
# method call to trimValue to trim excess trailing digits from the input which will
# then be returned
outputList = self.trimValue(outputList)
# the serial port buffer is flushed
self.__serialPort.flushSerialPort()
return outputList
# Name: trimValue
# Description: Parser class method which takes in a list containing as the second element
# a string which is to have trailing digits trimmed off depending whether the
# string corresponds to a voltage or a proximity reading
# Parameters: Takes in a list containing a control char marking the type of value which is
# being recieved from the serial port, which is the second element in the list
# Return: Returns the list that was taken in but with the string containing the value
# trimmed down to the proper size for use in other classes in the ground unit
def trimValue(self, outputList):
index = 1
voltLimit = 6
proxLimit = 5
if outputList != None and len(outputList) > 1 and len(
outputList[1]) > 0:
listSize = len(outputList[1])
# if the first element in the list is not a valid control then return None
if outputList[0] < 'a' or outputList[0] > 'z':
return None
# the input value is iterated through and there are non-numeric chars in the
# string, return None
while index < listSize:
if outputList[1][index] >= 'a' and outputList[1][index] <= 'z':
return None
index += 1
# if the input value is a voltage, enforce a string size of 5
if outputList[0] == 'v' and listSize > 6:
outputList[1] = outputList[1][:-(listSize - voltLimit)]
# else if the input value is proximity, enforce a string size of 4
elif len(outputList) > 0 and outputList[0] >= 'a' and outputList[
0] <= 'l' and listSize > 5:
outputList[1] = outputList[1][:-(listSize - proxLimit)]
return outputList
# Name: parsePipeInput
# Description: Parser class method which takes in a value and immediately returns it; provides for
# further parsing if necessary in the future by way of keeping other parsing methods
# intact
# Parameters: Takes in a value which is forwarded
# Return: Returns the value passed into the method
def parsePipeInput(self, inputValue):
return inputValue
def __init__(self, baudRate, timeOut, readinSize):
self.__serialReadSize = readinSize
# SerialPort object created with baud rate and timeout values passed into the constructor
self.__serialPort = SerialPort(baudRate, timeOut, readinSize)
def __init__(self, portName):
self.portName = portName
self.serialLink = SerialPort(self.portName)
class CommandCenter:
def __init__(self, portName):
self.portName = portName
self.serialLink = SerialPort(self.portName)
#binaryCommand = self.__getWirelessBinaryCommand(command, sensorId)
#self.__sendDataToSerialPort(binaryCommand)
#return self.__getFormatedDataFromSerialPort(lengthOfPacket=19,format)
def setStreamingTiming (self,interval,duration,delay, sensorId):
commandData = [0.0] * 3
commandData[0] = interval
commandData[1] = duration
commandData[2] = delay
data = self.__getWirelessBinaryCommand(Commands.SET_STREAMING_TIMING,sensorId,commandData=commandData,format=">III")
self.__retryIfSetCommandFailed(data,"setStreamingTiming", sensorId=sensorId)
def performOffsetOperation(self,sensorId):
#we are trying to find offset here by getting gravity vector of device and gravity vector that we want it as
northAndGravityVectors = self.__getNorthAndGravityVectorsInSensorFrame(sensorId)
untaredOrientationAsQuaternion = self.__getUntaredOrientationAsQuaternion(sensorId,needToReturnSensorId=False)
vectorAndQuaternionCalculator = VectorAndQuaternionCalculator()
offsetAsQuaternion = vectorAndQuaternionCalculator.getOffsetOrientationAsQuaternion(northAndGravityVectors)
#below two statements is to offset gd so that it is align with g
taredData = vectorAndQuaternionCalculator.getMultiplicationOfQuaternion(untaredOrientationAsQuaternion,offsetAsQuaternion)
self.__setTareOrientationAsSameAsSuppliedOrientationInQuaternionDomain(sensorId,tareData=taredData)
return offsetAsQuaternion
def getAngleBetweenThreeVectors(self, vectorOne,vectorTwo,vectorthree):
vectorAndQuaternionCalculator = VectorAndQuaternionCalculator()
return vectorAndQuaternionCalculator.calculateAngle(vectorOne,vectorTwo,vectorthree)
def getDeviceVector(self,sensorId, suppliedVector, offsetAsQuaternion):
taredOrientationAsQuaternion = self.__getTaredOrientationAsQuaternion(sensorId,needToReturnSensorId=False)
#print "taredOrientationAsQuaternion"
#print taredOrientationAsQuaternion
vectorAndQuaternionCalculator = VectorAndQuaternionCalculator()
vector = vectorAndQuaternionCalculator.getVectorOftheDeviceBasedOnSuppliedOrientation(suppliedVector,taredOrientationAsQuaternion,offsetAsQuaternion)
return vector
def calculateDeviceVector(self,sensorId,vector,offset):
taredOrientationAsQuaternion = self.__getTaredOrientationAsQuaternion(sensorId)
## Apply the offset for the device
quat = self.__quaternionMultiplication(taredOrientationAsQuaternion, offset)
## Calculate a vector for the device with its orientation
vector = self.__quaternionVectorMultiplication(quat, vector)
return vector
def getThisData(self):
numberOfByteAvaialbe = self.serialLink.getNumberOfByteAvailable()
if numberOfByteAvaialbe>18:
receivedData = self.serialLink.readData(numberOfByteAvaialbe)
if (numberOfByteAvaialbe == 19):
formatedData = self.__getFormatedData(receivedData,format=">ffff")
return formatedData
EmptyList = list()
return EmptyList
def getTaredOridntationAsQuaternionFromBuffer(self, sensorId):
print (self.serialLink.getNumberOfByteAvailable())
def getSerialBuffer(self):
print("the buffer is")
print ("available number of Byte")
print (self.serialLink.getNumberOfByteAvailable())
print repr(self.serialLink.readData(self.serialLink.getNumberOfByteAvailable()))
print ("available number of Byte after read")
print (self.serialLink.getNumberOfByteAvailable())
def closeSerialPort(self):
self.serialLink.clostPort()
def setStreamingSlot(self,sensorId, slot1, slot2 = chr(0xff),slot3 = chr(0xff), slot4= chr(0xff), slot5= chr(0xff), slot6= chr(0xff),slot7= chr(0xff),slot8= chr(0xff)):
commandData = [0.0] * 8
commandData[0] = slot1
commandData[1] = slot2
commandData[2] = slot3
commandData[3] = slot4
commandData[4] = slot5
commandData[5] = slot6
commandData[6] = slot7
commandData[7] = slot8
data = self.__getWirelessBinaryCommand(Commands.SET_STREAMING_SLOTS,sensorId, commandData=commandData,format='cccccccc')
self.__retryIfSetCommandFailed(data,"setStreamingSlots", sensorId=sensorId)
def startStreaming(self, sensorId):
binaryCommand = self.__getWirelessBinaryCommand(Commands.START_STREAMING, sensorId)
self.__sendDataToSerialPort(binaryCommand)
self.__retryIfSetCommandFailed(binaryCommand,"StartStreaming", sensorId=sensorId)
def stopStreaming(self,sensorId):
binaryCommand = self.__getWirelessBinaryCommand(Commands.STOP_STREAMING, sensorId)
self.__sendDataToSerialPort(binaryCommand)
self.__retryIfSetCommandFailed(binaryCommand,"StopStreaming", sensorId=sensorId)
def getStreamingTiming(self,sensorId):
binaryCommand = self.__getWirelessBinaryCommand(Commands.GET_STREAMING_TIMING, sensorId)
self.__sendDataToSerialPort(binaryCommand)
return self.__getFormatedDataFromSerialPort(lengthOfPacket=15,format="III")
########################################################################################################################
#Private function
def __getTaredOrientationAsQuaternion(self, sensorId,needToReturnSensorId = True):
command = Commands.getCommandAsChr(Commands.GET_TARED_ORIENTATION_AS_QUATERNION)
format = Commands.getRetrunDataFormat(Commands.GET_TARED_ORIENTATION_AS_QUATERNION)
lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_TARED_ORIENTATION_AS_QUATERNION)
binaryCommand = self.__getWirelessBinaryCommand(command, sensorId)
receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData)
if needToReturnSensorId is True:
return (self.__getFormatedData(receivedData,format))
else:
return (self.__getFormatedDataWithoutSensorId(receivedData,format))
def __setTareOrientationAsSameAsSuppliedOrientationInQuaternionDomain(self, sensorId, tareData):
command = Commands.getCommandAsChr(Commands.TARE_WITH_QUATERNION)
dataFormat = Commands.getDataFormat(Commands.TARE_WITH_QUATERNION)
binaryCommand = self.__getWirelessBinaryCommand(command, sensorId, tareData, dataFormat)
self.__retryIfSetCommandFailed(binaryCommand,"tareWithQuaternion", sensorId=sensorId)
def __getUntaredOrientationAsQuaternion(self, sensorId = 0,needToReturnSensorId = True):
command = Commands.getCommandAsChr(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION)
lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION)
format = Commands.getRetrunDataFormat(Commands.GET_UNTARED_ORIENTATION_AS_QUATERNION)
binaryCommand = self.__getWirelessBinaryCommand(command, sensorId)
receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData)
if needToReturnSensorId is True:
return (self.__getFormatedData(receivedData,format))
else:
#Note: starting byte is sensorId followed by data, need to remove index 0 if you dont want to get sensorId as return data
return (self.__getFormatedData(receivedData,format))[1:]
def __getFormatedDataWithoutSensorId(self,data, format):
actualData = data[3:len(data)]
dataToBeReturned = list(struct.unpack(format, actualData))
return dataToBeReturned
def __getNorthAndGravityVectorsInSensorFrame(self, sensorId):
command = Commands.getCommandAsChr(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME)
lengthOfReturnData = Commands.getReturnDataLength(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME)
format = Commands.getRetrunDataFormat(Commands.GET_NORTH_AND_GRAVITY_VECTORS_IN_SENSOR_FRAME)
binaryCommand = self.__getWirelessBinaryCommand(command, sensorId)
receivedData = self.__getRawDataAndRetryIfGetCommandFailed(sensorId,binaryCommand,lengthOfReturnData)
return (self.__getFormatedData(receivedData,format))
def __getRawDataAndRetryIfGetCommandFailed(self,sensorId,binaryCommand, returnDataLength):
WIRELESS_HEADER_LENGTH = 3
SUCESSFULLY_SENT_BYTE = chr(0x00)
TOTAL_PACKET_LENGTH = WIRELESS_HEADER_LENGTH + returnDataLength
self.__sendDataToSerialPort(binaryCommand)
receivedData = (self.serialLink.readData(TOTAL_PACKET_LENGTH))
while receivedData[0] != SUCESSFULLY_SENT_BYTE and receivedData[1] != sensorId and receivedData != returnDataLength:
print "send to sensor Id" + str(sensorId) + "fail"
self.serialLink.flushBuffer()
self.__sendDataToSerialPort(binaryCommand)
receivedData = (self.serialLink.readData(TOTAL_PACKET_LENGTH))
return receivedData
def __getFormatedData(self, data, format):
actualData = data[3:len(data)]
sensorId = data[1]
dataToBeReturned = list(struct.unpack(format, actualData))
dataToBeReturned.insert(0,ord(sensorId))
return dataToBeReturned
def __getSensorId(self,data):
return data[1]
def __flushBuffer(self):
self.serialLink.readData(self.serialLink.getNumberOfByteAvailable())
self.serialLink.flushBuffer()
def __retryIfSetCommandFailed(self, data, nameOfCommand, sensorId):
self.__sendDataToSerialPort(data)
while self.__isCommandSuccessful(sensorId) == False:
self.__flushBuffer()
print ("going to send again")
self.__sendDataToSerialPort(data)
print (nameOfCommand + " command is successfully sent to sensor ID: " + str(sensorId))
def __isCommandSuccessful(self, sensorId):
print(self.serialLink.getNumberOfByteAvailable())
numberOfbyte = self.serialLink.getNumberOfByteAvailable()
print (numberOfbyte)
receivedData = (self.serialLink.readData(3))
if ((receivedData[0] == chr(0x00))and(receivedData[1]==chr(int(sensorId)))):
#print ("command successful" + repr(receivedData))
return True
else:
#print ("command failed" + repr(receivedData))
return False
def __getFormatedDataFromSerialPort(self, lengthOfPacket, format):
receivedData = (self.serialLink.readData(lengthOfPacket))
if receivedData[0] == chr(0x00):
print "successful"
actualData = receivedData[3:lengthOfPacket]
outputData = list(struct.unpack(format, actualData))
return outputData
else:
print("data not avaialbe yet" + repr(receivedData))
return None
def __sendDataToSerialPort(self, data):
self.serialLink.sendData(data)
def __getWirelessBinaryCommand(self, command, sensorId, commandData=[], format=""):
sensorId = chr(int(sensorId))
if len(commandData) > 0:
packedData = struct.pack(format, *commandData)
sendingData = Commands.WIRELESS_STARTING_BYTE + sensorId + command + packedData + self.__getCheckSum(
sensorId + command + packedData)
return sendingData
else:
sendingData = Commands.WIRELESS_STARTING_BYTE + sensorId + command + self.__getCheckSum(
sensorId + command)
return sendingData
def __getCheckSum(self, char_data):
""" Calculates the checksum for the given data.
Args: char_data: A string of data.
"""
checksum = 0
for byte in char_data:
checksum += ord(byte)
return chr(checksum % 256)
class SerialModem:
"""
Class representing a serial panstamp modem
"""
class Mode:
"""
Serial modes
"""
DATA = 0
COMMAND = 1
def stop(self):
"""
Stop serial gateway
"""
if self._serport is not None:
self._serport.stop()
def _serialPacketReceived(self, buf):
"""
Serial packet received. This is a callback function called from
the SerialPort object
@param buf: Serial packet received in String format
"""
# If modem in command mode
if self._sermode == SerialModem.Mode.COMMAND:
self._atresponse = buf
self.__atresponse_received = True
# If modem in data mode
else:
# Waiting for ready signal from modem?
if self._wait_modem_start == False:
if buf == "Modem ready!":
self._wait_modem_start = True
# Create CcPacket from string and notify reception
elif self._ccpacket_received is not None:
try:
ccPacket = CcPacket(buf)
self._ccpacket_received(ccPacket)
except SwapException:
raise
def setRxCallback(self, cbFunct):
"""
Set callback reception function. Notify new CcPacket reception
@param cbFunct: Definition of custom Callback function for the reception of packets
"""
self._ccpacket_received = cbFunct
def goToCommandMode(self):
"""
Enter command mode (for AT commands)
@return True if the serial gateway does enter Command Mode. Return false otherwise
"""
if self._sermode == SerialModem.Mode.COMMAND:
return True
self._sermode = SerialModem.Mode.COMMAND
response = self.runAtCommand("+++", 5000)
if response is not None:
if response[:2] == "OK":
return True
self._sermode = SerialModem.Mode.DATA
return False
def goToDataMode(self):
"""
Enter data mode (for Rx/Tx operations)
@return True if the serial gateway does enter Data Mode. Return false otherwise
"""
if self._sermode == SerialModem.Mode.DATA:
return True
response = self.runAtCommand("ATO\r")
if response is not None:
if response[0:2] == "OK":
self._sermode = SerialModem.Mode.DATA;
return True;
return False;
def reset(self):
"""
Reset serial gateway
@return True if the serial gateway is successfully restarted
"""
# Switch to command mode if necessary
if self._sermode == SerialModem.Mode.DATA:
self.goToCommandMode()
# Run AT command
response = self.runAtCommand("ATZ\r")
if response is None:
return False
if response[0:2] == "OK":
self._sermode = SerialModem.Mode.DATA
return True
return False
def runAtCommand(self, cmd="AT\r", timeout=1000):
"""
Run AT command on the serial gateway
@param cmd: AT command to be run
@param timeout: Period after which the function should timeout
@return Response received from gateway or None in case of lack of response (timeout)
"""
self.__atresponse_received = False
# Send command via serial
if self._serport is None:
raise SwapException("Port " + self.portname + " is not open")
# Skip wireless packets
self._atresponse = "("
# Send serial packet
self._serport.send(cmd)
# Wait for response from modem
while len(self._atresponse) == 0 or self._atresponse[0] == '(':
if not self._waitForResponse(timeout):
return None
# Return response received from gateway
return self._atresponse
def sendCcPacket(self, packet):
"""
Send wireless CcPacket through the serial gateway
@param packet: CcPacket to be transmitted
"""
strBuf = packet.toString() + "\r"
self._serport.send(strBuf)
def setFreqChannel(self, value):
"""
Set frequency channel for the wireless gateway
@param value: New frequency channel
"""
# Check format
if value > 0xFF:
raise SwapException("Frequency channels must be 1-byte length")
# Switch to command mode if necessary
if self._sermode == SerialModem.Mode.DATA:
self.goToCommandMode()
# Run AT command
response = self.runAtCommand("ATCH=" + "{0:02X}".format(value) + "\r")
if response is None:
return False
if response[0:2] == "OK":
self.freq_channel = value
return True
return False
def setSyncWord(self, value):
"""
Set synchronization word for the wireless gateway
@param value: New synchronization word
"""
# Check format
if value > 0xFFFF:
raise SwapException("Synchronization words must be 2-byte length")
# Switch to command mode if necessary
if self._sermode == SerialModem.Mode.DATA:
self.goToCommandMode()
# Run AT command
response = self.runAtCommand("ATSW=" + "{0:04X}".format(value) + "\r")
if response is None:
return False
if response[0:2] == "OK":
self.syncword = value
return True
else:
return False
def setDevAddress(self, value):
"""
Set device address for the serial gateway
@param value: New device address
"""
# Check format
if value > 0xFF:
raise SwapException("Device addresses must be 1-byte length")
# Switch to command mode if necessary
if self._sermode == SerialModem.Mode.DATA:
self.goToCommandMode()
# Run AT command
response = self.runAtCommand("ATDA=" + "{0:02X}".format(value) + "\r")
if response is None:
return False
if response[0:2] == "OK":
self.devaddress = value
return True
else:
return False
def _waitForResponse(self, millis):
"""
Wait a given amount of milliseconds for a response from the serial modem
@param millis: Amount of milliseconds to wait for a response
"""
loops = millis / 10
while not self.__atresponse_received:
time.sleep(0.01)
loops -= 1
if loops == 0:
return False
return True
def __init__(self, portname="/dev/ttyUSB0", speed=38400, verbose=False):
"""
Class constructor
@param portname: Name/path of the serial port
@param speed: Serial baudrate in bps
@param verbose: Print out SWAP traffic (True or False)
"""
# Serial mode (command or data modes)
self._sermode = SerialModem.Mode.DATA
# Response to the last AT command sent to the serial modem
self._atresponse = ""
# AT response received from modem
self.__atresponse_received = None
# "Packet received" callback function. To be defined by the parent object
self._ccpacket_received = None
## Name(path) of the serial port
self.portname = portname
## Speed of the serial port in bps
self.portspeed = speed
## Hardware version of the serial modem
self.hwversion = None
## Firmware version of the serial modem
self.fwversion = None
try:
# Open serial port
self._serport = SerialPort(self.portname, self.portspeed, verbose)
# Define callback function for incoming serial packets
self._serport.setRxCallback(self._serialPacketReceived)
# Run serial port thread
self._serport.start()
# This flags switches to True when the serial modem is ready
self._wait_modem_start = False
start = time.time()
soft_reset = False
while self._wait_modem_start == False:
elapsed = time.time() - start
if not soft_reset and elapsed > 5:
self.reset()
soft_reset = True
elif soft_reset and elapsed > 10:
raise SwapException("Unable to reset serial modem")
# Retrieve modem settings
# Switch to command mode
if not self.goToCommandMode():
raise SwapException("Modem is unable to enter command mode")
# Hardware version
response = self.runAtCommand("ATHV?\r")
if response is None:
raise SwapException("Unable to retrieve Hardware Version from serial modem")
self.hwversion = long(response, 16)
# Firmware version
response = self.runAtCommand("ATFV?\r")
if response is None:
raise SwapException("Unable to retrieve Firmware Version from serial modem")
self.fwversion = long(response, 16)
# Frequency channel
response = self.runAtCommand("ATCH?\r")
if response is None:
raise SwapException("Unable to retrieve Frequency Channel from serial modem")
## Frequency channel of the serial gateway
self.freq_channel = int(response, 16)
# Synchronization word
response = self.runAtCommand("ATSW?\r")
if response is None:
raise SwapException("Unable to retrieve Synchronization Word from serial modem")
## Synchronization word of the serial gateway
self.syncword = int(response, 16)
# Device address
response = self.runAtCommand("ATDA?\r")
if response is None:
raise SwapException("Unable to retrieve Device Address from serial modem")
## Device address of the serial gateway
self.devaddress = int(response, 16)
# Switch to data mode
self.goToDataMode()
except:
raise
def OnOk( self, event ):
""" Clicked on OK """
twr_ser = self.cbTwrSerPort.GetValue().encode('ASCII')
if twr_ser == "":
wx.MessageBox("Please enter an valid serial port name for \
communicating with the tower ")
self.set_invalid()
return
else:
try:
ser = SerialPort(twr_ser)
ser.write_to_port('X0') # Write some known command for a check
read_info = ser.read_from_twr()
if read_info[1] == False:
dlg = wx.MessageDialog(self, "The Tower did not respond with expected response."+ \
" Please make sure that you have selected appropriate port."+ \
"\n\n Do you want to retry with a different serial port ?", \
"Warning",
wx.YES_NO)
resp = dlg.ShowModal()
dlg.Destroy()
if resp == wx.ID_YES:
ser.close_port()
self.set_invalid()
return
else:
self.config.set_twr_ser_port(twr_ser)
ser.close_port()
except IOError:
wx.MessageBox("Could not open com port %s ", twr_ser)
self.set_invalid()
return
dmm_ser = self.cbDmmSerPort.GetValue().encode('ASCII')
if dmm_ser == "":
wx.MessageBox("Please enter an valid serial port name for \
communicating with the DMM ")
self.set_invalid()
return
else:
try:
ser = SerialPort(dmm_ser, '9600', '2')
read_info = ser.read_from_dmm()
if read_info[1] == False :
dlg = wx.MessageDialog(self, "The dmm did not respond with expected response."+ \
" Please make sure that you have selected appropriate port."+ \
" And that the DMM has been set up properly " + \
"\n\n Do you want to retry with a different serial port ?", \
"Warning",
wx.YES_NO)
resp = dlg.ShowModal()
dlg.Destroy()
if resp == wx.ID_YES:
ser.close_port()
self.set_invalid()
return
else:
self.config.set_dmm_ser_port(dmm_ser)
ser.close_port()
except IOError:
wx.MessageBox("Could not open com port %s ", twr_ser)
self.set_invalid()
return
if dmm_ser == twr_ser:
# can't use same port for both DMM and Tower
wx.MessageBox("Cannot use same port for communicating with both \n"+
"Tower and DMM ")
self.set_invalid()
return
# Let us validate the exstince of the command file
if os.path.exists(self.config.get_cmd_file()) == False:
wx.MessageBox("Please enter a valid path for command file ")
self.set_invalid()
return
if os.path.exists(self.config.get_log_file()) == False:
wx.MessageBox("Please enter a valid path for log file ")
self.set_invalid()
return
# if we have made it to this point, most of the things are valid
# except for the serial ports which are dependent on user choice(s)
self.set_valid()
self.Close()
def start(self, config):
self.serialPort = SerialPort(self, config.get('port_address'), Constants.SERIAL_MESSAGE_DELIMITER)
self.serialPort.openPort()
pass
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open("logconfig.yaml", "r") as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger("app")
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("app_id", None),
("app_ver", 0x03010A00),
("bundle_id", "12345678901234567890123456789012"),
]
]
)
if not self.active_info.get("app_id"):
raise TypeError('{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("crc16_init", 0x3AA3),
("crc16_poly", 0x18005),
("crc32_init", 0x3AA3),
("crc32_poly", 0x104C11DB7),
("aes256_key", None),
]
]
)
if not encrypt_param.get("aes256_key"):
raise TypeError('{}.__init__() must pass argument "aes256_key"!'.format(__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("port", "/dev/ttyUSB0"),
("baudrate", 230400),
("read_bytes", 12),
("buffer_queue", self.port_rx_stream_queue),
]
]
)
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(self.port_rx_stream_queue, self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
from SerialPort import SerialPort
from time import sleep
com = SerialPort('COM6', timeout=5)
com.sendMsg('12 01 01 FF')
sleep(3)
com.sendMsg('05 14 2B 37 39 32 31 38 36 37 31 39 39 37 00 00 00 00 00 00 00 00 FF')
# Wait UP batton
com.waitMsg()
com.sendMsg('1F 01 01 FF')
#sleep(3)
com.sendMsg('04 01 01 FF')
def __init__(self, *args, **kwargs):
Tk.__init__(self, *args, **kwargs)
self.activeTab = 0
self.geometry("775x550")
self.title("Pedalbox")
# self.iconbitmap("assets/pedal.ico")
self.serial_data = ''
self.filter_data = ''
# Main Container
container = Frame(self, bg='white')
container.pack(fill="both")
tablayout = Notebook(container)
################################################################
## tab1
tab1 = Frame(tablayout, bg='white')
tab1.pack(fill="both")
clutch_cluster = ClutchCluster(tab1, self)
brake_cluster = BrakeCluster(tab1, self)
throttle_cluster = ThrottleCluster(tab1, self)
clutch_cluster.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
brake_cluster.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
throttle_cluster.grid(row=0, column=2, padx=10, pady=10, sticky="nsew")
tab1.grid_columnconfigure(0, weight=1)
tab1.grid_columnconfigure(1, weight=1)
tab1.grid_columnconfigure(2, weight=1)
tablayout.add(tab1, text="Clusters")
################################################################
# tab2
tab2 = Frame(tablayout, bg='white')
tab2.pack(fill="both", expand=1)
clutch = Clutch(tab2, self)
brake = Brake(tab2, self)
throttle = Throttle(tab2, self)
clutch.grid(row=0, column=0, padx=10, pady=10, sticky="nsew")
brake.grid(row=0, column=1, padx=10, pady=10, sticky="nsew")
throttle.grid(row=0, column=2, padx=10, pady=10, sticky="nsew")
tab2.grid_columnconfigure(0, weight=1)
tab2.grid_columnconfigure(1, weight=1)
tab2.grid_columnconfigure(2, weight=1)
tablayout.add(tab2, text="Settings")
tablayout.pack(fill="both", expand=1)
################################################################
# tab3
tab3 = Frame(tablayout, bg='white')
tab3.pack(fill="both", expand=1)
serial_port_settings = SerialPort(tab3, self)
serial_port_settings.grid(row=0,
column=0,
padx=10,
pady=10,
sticky="nsew")
tablayout.add(tab3, text="config")
tablayout.pack(fill="both", expand=1)
tablayout.bind("<<NotebookTabChanged>>",
lambda event: self.tab_changed(tablayout))
connect_button = Button(
self,
text="connect serial port",
command=lambda: serial_connect(self,
get_connection_info()[1],
get_connection_info()[0]))
connect_button.pack()
disconect_button = Button(self,
text="disconect serial port",
command=serial_disconect)
disconect_button.pack()
pub.subscribe(get_map_update_clutch, 'clutch_map_update')
pub.subscribe(get_map_update_brake, 'brake_map_update')
pub.subscribe(get_map_update_throttle, 'throttle_map_update')
class SDKApplication(StoppableThread):
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open('logconfig.yaml', 'r') as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger('app')
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('app_id', None),
('api_level', 0x02),
('app_ver', 0x01),
('bundle_id', '12345678901234567890123456789012'),
]]
)
if not self.active_info.get('app_id'):
raise TypeError(
'{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('crc16_init', 0x3AA3),
('crc16_poly', 0x18005),
('crc32_init', 0x3AA3),
('crc32_poly', 0x104C11DB7),
('aes256_key', None),
]]
)
if not encrypt_param.get('aes256_key'):
raise TypeError(
'{}.__init__() must pass argument "aes256_key"!'.format(__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict(
[(k, kwargs.get(k, v)) for (k, v) in [
('port', '/dev/ttyUSB0'),
('baudrate', 230400),
('read_bytes', 12),
('buffer_queue', self.port_rx_stream_queue),
]]
)
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(
self.port_rx_stream_queue, self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
def register_data_handle(self):
self.recv_data_handler_table = CMD_SET_R
def launch(self):
self.start()
def close(self):
self.sm.close_all_sessions()
self.port.close()
self.stop()
def run(self):
while (not self.stopped()):
try:
(header, data_buf) = self.parsed_message_queue.get(
block=True, timeout=3.0)
assert isinstance(header, ProtocolHeader) and isinstance(
data_buf, bytes)
if header.ack:
self.sm.feed_ack(header.session, header.seq, data_buf)
else:
d = ProtocolData()
cmd_set, cmd_id, content = d.parse(data_buf)
self.recv_data_handler_table[cmd_set][cmd_id](content)
# LOG('Data received.')
except Queue.Empty, e:
pass
class SDKApplication(StoppableThread):
"""
SDKApplication class for main entrance for api.
Usage:
>>> app = SDKApplication(app_id, aes256_key, port)
>>> app.get_api_version()
...
>>> app.active_api()
...
>>> app.acquire_control()
...
>>> app.release_control()
...
>>> app.close()
The following are the parameters supplied to the constructor.
app_id -- your app id
aes256_key -- your enc key
port -- your serial port path
baudrate -- your serial port baudrate
"""
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open("logconfig.yaml", "r") as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger("app")
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("app_id", None),
("app_ver", 0x03010A00),
("bundle_id", "12345678901234567890123456789012"),
]
]
)
if not self.active_info.get("app_id"):
raise TypeError('{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("crc16_init", 0x3AA3),
("crc16_poly", 0x18005),
("crc32_init", 0x3AA3),
("crc32_poly", 0x104C11DB7),
("aes256_key", None),
]
]
)
if not encrypt_param.get("aes256_key"):
raise TypeError('{}.__init__() must pass argument "aes256_key"!'.format(__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict(
[
(k, kwargs.get(k, v))
for (k, v) in [
("port", "/dev/ttyUSB0"),
("baudrate", 230400),
("read_bytes", 12),
("buffer_queue", self.port_rx_stream_queue),
]
]
)
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(self.port_rx_stream_queue, self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
def register_data_handle(self):
self.recv_data_handler_table = CMD_SET_R
def launch(self):
self.start()
def close(self):
self.sm.close_all_sessions()
self.port.close()
self.stop()
def run(self):
while not self.stopped():
try:
(header, data_buf) = self.parsed_message_queue.get(block=True, timeout=3.0)
assert isinstance(header, ProtocolHeader) and isinstance(data_buf, bytes)
if header.ack:
self.sm.feed_ack(header.session, header.seq, data_buf)
else:
d = ProtocolData()
cmd_set, cmd_id, content = d.parse(data_buf)
self.recv_data_handler_table[cmd_set][cmd_id](content)
# LOG('Data received.')
except Queue.Empty, e:
pass
class MainWindow(QMainWindow, Ui_MainWindow):
serial_readyWrite_signal = QtCore.pyqtSignal(str, bytes, str)
serial_readyRead_signal = QtCore.pyqtSignal(bool)
def __init__(self):
super().__init__()
self.setupUi(self)
self.comboBox = MyCombox(self.centralwidget)
self.comboBox.setGeometry(QtCore.QRect(750, 40, 193, 30))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.comboBox.sizePolicy().hasHeightForWidth())
self.comboBox.setSizePolicy(sizePolicy)
self.comboBox.setMinimumSize(QtCore.QSize(0, 30))
self.comboBox.setObjectName("comboBox")
self.comboBox.enter_event_signal.connect(self.onComboxEnterSlot)
self.serial_port = SerialPort()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox_2.addItem('1200')
self.comboBox_2.addItem('2400')
self.comboBox_2.addItem('4800')
self.comboBox_2.addItem('9600')
self.comboBox_2.addItem('19200')
self.comboBox_2.addItem('38400')
self.comboBox_2.addItem('57600')
self.comboBox_2.addItem('115200')
self.comboBox_2.setCurrentIndex(3)
self.comboBox_2.currentIndexChanged.connect(
self.onCombox_2IncdeChangeSlot)
self.comboBox_3.addItem('1')
self.comboBox_3.addItem('1.5')
self.comboBox_3.addItem('2')
self.comboBox_3.setCurrentIndex(0)
self.comboBox_3.currentIndexChanged.connect(
self.onCombox_3IncdeChangeSlot)
self.comboBox_4.addItem('5')
self.comboBox_4.addItem('6')
self.comboBox_4.addItem('7')
self.comboBox_4.addItem('8')
self.comboBox_4.setCurrentIndex(3)
self.comboBox_4.currentIndexChanged.connect(
self.onCombox_4IncdeChangeSlot)
self.comboBox_5.addItem('无')
self.comboBox_5.addItem('奇校验')
self.comboBox_5.addItem('偶校验')
self.comboBox_5.setCurrentIndex(0)
self.comboBox_5.currentIndexChanged.connect(
self.onCombox_5IncdeChangeSlot)
self.pushButton_flag = True
self.pushButton.clicked.connect(self.onPushButtonClickedSlot)
self.pushButton_2.clicked.connect(self.onPushButton_2ClickedSlot)
self.pushButton_3.clicked.connect(self.onPushButton_3ClickedSlot)
self.pushButton_4.clicked.connect(self.onPushButton_4ClickedSlot)
self.pushButton_5.clicked.connect(self.onPushButton_5ClickedSlot)
self.write_encodemode = 'utf-8'
self.radioButton.toggled.connect(self.onRadioButtonToggledSlot)
self.radioButton_2.toggled.connect(self.onRadioButton_2ToggledSlot)
self.radioButton_3.toggled.connect(self.onRadioButton_3ToggledSlot)
self.radioButton_4.toggled.connect(self.onRadioButton_4ToggledSlot)
self.radioButton_5.toggled.connect(self.onRadioButton_5ToggledSlot)
self.radioButton_6.toggled.connect(self.onRadioButton_6ToggledSlot)
self.serial_write_thread = QtCore.QThread()
self.serial_write_threadObject = SerialWriteThreadObject(
self.serial_port)
self.serial_write_threadObject.moveToThread(self.serial_write_thread)
self.serial_write_threadObject.write_finished.connect(
self.serialWriteThreadFinishedSlot)
self.serial_readyWrite_signal.connect(
self.serial_write_threadObject.serialWriteSlot)
self.serial_write_thread.start()
self.serial_read_thread = QtCore.QThread()
self.serial_read_threadObject = SerialReadThreadObject(
self.serial_port)
self.serial_read_threadObject.moveToThread(self.serial_read_thread)
self.serial_port.readyRead.connect(self.serialReadyReadSlot)
self.serial_readyRead_signal.connect(
self.serial_read_threadObject.serialReadSlot)
self.serial_read_threadObject.read_finished.connect(
self.serialReadThreadFinishedSlot)
self.serial_read_thread.start()
self.receive_color = QtGui.QColor(220, 20, 60)
self.send_color = QtGui.QColor(153, 50, 204)
self.textBrowser_text_list = []
self.textBrowser_addTime_flag = False
self.textBrowser_hex_flag = False
self.write_newLine_flag = False
self.write_hex_flag = False
self.textEdit_textNum = 0
def onComboxEnterSlot(self):
if self.pushButton_flag:
index = self.comboBox.currentIndex()
text = self.comboBox.currentText()
self.comboBox.clear()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox.setCurrentIndex(index)
if self.comboBox.currentText() != text:
self.comboBox.setCurrentIndex(0)
def onCombox_2IncdeChangeSlot(self):
current_index = self.comboBox_2.currentIndex()
if current_index == 0:
self.serial_port.baund_rate = QSerialPort.Baud1200
elif current_index == 1:
self.serial_port.baund_rate = QSerialPort.Baud2400
elif current_index == 2:
self.serial_port.baund_rate = QSerialPort.Baud4800
elif current_index == 3:
self.serial_port.baund_rate = QSerialPort.Baud9600
elif current_index == 4:
self.serial_port.baund_rate = QSerialPort.Baud19200
elif current_index == 5:
self.serial_port.baund_rate = QSerialPort.Baud38400
elif current_index == 6:
self.serial_port.baund_rate = QSerialPort.Baud57600
elif current_index == 7:
self.serial_port.baund_rate = QSerialPort.Baud115200
def onCombox_3IncdeChangeSlot(self):
current_index = self.comboBox_3.currentIndex()
if current_index == 0:
self.serial_port.stop_bits = QSerialPort.OneStop
elif current_index == 1:
self.serial_port.stop_bits = QSerialPort.OneAndHalfStop
elif current_index == 2:
self.serial_port.stop_bits = QSerialPort.TwoStop
def onCombox_4IncdeChangeSlot(self):
current_index = self.comboBox_4.currentIndex()
if current_index == 0:
self.serial_port.data_bits = QSerialPort.Data5
elif current_index == 1:
self.serial_port.data_bits = QSerialPort.Data6
elif current_index == 2:
self.serial_port.data_bits = QSerialPort.Data7
elif current_index == 3:
self.serial_port.data_bits = QSerialPort.Data8
def onCombox_5IncdeChangeSlot(self):
current_index = self.comboBox_5.currentIndex()
if current_index == 0:
self.serial_port.parity = QSerialPort.NoParity
elif current_index == 1:
self.serial_port.parity = QSerialPort.OddParity
elif current_index == 2:
self.serial_port.parity = QSerialPort.EvenParity
def onPushButtonClickedSlot(self):
if self.pushButton_flag:
port_name = self.comboBox.currentText()
if port_name != '':
self.serial_port.setPort(self.serial_port.port[port_name])
self.serial_port.open(QSerialPort.ReadWrite)
self.serial_port.setBaudRate(self.serial_port.baund_rate)
self.serial_port.setStopBits(self.serial_port.stop_bits)
self.serial_port.setDataBits(self.serial_port.data_bits)
self.serial_port.setParity(self.serial_port.parity)
self.pushButton_flag = False
self.pushButton.setStyleSheet("border-image: url(:/pic/on.png);")
self.comboBox.setEnabled(False)
self.comboBox_2.setEnabled(False)
self.comboBox_3.setEnabled(False)
self.comboBox_4.setEnabled(False)
self.comboBox_5.setEnabled(False)
else:
self.serial_port.close()
self.pushButton_flag = True
self.pushButton.setStyleSheet("border-image: url(:/pic/off.png);")
self.comboBox.setEnabled(True)
self.comboBox_2.setEnabled(True)
self.comboBox_3.setEnabled(True)
self.comboBox_4.setEnabled(True)
self.comboBox_5.setEnabled(True)
def onPushButton_2ClickedSlot(self):
file_name, _ = QtWidgets.QFileDialog.getSaveFileName(
self, '文件保存', './untitled.txt', 'Text files (*.txt)')
result = ''
with open(file_name, 'w') as fp:
for text_list in self.textBrowser_text_list:
text = "%s%s\n%s" % (text_list[0], text_list[2], text_list[1])
result = result + '\n' + text
fp.write(result)
def onPushButton_3ClickedSlot(self):
self.textBrowser.clear()
self.textBrowser_text_list = []
def onPushButton_4ClickedSlot(self):
self.textEdit.clear()
def onPushButton_5ClickedSlot(self):
if not self.pushButton_flag:
text = self.textEdit.toPlainText()
if text != '':
text_bytes = b''
if self.write_newLine_flag:
text = text + '\r\n'
if self.write_hex_flag:
text_bytes = StringProcess.hexStringToStingBytes(text)
self.serial_readyWrite_signal.emit(text, text_bytes,
self.write_encodemode)
def onRadioButtonToggledSlot(self):
if self.radioButton.isChecked():
self.textBrowser_addTime_flag = True
self.textBrowser.clear()
for text_list in self.textBrowser_text_list:
text = "%s%s\n%s" % (text_list[0], text_list[2], text_list[1])
result_filter = StringProcess.stringToHtmlFilter(text)
if text_list[0] == '[SEND]:':
result = StringProcess.stringToHtml(
result_filter, self.send_color)
else:
result = StringProcess.stringToHtml(
result_filter, self.receive_color)
self.textBrowser.append(result)
else:
self.textBrowser_addTime_flag = False
self.textBrowser.clear()
for text_list in self.textBrowser_text_list:
text = "%s\n%s" % (text_list[0], text_list[1])
result_filter = StringProcess.stringToHtmlFilter(text)
if text_list[0] == '[SEND]:':
result = StringProcess.stringToHtml(
result_filter, self.send_color)
else:
result = StringProcess.stringToHtml(
result_filter, self.receive_color)
self.textBrowser.append(result)
def onRadioButton_2ToggledSlot(self):
if self.radioButton_2.isChecked():
self.textBrowser_hex_flag = True
else:
self.textBrowser_hex_flag = False
def onRadioButton_3ToggledSlot(self):
text = self.textEdit.toPlainText()
if self.radioButton_3.isChecked():
self.write_hex_flag = True
self.textEdit.textChanged.connect(self.textEditTextChangeSlot)
if text != '':
result = StringProcess.stringToHexString(
text, self.write_encodemode)
self.textEdit.clear()
self.textEdit.setText(result)
else:
self.write_hex_flag = False
self.textEdit.textChanged.disconnect(self.textEditTextChangeSlot)
if text != '':
result, flag = StringProcess.hexStringToSting(
self.textEdit.toPlainText(), self.write_encodemode)
if not flag:
self.write_hex_flag = True
self.radioButton_3.toggled.disconnect(
self.onRadioButton_3ToggledSlot)
self.radioButton_3.setChecked(True)
self.radioButton_3.toggled.connect(
self.onRadioButton_3ToggledSlot)
QtWidgets.QMessageBox.warning(self, '警告',
'输入的16进制字节串无法用utf-8解码，请确认！')
self.textEdit.textChanged.connect(
self.textEditTextChangeSlot)
else:
self.textEdit.clear()
self.textEdit.setText(result)
def onRadioButton_4ToggledSlot(self):
self.write_encodemode = 'utf-8'
def onRadioButton_5ToggledSlot(self):
self.write_encodemode = 'gbk'
def onRadioButton_6ToggledSlot(self):
if self.radioButton_6.isChecked():
self.write_newLine_flag = True
else:
self.write_newLine_flag = False
def textEditTextChangeSlot(self):
text = self.textEdit.toPlainText()
if text != '':
cursor = self.textEdit.textCursor()
col = cursor.columnNumber()
row = cursor.blockNumber()
document = self.textEdit.document()
block_text = document.findBlockByNumber(row).text()
self.textEdit.textChanged.disconnect(self.textEditTextChangeSlot)
if self.textEdit_textNum < len(text):
if col > 0:
if ('0' <= block_text[col-1] <= '9') or ('a' <= block_text[col-1] <= 'f') \
or ('A' <= block_text[col-1] <= 'F'):
if col > 1:
if block_text[col - 2] != ' ':
if col == len(block_text):
self.textEdit.insertPlainText(' ')
elif block_text[col] != ' ' and block_text[
col] != '\n':
self.textEdit.insertPlainText(' ')
elif block_text[col - 1] != ' ' and block_text[col -
1] != '\n':
QtWidgets.QMessageBox.warning(
self, '输入警告', '在16进制输入下只允许0-9、a-f、A-F！')
ch = block_text[col - 1]
text = text.strip(ch)
self.textEdit.setText(text)
self.textEdit.moveCursor(QtGui.QTextCursor.End,
QtGui.QTextCursor.MoveAnchor)
self.textEdit.textChanged.connect(self.textEditTextChangeSlot)
self.textEdit_textNum = len(text)
def serialWriteThreadFinishedSlot(self):
text = self.textEdit.toPlainText()
current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
setting = '[SEND]:'
if self.write_hex_flag:
setting = setting + '(hex)'
temp_list = [setting, text, current_time]
self.textBrowser_text_list.append(temp_list)
if self.textBrowser_addTime_flag:
result = "%s(%s)\n%s" % (setting, current_time, text)
else:
result = "%s\n%s" % (setting, text)
result_filter = StringProcess.stringToHtmlFilter(result)
self.textBrowser.append(
StringProcess.stringToHtml(result_filter, self.send_color))
def serialReadThreadFinishedSlot(self, data):
current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
setting = '[RECEIVE]:'
if self.textBrowser_hex_flag:
setting = setting + '(hex)'
temp_list = [setting, data, current_time]
self.textBrowser_text_list.append(temp_list)
if self.textBrowser_addTime_flag:
result = "%s(%s)\n%s" % (setting, current_time, data)
else:
result = "%s\n%s" % (setting, data)
result_filter = StringProcess.stringToHtmlFilter(result)
self.textBrowser.append(
StringProcess.stringToHtml(result_filter, self.receive_color))
def serialReadyReadSlot(self):
self.serial_readyRead_signal.emit(self.textBrowser_hex_flag)
def __init__(self):
super().__init__()
self.setupUi(self)
self.comboBox = MyCombox(self.centralwidget)
self.comboBox.setGeometry(QtCore.QRect(750, 40, 193, 30))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.comboBox.sizePolicy().hasHeightForWidth())
self.comboBox.setSizePolicy(sizePolicy)
self.comboBox.setMinimumSize(QtCore.QSize(0, 30))
self.comboBox.setObjectName("comboBox")
self.comboBox.enter_event_signal.connect(self.onComboxEnterSlot)
self.serial_port = SerialPort()
self.serial_port.searchPort()
self.serial_list = list(self.serial_port.port.keys())
self.serial_list.sort()
for item in self.serial_list:
self.comboBox.addItem(item)
self.comboBox_2.addItem('1200')
self.comboBox_2.addItem('2400')
self.comboBox_2.addItem('4800')
self.comboBox_2.addItem('9600')
self.comboBox_2.addItem('19200')
self.comboBox_2.addItem('38400')
self.comboBox_2.addItem('57600')
self.comboBox_2.addItem('115200')
self.comboBox_2.setCurrentIndex(3)
self.comboBox_2.currentIndexChanged.connect(
self.onCombox_2IncdeChangeSlot)
self.comboBox_3.addItem('1')
self.comboBox_3.addItem('1.5')
self.comboBox_3.addItem('2')
self.comboBox_3.setCurrentIndex(0)
self.comboBox_3.currentIndexChanged.connect(
self.onCombox_3IncdeChangeSlot)
self.comboBox_4.addItem('5')
self.comboBox_4.addItem('6')
self.comboBox_4.addItem('7')
self.comboBox_4.addItem('8')
self.comboBox_4.setCurrentIndex(3)
self.comboBox_4.currentIndexChanged.connect(
self.onCombox_4IncdeChangeSlot)
self.comboBox_5.addItem('无')
self.comboBox_5.addItem('奇校验')
self.comboBox_5.addItem('偶校验')
self.comboBox_5.setCurrentIndex(0)
self.comboBox_5.currentIndexChanged.connect(
self.onCombox_5IncdeChangeSlot)
self.pushButton_flag = True
self.pushButton.clicked.connect(self.onPushButtonClickedSlot)
self.pushButton_2.clicked.connect(self.onPushButton_2ClickedSlot)
self.pushButton_3.clicked.connect(self.onPushButton_3ClickedSlot)
self.pushButton_4.clicked.connect(self.onPushButton_4ClickedSlot)
self.pushButton_5.clicked.connect(self.onPushButton_5ClickedSlot)
self.write_encodemode = 'utf-8'
self.radioButton.toggled.connect(self.onRadioButtonToggledSlot)
self.radioButton_2.toggled.connect(self.onRadioButton_2ToggledSlot)
self.radioButton_3.toggled.connect(self.onRadioButton_3ToggledSlot)
self.radioButton_4.toggled.connect(self.onRadioButton_4ToggledSlot)
self.radioButton_5.toggled.connect(self.onRadioButton_5ToggledSlot)
self.radioButton_6.toggled.connect(self.onRadioButton_6ToggledSlot)
self.serial_write_thread = QtCore.QThread()
self.serial_write_threadObject = SerialWriteThreadObject(
self.serial_port)
self.serial_write_threadObject.moveToThread(self.serial_write_thread)
self.serial_write_threadObject.write_finished.connect(
self.serialWriteThreadFinishedSlot)
self.serial_readyWrite_signal.connect(
self.serial_write_threadObject.serialWriteSlot)
self.serial_write_thread.start()
self.serial_read_thread = QtCore.QThread()
self.serial_read_threadObject = SerialReadThreadObject(
self.serial_port)
self.serial_read_threadObject.moveToThread(self.serial_read_thread)
self.serial_port.readyRead.connect(self.serialReadyReadSlot)
self.serial_readyRead_signal.connect(
self.serial_read_threadObject.serialReadSlot)
self.serial_read_threadObject.read_finished.connect(
self.serialReadThreadFinishedSlot)
self.serial_read_thread.start()
self.receive_color = QtGui.QColor(220, 20, 60)
self.send_color = QtGui.QColor(153, 50, 204)
self.textBrowser_text_list = []
self.textBrowser_addTime_flag = False
self.textBrowser_hex_flag = False
self.write_newLine_flag = False
self.write_hex_flag = False
self.textEdit_textNum = 0
class SDKApplication(StoppableThread):
'''
SDKApplication class for main entrance for api.
Usage:
>>> app = SDKApplication(app_id, aes256_key, port)
>>> app.get_api_version()
...
>>> app.active_api()
...
>>> app.acquire_control()
...
>>> app.release_control()
...
>>> app.close()
The following are the parameters supplied to the constructor.
app_id -- your app id
aes256_key -- your enc key
port -- your serial port path
baudrate -- your serial port baudrate
'''
def __init__(self, **kwargs):
super(SDKApplication, self).__init__()
with open('logconfig.yaml', 'r') as f:
logging.config.dictConfig(yaml.load(f.read(), Loader=yaml.Loader))
self.applogger = logging.getLogger('app')
self.port_rx_stream_queue = Queue.Queue()
self.parsed_message_queue = Queue.Queue()
self.active_info = dict([(k, kwargs.get(k, v)) for (k, v) in [
('app_id', None),
('app_ver', 0x03010A00),
('bundle_id', '12345678901234567890123456789012'),
]])
if not self.active_info.get('app_id'):
raise TypeError(
'{}.__init__() must pass argument "app_id"!'.format(__class__))
encrypt_param = dict([(k, kwargs.get(k, v)) for (k, v) in [
('crc16_init', 0x3AA3),
('crc16_poly', 0x18005),
('crc32_init', 0x3AA3),
('crc32_poly', 0x104C11DB7),
('aes256_key', None),
]])
if not encrypt_param.get('aes256_key'):
raise TypeError(
'{}.__init__() must pass argument "aes256_key"!'.format(
__class__))
EncryptCodec.initEncryptCodec(encrypt_param)
port_param = dict([(k, kwargs.get(k, v)) for (k, v) in [
('port', '/dev/ttyUSB0'),
('baudrate', 230400),
('read_bytes', 12),
('buffer_queue', self.port_rx_stream_queue),
]])
self.port = SerialPort(**port_param)
self.parser = ProtocolParser(self.port_rx_stream_queue,
self.parsed_message_queue)
self.sm = SessionManager(self.port.write)
self.register_data_handle()
self.port.open()
self.parser.start()
def register_data_handle(self):
self.recv_data_handler_table = CMD_SET_R
def launch(self):
self.start()
def close(self):
self.sm.close_all_sessions()
self.port.close()
self.stop()
def run(self):
while (not self.stopped()):
try:
(header, data_buf) = self.parsed_message_queue.get(block=True,
timeout=3.0)
assert isinstance(header, ProtocolHeader) and isinstance(
data_buf, bytes)
if header.ack:
self.sm.feed_ack(header.session, header.seq, data_buf)
else:
d = ProtocolData()
cmd_set, cmd_id, content = d.parse(data_buf)
self.recv_data_handler_table[cmd_set][cmd_id](content)
# LOG('Data received.')
except Queue.Empty, e:
pass
def __init__(self, portname="/dev/ttyUSB0", speed=38400, verbose=False):
"""
Class constructor
@param portname: Name/path of the serial port
@param speed: Serial baudrate in bps
@param verbose: Print out SWAP traffic (True or False)
"""
# Serial mode (command or data modes)
self._sermode = SerialModem.Mode.DATA
# Response to the last AT command sent to the serial modem
self._atresponse = ""
# AT response received from modem
self.__atresponse_received = None
# "Packet received" callback function. To be defined by the parent object
self._ccpacket_received = None
## Name(path) of the serial port
self.portname = portname
## Speed of the serial port in bps
self.portspeed = speed
## Hardware version of the serial modem
self.hwversion = None
## Firmware version of the serial modem
self.fwversion = None
try:
# Open serial port
self._serport = SerialPort(self.portname, self.portspeed, verbose)
# Define callback function for incoming serial packets
self._serport.setRxCallback(self._serialPacketReceived)
# Run serial port thread
self._serport.start()
# This flags switches to True when the serial modem is ready
self._wait_modem_start = False
start = time.time()
soft_reset = False
while self._wait_modem_start == False:
elapsed = time.time() - start
if not soft_reset and elapsed > 5:
self.reset()
soft_reset = True
elif soft_reset and elapsed > 10:
raise SwapException("Unable to reset serial modem")
# Retrieve modem settings
# Switch to command mode
if not self.goToCommandMode():
raise SwapException("Modem is unable to enter command mode")
# Hardware version
response = self.runAtCommand("ATHV?\r")
if response is None:
raise SwapException("Unable to retrieve Hardware Version from serial modem")
self.hwversion = long(response, 16)
# Firmware version
response = self.runAtCommand("ATFV?\r")
if response is None:
raise SwapException("Unable to retrieve Firmware Version from serial modem")
self.fwversion = long(response, 16)
# Frequency channel
response = self.runAtCommand("ATCH?\r")
if response is None:
raise SwapException("Unable to retrieve Frequency Channel from serial modem")
## Frequency channel of the serial gateway
self.freq_channel = int(response, 16)
# Synchronization word
response = self.runAtCommand("ATSW?\r")
if response is None:
raise SwapException("Unable to retrieve Synchronization Word from serial modem")
## Synchronization word of the serial gateway
self.syncword = int(response, 16)
# Device address
response = self.runAtCommand("ATDA?\r")
if response is None:
raise SwapException("Unable to retrieve Device Address from serial modem")
## Device address of the serial gateway
self.devaddress = int(response, 16)
# Switch to data mode
self.goToDataMode()
except:
raise
port.stop()
port.disconnect()
def printout():
end = time.time()
print(end - start,"s -------------------------")
print("chars received : ",count)
print("in waiting :",port.get_rxloadmax())
print("errors :",errorcount)
if port.isAlive():
t2 = Timer(1.0, printout)
t2.start()
port = SerialPort()
port.start()
port.connect("COM5",115200)
synced = False
count = 0
errorcount = 0
index = 0
sequence = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
t = Timer(10.0, stop)
t.start()
start = time.time()
t2 = Timer(1.0, printout)
t2.start()
from flask import Flask, jsonify
from flask_socketio import SocketIO
from flask_cors import CORS
from RPi import GPIO
from helpers.Database import Database
from SerialPort import SerialPort
import threading
serialPort = SerialPort()
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
app = Flask(__name__)
CORS(app)
socketio = SocketIO(app)
hallsensor = 4
f = 0
r = 0
eindpoint = '/api/vi/'
conn = Database(app=app,
host='192.168.4.1',
port=3306,
user='******',
password='******',
from AT.NRB import NRB
from equipment.Led import Led
from equipment.Gpio import Gpio
from equipment.Pi import Pi
from equipment.Drive import Drive
import threading
serialPort = "/dev/ttyAMA0" # 串口
'''serialPort = "COM3" # 串口'''
baudRate = 9600 # 波特率
"""
所有模块初始化
"""
nnmi = NNMI()
qlwevtind = QLWEVTIND()
mSerial = SerialPort(serialPort, baudRate)
receiveMsg = ReceiveMsg(mSerial, nnmi, qlwevtind)
nmgs = NMGS(mSerial, receiveMsg)
csq = CSQ(mSerial, receiveMsg)
cfun = CFUN(mSerial, receiveMsg)
cgatt = CGATT(mSerial, receiveMsg)
qlwuldataex = QLWULDATAEX(mSerial, receiveMsg)
nconfig = NCONFIG(mSerial, receiveMsg)
nrb = NRB(mSerial, receiveMsg)
gpio_equipment = Gpio()
led_equipment = Led(gpio_equipment, nmgs)
pi_equipment = Pi(mSerial, receiveMsg, nmgs, csq, cfun, cgatt, qlwuldataex,
nconfig, nrb, gpio_equipment)
drive = Drive(nnmi, receiveMsg, led_equipment, pi_equipment)
import threading
import time
from tkinter import *
from tkinter import font
from SystemUsageDisplay import init_system_usage_gui
from TakeActions import init_take_actions_gui
from VolumeDisplay import init_volume_display_gui
from Buttons_Description import init_describe_button_gui
from Resolver import Resolver
from SerialPort import SerialPort
ser = SerialPort(sys.argv[1], Resolver(), timeout=0)
ser.start()
window = Tk()
window.title("Host")
frames = []
for row in range(6):
frame = Frame(window)
frame.grid(column=0, row=row, padx=20, pady=20)
frame.update()
frames.append(frame)
def get_scale(volume: str):
ser.write(b'zad1')
print(volume)
ser.write(volume.encode())
from SerialPort import SerialPort
com = SerialPort('COM6', timeout=1)
com.waitMsg()
com.sendMsg('01 02 00 01 FF')
com.waitMsg()
com.sendMsg('01 02 00 01 FF')
com.waitMsg()
com.sendMsg('22 22 07 30 30 32 34 30 34 31 39 66 66 63 64 00 45 37 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF')
while True:
com.waitMsg()
