精华内容
下载资源
问答
  • python 串口工具制作(2)

    万次阅读 2020-04-03 20:18:39
    基于上一篇python TK之串口工具制作(1)的博文,我在这里做一些功能的完善,添加文本框数据编写发送功能。 首先我们在TK界面制作页面(按键初始化)增加文本框以及数据发送按钮: #按钮初始化 def Button_Init(): ...

    基于上一篇python TK之串口工具制作(1)的博文,我在这里做一些功能的完善,添加文本框数据编写发送功能。
    首先我们在TK界面制作页面(按键初始化)增加文本框以及数据发送按钮:

    #按钮初始化
    def Button_Init():
     global root
     global com_list_tk
     global Test_Log
     global Entry_SN
    
     #串口读取写入
     Button(text='扫描串口', command=Scan_Com, width=24, height=3,font=('宋体', 11)).grid(row=0, column=0)
     Button(text='选择串口', command=Select_Com, width=24, height=3,font=('宋体', 11)).grid(row=1, column=0)
     #Button(text='选择串口', command=send_Com, width=24, height=3, font=('宋体', 11)).grid(row=0, column=1)
     Button(text='删除文本框', command=Delete_Text, width=24, height=3, font=('宋体', 11)).grid(row=0, column=1)
     Button(text='关闭串口', command=close_serial, width=24, height=3, font=('宋体', 11)).grid(row=1, column=1)
    
     Button(text='发送', command=send_data, width=10, height=2, font=('宋体', 11)).grid(row=3, column=2)
     Entry_SN = Entry(root)
     Entry_SN.grid(row=3, column=0, ipadx=131, ipady=10,columnspan=2)
    
     com_list_tk = Listbox(root)
     com_list_tk.grid(row=2, column=0, ipadx=28, ipady=60)
     Test_Log = scrolledtext.ScrolledText(root, width=23, height=20, font=('宋体', 11), bg='Linen')
     Test_Log.grid(row=2, column=1)
    

    再增加数据发送函数

    #发送数据
    def send_data():
        global ser
        global root
        global cmd
        global Test_Log
        global Test_Log_flag
    
        send_entry = Entry_SN.get()
        ser.write(binascii.a2b_hex(str(send_entry)))
        Test_Log.tag_config('s', background='springgreen')
        Test_Log.insert("end", datetime.datetime.now().strftime('%H:%M:%S ') +'send_data:' +send_entry + "\r\n", "s")
        Entry_SN.delete(0, END)
    

    这样,完整的串口数据收发工具制作就完成了,下面是完整的代码以及功能演示:

    # -*- coding:utf-8 -*-
    import serial
    import serial.tools.list_ports
    from tkinter import *
    import threading
    import binascii
    from tkinter import scrolledtext
    import time
    import datetime
    
    #扫描串口
    def Scan_Com():
     global root
     global com_list_tk
     global Test_Log
    
     com_list_tk.delete(0, END)
     port_list = list(serial.tools.list_ports.comports())
     if len(port_list) == 0:
         Test_Log.tag_config('t', background='tomato')
         Test_Log.insert("end", "请插入串口!!!\r\n", "t")
         Test_Log.see(END)
     for i in range(0,len(port_list)):
         com_list_tk.insert(END, port_list[i])
    
    #选择串口
    def Select_Com():
     global com_list_tk
     global ser
     global Test_Log
    
     try:
         com = com_list_tk.get(com_list_tk.curselection())
     except:
         Test_Log.tag_config('t', background='tomato')
         Test_Log.insert("end", "请先扫描串口!!!\r\n", "t")
         Test_Log.see(END)
         return
     if com.find('-') != -1:
         com = com[:com.find('-')]
    
     try:
         ser = serial.Serial(com,115200)
         serial_recv_threading = threading.Thread(target=Serial_Recv,daemon=True)
         serial_recv_threading.start()
         #Heartbeat()
         #Test_Log.delete(0.0,END)
         Test_Log.tag_config('s', background='springgreen')
         Test_Log.insert("end", com + "连接成功!\r\n", "s")
         Test_Log.see(END)
     except:
         Test_Log.delete(0.0,END)
         Test_Log.tag_config('t', background='tomato')
         Test_Log.insert("end", com+"连接失败!!!\r\n", "t")
         Test_Log.see(END)
    
    #关闭串口
    def Select_Com_close():
     global ser
     global Test_Log
    
     ser.close()
     Test_Log.tag_config('t', background='tomato')
     Test_Log.insert("end", "串口已关闭!\r\n", "t")
     Test_Log.see(END)
    
    #按钮初始化
    def Button_Init():
     global root
     global com_list_tk
     global Test_Log
     global Entry_SN
    
     #串口读取写入
     Button(text='扫描串口', command=Scan_Com, width=24, height=3,font=('宋体', 11)).grid(row=0, column=0)
     Button(text='选择串口', command=Select_Com, width=24, height=3,font=('宋体', 11)).grid(row=1, column=0)
     #Button(text='选择串口', command=send_Com, width=24, height=3, font=('宋体', 11)).grid(row=0, column=1)
     Button(text='删除文本框', command=Delete_Text, width=24, height=3, font=('宋体', 11)).grid(row=0, column=1)
     Button(text='关闭串口', command=close_serial, width=24, height=3, font=('宋体', 11)).grid(row=1, column=1)
    
     Button(text='发送', command=send_data, width=10, height=2, font=('宋体', 11)).grid(row=3, column=2)
     Entry_SN = Entry(root)
     Entry_SN.grid(row=3, column=0, ipadx=131, ipady=10,columnspan=2)
    
     com_list_tk = Listbox(root)
     com_list_tk.grid(row=2, column=0, ipadx=28, ipady=60)
     Test_Log = scrolledtext.ScrolledText(root, width=23, height=20, font=('宋体', 11), bg='Linen')
     Test_Log.grid(row=2, column=1)
    
    #发送数据
    def send_data():
        global ser
        global root
        global cmd
        global Test_Log
        global Test_Log_flag
    
        send_entry = Entry_SN.get()
        ser.write(str(send_entry).encode("gbk"))
        Test_Log.tag_config('s', background='springgreen')
        Test_Log.insert("end", datetime.datetime.now().strftime('%H:%M:%S ') +'send_data:' +send_entry + "\r\n", "s")
        Entry_SN.delete(0, END)
    
    #刪除文本框
    def Delete_Text():
     global Test_Log
    
     Test_Log.delete(0.0,END)
     Test_Log.tag_config('n', background='green')
     Test_Log.insert('end','文本框清除成功'+'\r\n','n')
     Test_Log.see(END)
    
    #关闭串口
    def close_serial():
     global ser
    
     ser.close()
     Test_Log.tag_config('n', background='red')
     Test_Log.insert("end", "串口已关闭!\r\n", "n")
     Test_Log.see(END)
    
    def Serial_Recv():
     global ser
     global root
     global cmd
     global Test_Log
     global recv_data
     global Test_Log_flag
    
     try:
         while True:
             time.sleep(0.05)
             data_len = ser.inWaiting()
             if data_len == 0:
                 continue
             print(data_len)
             recv_data = str(binascii.b2a_hex(ser.read(data_len)))[2:-1]
             print(datetime.datetime.now().strftime('%H:%M:%S'),'要处理的数据', recv_data)
             Test_Log.tag_config('s', background='springgreen')
             Test_Log.insert("end", datetime.datetime.now().strftime('%H:%M:%S ') + 'rec_data:'+recv_data +"\r\n", "s")
     except:
         ser.close()
         Test_Log.tag_config('t', background='tomato')
         Test_Log.insert("end", datetime.datetime.now().strftime('%H:%M:%S ') + "串口已关闭,请重新选择串口! \r\n", "t")
         Test_Log.see(END)
    
    def main():
     global root
    
     root = Tk()
     root.title('串口工具 V1.01')
     root.geometry('500x500')
     Button_Init()
     root.mainloop()
    
    if __name__ == '__main__':
     main()
    

    功能演示:
    在这里插入图片描述
    *關注我,之後會有更多的實用小工具,完整代碼送給你哦

    展开全文
  • Python3+PyQT5+Pyserial 实现简单的串口工具

    万次阅读 多人点赞 2018-04-19 11:04:00
    先实现一个简单的串口工具,为之后的上位机做准备 代码如下: github 下载地址 pyserial_demo.py import sys import serial import serial.tools.list_ports from PyQt5 import QtWidgets from PyQt5...

    练手项目,先上图
    这里写图片描述
    先实现一个简单的串口工具,为之后的上位机做准备
    代码如下:

    代码 github 地址: https://github.com/ColinFred/Pyserial-Demo

    pyserial_demo.py

    import sys
    import serial
    import serial.tools.list_ports
    from PyQt5 import QtWidgets
    from PyQt5.QtWidgets import QMessageBox
    from PyQt5.QtCore import QTimer
    from ui_demo_1 import Ui_Form
    
    
    class Pyqt5_Serial(QtWidgets.QWidget, Ui_Form):
        def __init__(self):
            super(Pyqt5_Serial, self).__init__()
            self.setupUi(self)
            self.init()
            self.setWindowTitle("串口小助手")
            self.ser = serial.Serial()
            self.port_check()
    
            # 接收数据和发送数据数目置零
            self.data_num_received = 0
            self.lineEdit.setText(str(self.data_num_received))
            self.data_num_sended = 0
            self.lineEdit_2.setText(str(self.data_num_sended))
    
        def init(self):
            # 串口检测按钮
            self.s1__box_1.clicked.connect(self.port_check)
    
            # 串口信息显示
            self.s1__box_2.currentTextChanged.connect(self.port_imf)
    
            # 打开串口按钮
            self.open_button.clicked.connect(self.port_open)
    
            # 关闭串口按钮
            self.close_button.clicked.connect(self.port_close)
    
            # 发送数据按钮
            self.s3__send_button.clicked.connect(self.data_send)
    
            # 定时发送数据
            self.timer_send = QTimer()
            self.timer_send.timeout.connect(self.data_send)
            self.timer_send_cb.stateChanged.connect(self.data_send_timer)
    
            # 定时器接收数据
            self.timer = QTimer(self)
            self.timer.timeout.connect(self.data_receive)
    
            # 清除发送窗口
            self.s3__clear_button.clicked.connect(self.send_data_clear)
    
            # 清除接收窗口
            self.s2__clear_button.clicked.connect(self.receive_data_clear)
    
        # 串口检测
        def port_check(self):
            # 检测所有存在的串口,将信息存储在字典中
            self.Com_Dict = {}
            port_list = list(serial.tools.list_ports.comports())
            self.s1__box_2.clear()
            for port in port_list:
                self.Com_Dict["%s" % port[0]] = "%s" % port[1]
                self.s1__box_2.addItem(port[0])
            if len(self.Com_Dict) == 0:
                self.state_label.setText(" 无串口")
    
        # 串口信息
        def port_imf(self):
            # 显示选定的串口的详细信息
            imf_s = self.s1__box_2.currentText()
            if imf_s != "":
                self.state_label.setText(self.Com_Dict[self.s1__box_2.currentText()])
    
        # 打开串口
        def port_open(self):
            self.ser.port = self.s1__box_2.currentText()
            self.ser.baudrate = int(self.s1__box_3.currentText())
            self.ser.bytesize = int(self.s1__box_4.currentText())
            self.ser.stopbits = int(self.s1__box_6.currentText())
            self.ser.parity = self.s1__box_5.currentText()
    
            try:
                self.ser.open()
            except:
                QMessageBox.critical(self, "Port Error", "此串口不能被打开!")
                return None
    
            # 打开串口接收定时器,周期为2ms
            self.timer.start(2)
    
            if self.ser.isOpen():
                self.open_button.setEnabled(False)
                self.close_button.setEnabled(True)
                self.formGroupBox1.setTitle("串口状态(已开启)")
    
        # 关闭串口
        def port_close(self):
            self.timer.stop()
            self.timer_send.stop()
            try:
                self.ser.close()
            except:
                pass
            self.open_button.setEnabled(True)
            self.close_button.setEnabled(False)
            self.lineEdit_3.setEnabled(True)
            # 接收数据和发送数据数目置零
            self.data_num_received = 0
            self.lineEdit.setText(str(self.data_num_received))
            self.data_num_sended = 0
            self.lineEdit_2.setText(str(self.data_num_sended))
            self.formGroupBox1.setTitle("串口状态(已关闭)")
    
        # 发送数据
        def data_send(self):
            if self.ser.isOpen():
                input_s = self.s3__send_text.toPlainText()
                if input_s != "":
                    # 非空字符串
                    if self.hex_send.isChecked():
                        # hex发送
                        input_s = input_s.strip()
                        send_list = []
                        while input_s != '':
                            try:
                                num = int(input_s[0:2], 16)
                            except ValueError:
                                QMessageBox.critical(self, 'wrong data', '请输入十六进制数据,以空格分开!')
                                return None
                            input_s = input_s[2:].strip()
                            send_list.append(num)
                        input_s = bytes(send_list)
                    else:
                        # ascii发送
                        input_s = (input_s + '\r\n').encode('utf-8')
    
                    num = self.ser.write(input_s)
                    self.data_num_sended += num
                    self.lineEdit_2.setText(str(self.data_num_sended))
            else:
                pass
    
        # 接收数据
        def data_receive(self):
            try:
                num = self.ser.inWaiting()
            except:
                self.port_close()
                return None
            if num > 0:
                data = self.ser.read(num)
                num = len(data)
                # hex显示
                if self.hex_receive.checkState():
                    out_s = ''
                    for i in range(0, len(data)):
                        out_s = out_s + '{:02X}'.format(data[i]) + ' '
                    self.s2__receive_text.insertPlainText(out_s)
                else:
                    # 串口接收到的字符串为b'123',要转化成unicode字符串才能输出到窗口中去
                    self.s2__receive_text.insertPlainText(data.decode('utf-8'))
    
                # 统计接收字符的数量
                self.data_num_received += num
                self.lineEdit.setText(str(self.data_num_received))
    
                # 获取到text光标
                textCursor = self.s2__receive_text.textCursor()
                # 滚动到底部
                textCursor.movePosition(textCursor.End)
                # 设置光标到text中去
                self.s2__receive_text.setTextCursor(textCursor)
            else:
                pass
    
        # 定时发送数据
        def data_send_timer(self):
            if self.timer_send_cb.isChecked():
                self.timer_send.start(int(self.lineEdit_3.text()))
                self.lineEdit_3.setEnabled(False)
            else:
                self.timer_send.stop()
                self.lineEdit_3.setEnabled(True)
    
        # 清除显示
        def send_data_clear(self):
            self.s3__send_text.setText("")
    
        def receive_data_clear(self):
            self.s2__receive_text.setText("")
    
    
    if __name__ == '__main__':
        app = QtWidgets.QApplication(sys.argv)
        myshow = Pyqt5_Serial()
        myshow.show()
        sys.exit(app.exec_())
    
    

    ui_demo_1.py

    # -*- coding: utf-8 -*-
    
    # Form implementation generated from reading ui file 'demo_1.ui'
    #
    # Created by: PyQt5 UI code generator 5.6
    #
    # WARNING! All changes made in this file will be lost!
    
    from PyQt5 import QtCore, QtGui, QtWidgets
    
    class Ui_Form(object):
        def setupUi(self, Form):
            Form.setObjectName("Form")
            Form.resize(707, 458)
            self.formGroupBox = QtWidgets.QGroupBox(Form)
            self.formGroupBox.setGeometry(QtCore.QRect(20, 20, 167, 301))
            self.formGroupBox.setObjectName("formGroupBox")
            self.formLayout = QtWidgets.QFormLayout(self.formGroupBox)
            self.formLayout.setContentsMargins(10, 10, 10, 10)
            self.formLayout.setSpacing(10)
            self.formLayout.setObjectName("formLayout")
            self.s1__lb_1 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_1.setObjectName("s1__lb_1")
            self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.s1__lb_1)
            self.s1__box_1 = QtWidgets.QPushButton(self.formGroupBox)
            self.s1__box_1.setAutoRepeatInterval(100)
            self.s1__box_1.setDefault(True)
            self.s1__box_1.setObjectName("s1__box_1")
            self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.s1__box_1)
            self.s1__lb_2 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_2.setObjectName("s1__lb_2")
            self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.s1__lb_2)
            self.s1__box_2 = QtWidgets.QComboBox(self.formGroupBox)
            self.s1__box_2.setObjectName("s1__box_2")
            self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.s1__box_2)
            self.s1__lb_3 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_3.setObjectName("s1__lb_3")
            self.formLayout.setWidget(3, QtWidgets.QFormLayout.LabelRole, self.s1__lb_3)
            self.s1__box_3 = QtWidgets.QComboBox(self.formGroupBox)
            self.s1__box_3.setObjectName("s1__box_3")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.s1__box_3.addItem("")
            self.formLayout.setWidget(3, QtWidgets.QFormLayout.FieldRole, self.s1__box_3)
            self.s1__lb_4 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_4.setObjectName("s1__lb_4")
            self.formLayout.setWidget(4, QtWidgets.QFormLayout.LabelRole, self.s1__lb_4)
            self.s1__box_4 = QtWidgets.QComboBox(self.formGroupBox)
            self.s1__box_4.setObjectName("s1__box_4")
            self.s1__box_4.addItem("")
            self.s1__box_4.addItem("")
            self.s1__box_4.addItem("")
            self.s1__box_4.addItem("")
            self.formLayout.setWidget(4, QtWidgets.QFormLayout.FieldRole, self.s1__box_4)
            self.s1__lb_5 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_5.setObjectName("s1__lb_5")
            self.formLayout.setWidget(5, QtWidgets.QFormLayout.LabelRole, self.s1__lb_5)
            self.s1__box_5 = QtWidgets.QComboBox(self.formGroupBox)
            self.s1__box_5.setObjectName("s1__box_5")
            self.s1__box_5.addItem("")
            self.formLayout.setWidget(5, QtWidgets.QFormLayout.FieldRole, self.s1__box_5)
            self.open_button = QtWidgets.QPushButton(self.formGroupBox)
            self.open_button.setObjectName("open_button")
            self.formLayout.setWidget(7, QtWidgets.QFormLayout.SpanningRole, self.open_button)
            self.close_button = QtWidgets.QPushButton(self.formGroupBox)
            self.close_button.setObjectName("close_button")
            self.formLayout.setWidget(8, QtWidgets.QFormLayout.SpanningRole, self.close_button)
            self.s1__lb_6 = QtWidgets.QLabel(self.formGroupBox)
            self.s1__lb_6.setObjectName("s1__lb_6")
            self.formLayout.setWidget(6, QtWidgets.QFormLayout.LabelRole, self.s1__lb_6)
            self.s1__box_6 = QtWidgets.QComboBox(self.formGroupBox)
            self.s1__box_6.setObjectName("s1__box_6")
            self.s1__box_6.addItem("")
            self.formLayout.setWidget(6, QtWidgets.QFormLayout.FieldRole, self.s1__box_6)
            self.state_label = QtWidgets.QLabel(self.formGroupBox)
            self.state_label.setText("")
            self.state_label.setTextFormat(QtCore.Qt.AutoText)
            self.state_label.setScaledContents(True)
            self.state_label.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
            self.state_label.setObjectName("state_label")
            self.formLayout.setWidget(2, QtWidgets.QFormLayout.SpanningRole, self.state_label)
            self.verticalGroupBox = QtWidgets.QGroupBox(Form)
            self.verticalGroupBox.setGeometry(QtCore.QRect(210, 20, 401, 241))
            self.verticalGroupBox.setObjectName("verticalGroupBox")
            self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalGroupBox)
            self.verticalLayout.setContentsMargins(10, 10, 10, 10)
            self.verticalLayout.setObjectName("verticalLayout")
            self.s2__receive_text = QtWidgets.QTextBrowser(self.verticalGroupBox)
            self.s2__receive_text.setObjectName("s2__receive_text")
            self.verticalLayout.addWidget(self.s2__receive_text)
            self.verticalGroupBox_2 = QtWidgets.QGroupBox(Form)
            self.verticalGroupBox_2.setGeometry(QtCore.QRect(210, 280, 401, 101))
            self.verticalGroupBox_2.setObjectName("verticalGroupBox_2")
            self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.verticalGroupBox_2)
            self.verticalLayout_2.setContentsMargins(10, 10, 10, 10)
            self.verticalLayout_2.setObjectName("verticalLayout_2")
            self.s3__send_text = QtWidgets.QTextEdit(self.verticalGroupBox_2)
            self.s3__send_text.setObjectName("s3__send_text")
            self.verticalLayout_2.addWidget(self.s3__send_text)
            self.s3__send_button = QtWidgets.QPushButton(Form)
            self.s3__send_button.setGeometry(QtCore.QRect(620, 310, 61, 31))
            self.s3__send_button.setObjectName("s3__send_button")
            self.s3__clear_button = QtWidgets.QPushButton(Form)
            self.s3__clear_button.setGeometry(QtCore.QRect(620, 350, 61, 31))
            self.s3__clear_button.setObjectName("s3__clear_button")
            self.formGroupBox1 = QtWidgets.QGroupBox(Form)
            self.formGroupBox1.setGeometry(QtCore.QRect(20, 340, 171, 101))
            self.formGroupBox1.setObjectName("formGroupBox1")
            self.formLayout_2 = QtWidgets.QFormLayout(self.formGroupBox1)
            self.formLayout_2.setContentsMargins(10, 10, 10, 10)
            self.formLayout_2.setSpacing(10)
            self.formLayout_2.setObjectName("formLayout_2")
            self.label = QtWidgets.QLabel(self.formGroupBox1)
            self.label.setObjectName("label")
            self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label)
            self.label_2 = QtWidgets.QLabel(self.formGroupBox1)
            self.label_2.setObjectName("label_2")
            self.formLayout_2.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label_2)
            self.lineEdit = QtWidgets.QLineEdit(self.formGroupBox1)
            self.lineEdit.setObjectName("lineEdit")
            self.formLayout_2.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.lineEdit)
            self.lineEdit_2 = QtWidgets.QLineEdit(self.formGroupBox1)
            self.lineEdit_2.setObjectName("lineEdit_2")
            self.formLayout_2.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.lineEdit_2)
            self.hex_send = QtWidgets.QCheckBox(Form)
            self.hex_send.setGeometry(QtCore.QRect(620, 280, 71, 16))
            self.hex_send.setObjectName("hex_send")
            self.hex_receive = QtWidgets.QCheckBox(Form)
            self.hex_receive.setGeometry(QtCore.QRect(620, 40, 71, 16))
            self.hex_receive.setObjectName("hex_receive")
            self.s2__clear_button = QtWidgets.QPushButton(Form)
            self.s2__clear_button.setGeometry(QtCore.QRect(620, 80, 61, 31))
            self.s2__clear_button.setObjectName("s2__clear_button")
            self.timer_send_cb = QtWidgets.QCheckBox(Form)
            self.timer_send_cb.setGeometry(QtCore.QRect(260, 390, 71, 16))
            self.timer_send_cb.setObjectName("timer_send_cb")
            self.lineEdit_3 = QtWidgets.QLineEdit(Form)
            self.lineEdit_3.setGeometry(QtCore.QRect(350, 390, 61, 20))
            self.lineEdit_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
            self.lineEdit_3.setObjectName("lineEdit_3")
            self.dw = QtWidgets.QLabel(Form)
            self.dw.setGeometry(QtCore.QRect(420, 390, 54, 20))
            self.dw.setObjectName("dw")
            self.verticalGroupBox.raise_()
            self.verticalGroupBox_2.raise_()
            self.formGroupBox.raise_()
            self.s3__send_button.raise_()
            self.s3__clear_button.raise_()
            self.formGroupBox.raise_()
            self.hex_send.raise_()
            self.hex_receive.raise_()
            self.s2__clear_button.raise_()
            self.timer_send_cb.raise_()
            self.lineEdit_3.raise_()
            self.dw.raise_()
    
            self.retranslateUi(Form)
            QtCore.QMetaObject.connectSlotsByName(Form)
    
        def retranslateUi(self, Form):
            _translate = QtCore.QCoreApplication.translate
            Form.setWindowTitle(_translate("Form", "Form"))
            self.formGroupBox.setTitle(_translate("Form", "串口设置"))
            self.s1__lb_1.setText(_translate("Form", "串口检测:"))
            self.s1__box_1.setText(_translate("Form", "检测串口"))
            self.s1__lb_2.setText(_translate("Form", "串口选择:"))
            self.s1__lb_3.setText(_translate("Form", "波特率:"))
            self.s1__box_3.setItemText(0, _translate("Form", "115200"))
            self.s1__box_3.setItemText(1, _translate("Form", "2400"))
            self.s1__box_3.setItemText(2, _translate("Form", "4800"))
            self.s1__box_3.setItemText(3, _translate("Form", "9600"))
            self.s1__box_3.setItemText(4, _translate("Form", "14400"))
            self.s1__box_3.setItemText(5, _translate("Form", "19200"))
            self.s1__box_3.setItemText(6, _translate("Form", "38400"))
            self.s1__box_3.setItemText(7, _translate("Form", "57600"))
            self.s1__box_3.setItemText(8, _translate("Form", "76800"))
            self.s1__box_3.setItemText(9, _translate("Form", "12800"))
            self.s1__box_3.setItemText(10, _translate("Form", "230400"))
            self.s1__box_3.setItemText(11, _translate("Form", "460800"))
            self.s1__lb_4.setText(_translate("Form", "数据位:"))
            self.s1__box_4.setItemText(0, _translate("Form", "8"))
            self.s1__box_4.setItemText(1, _translate("Form", "7"))
            self.s1__box_4.setItemText(2, _translate("Form", "6"))
            self.s1__box_4.setItemText(3, _translate("Form", "5"))
            self.s1__lb_5.setText(_translate("Form", "校验位:"))
            self.s1__box_5.setItemText(0, _translate("Form", "N"))
            self.open_button.setText(_translate("Form", "打开串口"))
            self.close_button.setText(_translate("Form", "关闭串口"))
            self.s1__lb_6.setText(_translate("Form", "停止位:"))
            self.s1__box_6.setItemText(0, _translate("Form", "1"))
            self.verticalGroupBox.setTitle(_translate("Form", "接受区"))
            self.verticalGroupBox_2.setTitle(_translate("Form", "发送区"))
            self.s3__send_text.setHtml(_translate("Form", "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"
    "<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"
    "p, li { white-space: pre-wrap; }\n"
    "</style></head><body style=\" font-family:\'SimSun\'; font-size:9pt; font-weight:400; font-style:normal;\">\n"
    "<p style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\">123456</p></body></html>"))
            self.s3__send_button.setText(_translate("Form", "发送"))
            self.s3__clear_button.setText(_translate("Form", "清除"))
            self.formGroupBox1.setTitle(_translate("Form", "串口状态"))
            self.label.setText(_translate("Form", "已接收:"))
            self.label_2.setText(_translate("Form", "已发送:"))
            self.hex_send.setText(_translate("Form", "Hex发送"))
            self.hex_receive.setText(_translate("Form", "Hex接收"))
            self.s2__clear_button.setText(_translate("Form", "清除"))
            self.timer_send_cb.setText(_translate("Form", "定时发送"))
            self.lineEdit_3.setText(_translate("Form", "1000"))
            self.dw.setText(_translate("Form", "ms/次"))
    
    
    展开全文
  • Android串口工具

    千次阅读 2019-12-12 17:47:07
    最近开发了一款Android串口小工具,具有Loopback和Send/Receive两种模式,比较简单,可以用于串口测试,也可以当标准的串口工具使用,使用起来特别方便,所以推荐给大家 apk下载地址:...

    最近开发了一款Android串口小工具,具有Loopback和Send/Receive两种模式,比较简单,可以用于串口测试,也可以当标准的串口工具使用,使用起来特别方便,所以推荐给大家

    apk下载地址:https://download.csdn.net/download/u012851408/12028915

    程序主要界面如下

    展开全文
  • python串口工具,串口上位机

    千次阅读 2019-12-19 18:40:57
    python 使用pyserial串口库开发串口工具 之前发过用tkinter库设计的串口工具UI代码,以下为python串口的逻辑代码,已整理成模块,可以随时保存下来使用。部分函数采用中文命名,只是测试中文函数是否可运行,事实...

    python 使用pyserial串口库开发串口工具

    之前发过用tkinter库设计的串口工具UI代码,以下为python串口的逻辑代码,已整理成模块,可以随时保存下来使用。部分函数采用中文命名,只是测试中文函数是否可运行,事实证明可以正常运行。也可另外修改函数名称

    1. 示例代码(MyPySerial.py)
    # !/usr/bin/python 3.6.5
    # coding=utf-8
    
    import serial
    import serial.tools.list_ports
    import threading
    
    '''
        1、扫描串口列表
        2、打开串口
        3、向串口写数据
        4、从串口读数据
        5、关闭串口
        
        init 初始化串口
            --> 创建线程:
                1. 如果串口未打开,则用于实时扫描串口,检测是否有新设备插入
                    有新设备插入:添加到设备列表,并刷新UI的设备列表提供选择
                    没有新设备:继续扫描
                2. 如果串口已打开,则用于监测串口是否有接收到数据
                    如果有则读取数据,并发送给UI
                    如果没有则继续扫描
            参数:主窗口,端口列表,接收窗口
            返回:线程实例(用于关闭窗口前,先关闭线程)
            
        open 打开串口
            --> 参数:端口号,波特率,超时时间
                返回:串口实例(打开成功)/ None(打开失败)
        
        close 关闭串口
            --> 参数:串口实例
                返回:0(关闭成功)/ -1(关闭失败)
                
        write 写数据
        read 读数据
            
    '''
    
    SERIAL_IS_OPEN = False      # 默认串口关闭
    port_name_list = []         # 端口名称列表
    port_com_list = []          # 端口号列表
    MySerial = None             # 打开的串口
    
    def 扫描串口():
        port_list = list(serial.tools.list_ports.comports())
        if len(port_list) > 0:
            return port_list
        else:
            return None
    
    def 打开串口(port="COM4", bps=115200, timex=5):
        try:
            # 打开串口
            ser = serial.Serial(port, bps, timeout=timex)
    
            if ser.is_open:
                global SERIAL_IS_OPEN
                SERIAL_IS_OPEN = True
                print("--- 串口打开 ---")
                return ser
    
        except Exception as e:
            print("--- 打开异常 ---: ", e)
            return None
    
    def 发送数据(ser, text, code="utf-8"):
        try:
            result = ser.write(text.encode(code))
            if result == len(text):
                print("--- 发送成功 ---:", text)
                return result
            else:
                print("--- 发送错误 ---:", "data len:", len(text), "send len:", result)
                return None
        except Exception as e:
            print("--- 发送异常 ---:", e)
    
    def 读取数据(ser, code="utf-8"):
        if ser.in_waiting:
            str = ser.read(ser.in_waiting).decode(code)
            print("--- 读到数据 ---:", str)
            return str
        else:
            return None
    
    
    def 关闭串口(ser):
        if ser.is_open:
            try:
                global SERIAL_IS_OPEN
                SERIAL_IS_OPEN = False
                ser.close()
                print("--- 串口关闭 ---")
                return 0
            except Exception as e:
                print("--- 关闭异常 ---:", e)
                return -1
        else:
            print("--- 错误 ---:串口未打开!")
            return -1
    
    class SERIAL:
        def __init__(self):
            self.ser = None
            self.get_str = ''
            self.master = None
            self.show_com = None
            self.read_text_win = None
            self.serialThread = None
    
        def serial_thread(self, master, list_port, text_read):
            global SERIAL_IS_OPEN, port_name_list, port_com_list
            global MySerial
            while True:
                if SERIAL_IS_OPEN:
                    self.get_str = 读取数据(MySerial)
                    if self.get_str:
                        # print(self.get_str)
                        text_read.insert(tk.END, self.get_str)
                        master.update()
                else:
                    port_list = 扫描串口()
                    if len(port_name_list) is not len(port_list):   # 只判断列表长度,不可靠。需修改为列表内容判断比较可靠
                        port_name_list.clear()
                        port_com_list.clear()
                        for i in range(0, len(port_list)):
                            port_name_list.append(port_list[i].description)
                            port_com_list.append(port_list[i].device)
                            list_port["values"] = port_name_list
                            if list_port.get() is "":  # 如果当前UI中的端口列表为空,则指定显示第一个
                                list_port.current(0)
                        master.update()
    
        @classmethod
        def init(cls, master, list_port, text_read):
            cls.master = master
            cls.show_com = list_port
            cls.read_text_win = text_read
            cls.serialThread = threading.Thread(target=cls.serial_thread,
                                                args=(SERIAL, cls.master, cls.show_com, cls.read_text_win))
            cls.serialThread.start()
            return cls.serialThread
    
        @classmethod
        def open(cls, port=None, bps=115200, timex=5):
            global port_name_list, port_com_list, MySerial
            if not port:
                port_name = cls.show_com.get()
                index = port_name_list.index(port_name)
                MySerial = 打开串口(port_com_list[index], bps, timex)
            else:
                MySerial = 打开串口(port, bps, timex)
    
        @staticmethod
        def write(text, coding="gbk"):
            global MySerial, SERIAL_IS_OPEN
            if SERIAL_IS_OPEN:
                发送数据(MySerial, text, coding)
    
        @staticmethod
        def read(coding="gbk"):
            global MySerial, SERIAL_IS_OPEN
            str = None
            if SERIAL_IS_OPEN:
                str = 读取数据(MySerial, coding)
            return str
    
        @staticmethod
        def close():
            global MySerial, SERIAL_IS_OPEN
            if SERIAL_IS_OPEN and MySerial:
                关闭串口(MySerial)
    
    
    if __name__ == "__main__":
        import tkinter as tk
        from tkinter import ttk
        root = tk.Tk()
        root.title("测试窗口")
        root.geometry("300x300")
    
        list_box = ttk.Combobox(root, width=22, textvariable=port_name_list, state="readonly")
        list_box.place(x=10, y=10)
    
        text_box = tk.Text(root, width=25, heigh=10)
        text_box.place(x=10, y=50)
    
        def open_serial():
            SERIAL.open()
    
        def send_date():
            SERIAL.write("hello python serial\n", coding="gbk")
    
        def close_serial():
            SERIAL.close()
    
        SERIAL.init(root, list_box, text_box)
    
        button0 = tk.Button(root, text="打开串口", command=open_serial)
        button0.place(x=10, y=200)
        button1 = tk.Button(root, text="发送数据", command=send_date)
        button1.place(x=70, y=200)
        button2 = tk.Button(root, text="关闭串口", command=close_serial)
        button2.place(x=130, y=200)
    
        root.mainloop()
        
    
    2. 测试UI窗口

    测试窗口使用方法:

    1. 直接将示例代码拷贝下来保存为:MyPySerial.py 文件
    2. 运行文件即可打开测试窗口
    3. 选择CH340端口,打开串口
    4. “发送数据”,会向串口发送"hello python serial\n"
    5. 将CH340串口的“tx”和“rx”短接,即可将发送出去的数据接收回显到Text控件
    6. 关闭串口
      注意:本实例在init中会返回线程,需要自行关闭,python主线程关闭,子线程不会自动关闭

    在这里插入图片描述

    展开全文
  • Mac安装串口工具

    千次阅读 2019-01-17 14:47:57
    此文是记录在Mac上安装调试串口工具的步骤,这么简单的步骤,自己也看好多文章才弄好。 一、安装驱动 这个设备使用的是PL2303芯片的usb转串口线,刚好网上有一篇文章也是。但是由于自己学术短浅,遇到了一些简单...
  • 2.打开串口工具并保存为文件名为zkw的log :sudo minicom -C zkw.log 也可以使用 [sudo minicom] 命令直接打开串口工具 3.进入minicom界面了,可以监听串口信息了 4.怎么使用串口工具:CTRL+A Z 进入命令菜...
  • 串口工具 流水的打印工具,屏幕会跟踪到当前行 显示终端 相当于显示屏,显示内容尽量会显示在单个屏幕上。会不断刷新单个屏幕上内容
  • PC插上串口工具后PC端口com那里有个黄色叹号,无法使用串口工具! 原文链接:http://blog.csdn.net/csdnhuaong/article/details/68945601 解决WIN10系统下PL2303_USB转串口驱动兼容性问题。问题的真正原因,就是...
  • 日常生活小技巧 -- 虚拟串口工具

    万次阅读 多人点赞 2017-12-06 18:08:17
    串口部分基本讲完,最后再提供一个虚拟串口工具。一、虚拟串口 vspdconfig下载:虚拟串口工具二、使用添加端口 COM1-COM2打开串口调试工具测试
  • ubuntu下串口工具的安装与使用

    万次阅读 2018-05-14 00:45:40
     作为一个嵌入式开发人员,串口是开发过程中不可或缺的工具之一,window下有各种各样的串口工具,使用起来很方便,这里不再做过多陈述,这里主要介绍Ubuntu 16.04 系统下的串口工具-minicom 2. 安装  ubuntu安装...
  • 可以把TCP通讯的设备转换成本机上的虚拟串口 改IP:Tool - IPsearch - Refresh - 搜索到IP后 在下面的方框里更改 然后点Alter 转串口:在COM选择处选你要虚拟成的串口,点Create - 弹出来的地方 把IP ADD改为你刚改的...
  • 串口工具secureCRT 日志保存时间戳

    千次阅读 2019-09-17 16:37:03
    secureCRT串口工具现在是嵌入式软件工程师用得比较频繁的一款工具软件,我们在使用secureCRT过程中,难免会根据log信息来分析相应的问题,定位代码的走向。 日志保存则是一项较重要的操作,日志中存在时间戳也是...
  • SecureCRT串口工具常用设置

    千次阅读 2016-12-02 14:34:12
    SecureCRT串口工具常用设置
  • secureCRT 当作串口工具 使用

    千次阅读 2020-01-03 18:20:36
    secureCRT 简称crt,终端仿真工具很强大,支持 SSH1和SSH2,串口,Telnet等,我这里只用作 串口打印log,可以自动保存log ,随时暂停log恢复 网上有很多破解版 ...然后配置成串口工具 选择Options->Globa...
  • linux串口工具miniterm的使用 将(usb转)串口插入主机,/dev目录下会显示新设备,如下图所示为ttyUSB0 执行miniterm.py /dev/ttyUSB0 74880,指定对应串口并设置波特率 如上图所示,提示打开串口失败。 原因是对于该...
  • 做嵌入式硬件同事应该都遇到过查看设备串口打印信息,有时打印的内容太多,总是找不到自己关注的log,因此花了一下午设计了这个简单的具备二次过滤功能的串口工具SerialTools,因我本身不是做软件开发的,只为实用...
  • cutecom是linux下图形界面形式的串口工具(非界面串口工具有minicom),简要说明下cutecom的安装和使用。
  • 在上面的链接中下载了命令行串口工具TELCOM。 目前我们通过TELCOM实现了接收串口数据和发送串口数据, 但是不知道该怎么用TELCOM保存输出文件。 求问有什么方法能让收到的数据保存到电脑里啊。
  • microcom用法(嵌入式平台串口工具

    千次阅读 2017-08-02 15:50:52
    microcom 嵌入式平台串口工具
  • Mac使用minicom串口工具

    千次阅读 2017-11-23 14:19:22
    我们可以畅快的在Mac下使用串口工具了,今天介绍一个简单实用的minicom 1.安装minicom(注意:Mac下没有1500000这个波特率,Ubuntu下的minicom有)  # brew install minicom //我的是tty.SLAB_USBtoUART   # ...
  • 虚拟串口工具及串口调试工具

    热门讨论 2010-10-27 09:19:29
    该资源包括两个压缩包。一个用于虚拟串口,另一个用于接收自己编写的程序发送来的数据,同时能实现向程序回发数据。
  • macOS 上的几款串口工具

    千次阅读 2019-01-24 16:04:26
    macOS 上的几款串口工具友善串口调试助手优点SecureCRTCoolTerm 友善串口调试助手 优点 跨平台 使用方便,超级稳定,不死机,不丢包; 串口自动识别,支持COM9以上串口; 支持多串口调试; 支持历史发送记录; 广泛...
  • 串口工具SecureCRT不能输入命令

    万次阅读 2017-05-05 23:23:05
    发现串口工具SecureCRT不能输入命令安回车没有反应请问是什么问题啊? 目前发现无线AP 思科华三的AP 及 博科光纤交换机 均需要做此操作方能键入指令 解决方法: 右键连接标签-> 属性 -> 串口 -> ,将原先...
  • 串口工具Kermit

    千次阅读 2019-03-28 20:26:12
    set line /dev/ttyUSB0 (串口名,具体是哪个串口查看方法在下方) set speed 115200 (串口速率) set carrier-watch off set handshake none set flow-control none robust set file type bin set file name ...
  • USB-串口工具 TXD、RXD、GND与单片机的RXD、TXD、GND相连,由于USB-串口工的TXD会给单片机供电上(电流倒灌,这时一般需立即给单片机外部供电,防止USB-串口工具损坏),完成仿真芯片烧录。 3. Keil下可以仿真芯片了...
  • ubuntn下串口工具minicom ,kermit的使用

    千次阅读 2018-03-01 17:17:43
    串口是嵌入式开发使用最多的通信方式,linux系统提供了一个串口工具minicom,可以完成复杂的串口通信工作。 Ubuntu下也有这样的串口通信工具,比如Minicom,kermit。minicom比较通用,kermit比较好用。 1.minicom...
  • 目录 YModem协议传输的过程 ...YModem串口工具 YModem技术手册 手把手教你如何实现自动固件更新 YModem协议是由XModem协议演变而来的,每包数据可以达到1024字节,是一个非常高效的文件传输协议。
  • 使用串口调试助手可能会遇到的问题 & 使用虚拟串口工具可能会遇到的问题
  • android-serialport-api串口工具测试随笔

    千次阅读 2019-02-03 09:37:16
    android-serialport-api串口工具测试随笔

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,283
精华内容 26,113
关键字:

串口工具