精华内容
下载资源
问答
  • 串口通信,接收并解析数据的方式
    更多相关内容
  • 基于串口中断的示例工程,工程是基于Keil4的mk60单片机设计,直接打开中断文件复制函数使用即可,注释清晰
  • 后来又需要调试UART串口,将MCU传输的协议数据分参数在桌面打印出来,这样应该利于第一时间检查协议数据每一个参数是否满足要求。 这个现有在串口调试助手中尽管可以打印,可以过滤,但是并不能满足自定义的个性要求...
  • vc串口数据解析

    2018-01-22 16:05:26
    串口数据解析,vc读取串口数据,获取完整数据包并解析出其中数据 抱歉,上传时默认了下载所需积分,之后不能编辑,下载了的可以联系我返还部分积分
  • 此程序是基于对话框的MFC程序,能够做到串口实时通信,并且将数据展示到编辑框,而且并对获得的数据进行解析,主要处理的数据是GPGGA报文,安装环境请对照安装包提示,有问题可以发邮件交流学习,liaoby@jmev.com
  • 编写的GPS协议数据解析串口接收地方没有写,只是单纯的解析
  • TI IWR1642雷达串口数据解析C++代码。 本文毕设一部分,有C++基础的可以借鉴。只提供一个CPP文件
  • 使用pyserial进行串口传输 一、安装pyserial以及基本用法 在cmd下输入命令pip install pyserial 注:升级pip后会出现 “‘E:\Anaconda3\Scripts\pip-...ser.write(“hello”) 就是往串口里面写数据 ser.close() 就
  • 关于FPGA在解析带有数据包协议的数据存储问题。FPGA先根据数据包协议接收数据并存储到RAM,在接收到完整一包数据后,将数据从RAM转移到FIFO中,后端的数据处理或者数据转发可以直接从FIFO读取。本代码模拟数据写入...
  • Qt界面,主要功能有1:串口收发数据 2:Qt实时显示串口接收数据
  • 本程序功能是Arduino R3串口通讯时,解析接收到的数据
  • 解析串口通信数据

    2017-09-17 14:34:51
    MFC编程中,串口传输的原理,串口数据传输过程及电平转换,RS232的引脚定义,电气特性,传输格式,接收过程,配波形图
  • QT实时绘制串口数据

    2018-07-20 22:22:04
    采用多线程方法,主线程解析数据和绘图,子线程接收数据,QWT绘图,有历史回顾功能
  • 在双机通讯中,第九位一般是奇偶校验位。 可以发9位数据,8个数据为,第九位是校验位,校验位有4个状态可设置,基校验,偶校验,总为1,总为0。
  • 通过C#实现串口通信,里面的代码展示了如何监听计算机中的串口解析数据或者发送数据,做串口开发的可以参考
  • 使用Modbus协议,解析串口接收数据并显示,整个项目使用C#开发
  • 1、实时解析串口数据并绘制相关曲线 | 2、串口单独一个进程(不影响GUI刷新) | 3、曲线、串口参数可配置、可保存
  • 这是STM32串口解析GPS数据示例源码,采用串口1接收GPS的数据解析输出。 MCU型号: STM32F103ZET6 GPS型号: 中科微电子串口GPS模块,波特率默认为9600。 解析出的数据可以调用百度地图、高德地图API,或者传递给...
  • 最近工作需要把单片机读取的传感器电压数据实时在PC上通过曲线显示出来,刚好在看python, 就试着用了python 与uart端口通讯,并且通过matplotlib.pyplot 模块实时绘制图形出来。 1. 废话少说,上图 因为没有UI,...
  • 功能:解析串口数据(此程序中以回车符作为解析对象,如需要解析其他字符可以自行参考修改),并将...测试结果:整个过程数据解析正确,数据传输稳定,无丢包。满足任意串口通信速度下的串口数据的解析与Wi-Fi透传。
  • JAVA串口助手接收串口来的数据,并将数据解析存储入MySQL数据库中,在使用前串口需要有设备,同时自己创建数据库与数据表,见README
  • 串口数据读取解析

    2014-01-17 11:17:37
    c#,通过调用类函数来进行各种串口数据的操作与协议解析,经过大量使用、稳定可靠,希望对串口编写人员有所帮助。
  • 人体红外感应,UCOSSIII+STm32F0.程序可用
  • QT串口数据解析

    千次阅读 2021-02-26 10:50:47
    数据解析 /******************************************************************* * 函数功能:接收遥控器传来的数据并进行解析 * 调用:放在定时器中断服务函数中定时接收 * 时间:2020.12.5 *****************...

    数据解析

    /*******************************************************************
     * 函数功能:接收遥控器传来的数据并进行解析
     * 调用:放在定时器中断服务函数中定时接收
     * 时间:2020.12.5
    ********************************************************************/
    void MainWindow::rec_buffer()//接收操纵杆
    {
        buffer = serial->readAll();
        buffer = buffer.toHex();
    
        QString rDate;
        QByteArray fPLatLeverPercent,fPFanLeverPercent,fPMainLeverPercent,fPLonLeverPercent,
                   fPoil1LeverPercent,fPoil2LeverPercent,byteFlyingMode;
        rDate = QString(buffer);
        if(buffer != NULL)
        {
            if(rDate[0] == '0'&&rDate[1] == 'f'&&rDate.length() >= 70)
            {
                //qDebug("%s",qPrintable(rDate));
                rDate.remove(0, 2);
                fPLatLeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                fPFanLeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                fPMainLeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                fPLonLeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                byteFlyingMode = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                fPoil1LeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
                fPoil2LeverPercent = rDate.left(4).toLocal8Bit();
                rDate.remove(0, 4);
    
                gl_intPLatLeverPercent = (int16_t)fPLatLeverPercent.toInt(nullptr, 16);
                gl_intPFanLeverPercent = (int16_t)fPFanLeverPercent.toInt(nullptr, 16);
                gl_intPMainLeverPercent = (uint16_t)fPMainLeverPercent.toInt(nullptr, 16);
                gl_intPLonLeverPercent = (int16_t)fPLonLeverPercent.toInt(nullptr, 16);
                gl_intPOil1LeverPercent = (uint16_t)fPoil1LeverPercent.toInt(nullptr, 16);
                gl_intPOil2LeverPercent = (uint16_t)fPoil2LeverPercent.toInt(nullptr, 16);
    
            }
        }
        buffer.clear();
    }
    
    展开全文
  • java读取pc串口数据

    2018-10-23 15:31:53
    java读取串口数据,并且发送数据。将读取的数据存储在mysql中,然后进行绘图和数据分析。
  • 最近项目中接到一个需求,需要对接硬件流速仪,实时获取数据并保存到数据库.根据了解得到硬件支持XPH通讯、标准MODBUS通讯两种格式。支持RS-232、RS-485通讯总线。支持9600波特率. 在调试之前需要先要下载RXTX的jar包...

    最近项目中接到一个需求,需要对接硬件流速仪,实时获取数据并保存到数据库.根据了解得到硬件支持XPH通讯、标准MODBUS通讯两种格式。支持RS-232、RS-485通讯总线。支持9600波特率.

    在调试之前需要先要下载RXTX的jar包,win64位下载地址:链接:https://pan.baidu.com/s/1jGTbarFctOqEAsHh-4IfcA 提取码:7cu9 );将解压后的rxtxParallel.dll和rxtxSerial.dll两个文件放在C:\Windows\System32目录下,这样该包才能被正常的加载和调用。

    代码如下:

    
    
    import gnu.io.*;
    import org.springframework.boot.ApplicationArguments;
    import org.springframework.boot.ApplicationRunner;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.Serializable;
    import java.math.BigInteger;
    import java.util.*;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    
    
    @Component
    @Order(value = 1)
    public class ContinueRead extends Thread implements SerialPortEventListener ,ApplicationRunner,Serializable { // SerialPortEventListener
        // 监听器,我的理解是独立开辟一个线程监听串口数据
    // 串口通信管理类
        static CommPortIdentifier portId;
    
        /* 有效连接上的端口的枚举 */
    
        static Enumeration<?> portList;
        InputStream inputStream; // 从串口来的输入流
        static OutputStream outputStream;// 向串口输出的流
        static SerialPort serialPort; // 串口的引用
        // 堵塞队列用来存放读到的数据
        private BlockingQueue<String> msgQueue = new LinkedBlockingQueue<String>();
        //用来存放原始数据
        static LinkedList<Double> linkedList = new LinkedList();
    
        @Override
        /**
         * SerialPort EventListene 的方法,持续监听端口上是否有数据流
         */
        public void serialEvent(SerialPortEvent event) {//
    
            switch (event.getEventType()) {
                case SerialPortEvent.BI:
                case SerialPortEvent.OE:
                case SerialPortEvent.FE:
                case SerialPortEvent.PE:
                case SerialPortEvent.CD:
                case SerialPortEvent.CTS:
                case SerialPortEvent.DSR:
                case SerialPortEvent.RI:
                case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                    break;
                case SerialPortEvent.DATA_AVAILABLE:// 当有可用数据时读取数据
                    byte[] readBuffer = null;
                    int availableBytes = 0;
                    try {
                        availableBytes = inputStream.available();
                        while (availableBytes > 0) {
                            readBuffer = ContinueRead.readFromPort(serialPort);
                            String needData = printHexString(readBuffer);
                            System.out.println(new Date() + "真实收到的数据为:-----" + needData);
                            availableBytes = inputStream.available();
                            msgQueue.add(needData);
                        }
                    } catch (IOException e) {
                    }
                default:
                    break;
            }
        }
    
        /**
         * 从串口读取数据
         *
         * @param serialPort 当前已建立连接的SerialPort对象
         * @return 读取到的数据
         */
        public static byte[] readFromPort(SerialPort serialPort) {
            InputStream in = null;
            byte[] bytes = {};
            try {
                in = serialPort.getInputStream();
                // 缓冲区大小为一个字节
                byte[] readBuffer = new byte[1];
                int bytesNum = in.read(readBuffer);
                while (bytesNum > 0) {
                    bytes = MyUtils.concat(bytes, readBuffer);
                    bytesNum = in.read(readBuffer);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (in != null) {
                        in.close();
                        in = null;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return bytes;
        }
    
    
        /**
         * 通过程序打开COM4串口,设置监听器以及相关的参数
         *
         * @return 返回1 表示端口打开成功,返回 0表示端口打开失败
         */
        public int startComPort() {
            // 通过串口通信管理类获得当前连接上的串口列表
            portList = CommPortIdentifier.getPortIdentifiers();
    
            while (portList.hasMoreElements()) {
                // 获取相应串口对象
                portId = (CommPortIdentifier) portList.nextElement();
    
                System.out.println("设备类型:--->" + portId.getPortType());
                System.out.println("设备名称:---->" + portId.getName());
                // 判断端口类型是否为串口
                if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
                    // 判断如果COM4串口存在,就打开该串口
                    if ("COM3".equals(portId.getName())) {
                        try {
                            // 打开串口名字为COM_4(名字任意),延迟为1000毫秒
                            serialPort = (SerialPort) portId.open(portId.getName(), 1000);
    
                        } catch (PortInUseException e) {
                            System.out.println("打开端口失败!");
                            e.printStackTrace();
                            return 0;
                        }
                        // 设置当前串口的输入输出流
                        try {
                            inputStream = serialPort.getInputStream();
                            outputStream = serialPort.getOutputStream();
                        } catch (IOException e) {
                            e.printStackTrace();
                            return 0;
                        }
                        // 给当前串口添加一个监听器
                        try {
                            serialPort.addEventListener(this);
                        } catch (TooManyListenersException e) {
                            e.printStackTrace();
                            return 0;
                        }
                        // 设置监听器生效,即:当有数据时通知
                        serialPort.notifyOnDataAvailable(true);
    
                        // 设置串口的一些读写参数
                        try {
                            // 比特率、数据位、停止位、奇偶校验位
                            serialPort.setSerialPortParams(9600,
                                    SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
                                    SerialPort.PARITY_NONE);
                        } catch (UnsupportedCommOperationException e) {
                            e.printStackTrace();
                            return 0;
                        }
                        return 1;
                    }
                }
            }
            return 0;
        }
    
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                System.out.println("--------------任务处理线程运行了--------------");
                while (true) {
                    // 如果堵塞队列中存在数据就将其输出
                    if (msgQueue.size() > 0) {
                        String vo = msgQueue.peek();
                        String vos[] = vo.split("  ", -1);
                        getData(vos);
                        sendOrder();
                        msgQueue.take();
                    }
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
        /**
         * @Description: 发送获取数据指令
         * @Param:
         * @return:
         * @Author: LiangZF
         * @Date: 2019/1/3
         */
        public void sendOrder() {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 1;
            if (i == 1) {
                // 启动线程来处理收到的数据
                try {
                    byte[] b = new byte[]{0x01, 0x03, 0x00, 0x00, 0x00, 0x0E, (byte) 0xC4, 0x0E};
                    System.out.println("发送的数据:" + b);
                    System.out.println("发出字节数:" + b.length);
                    outputStream.write(b);
                    outputStream.flush();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    serialPort.close();
                    e.printStackTrace();
                } finally {
                    try {
                        if (outputStream != null) {
                            outputStream.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        /**
         * @Description:通过数组解析检测数据
         * @Param: [vo]
         * @return: void
         * @Author: LiangZF
         * @Date: 2019/1/4
         */
        public void getData(String[] vos) {
            // 数组不为空
            if (vos != null || vos.length != 0) {
                // 流速数据
                double wind_direction = getNum(vos[4], vos[5]);
                linkedList.add(wind_direction);
                System.out.println("linkedList = " + linkedList);
                System.out.println(wind_direction);
            }
        }
    
        // 16转10计算
        public double getNum(String num1, String num2) {
            BigInteger bigint=new BigInteger(num1+num2, 16);
            int numb=bigint.intValue();
            return numb/100.00;
        }
    
    
        // 字节数组转字符串
        private String printHexString(byte[] b) {
    
            StringBuffer sbf = new StringBuffer();
            for (int i = 0; i < b.length; i++) {
                String hex = Integer.toHexString(b[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sbf.append(hex.toUpperCase() + "  ");
            }
            return sbf.toString().trim();
        }
    
    
    
    
    
    
    
    
        @Override
        public void run(ApplicationArguments args) throws Exception {
            ContinueRead cRead = new ContinueRead();
            System.out.println("asdasd");
            int i = cRead.startComPort();
            if (i == 1) {
                // 启动线程来处理收到的数据
                cRead.start();
                try {
                    //根据提供的文档给出的发送命令,发送16进制数据给仪器
                    byte[] b = new byte[]{0x01, 0x03, 0x00, 0x00, 0x00, 0x0E, (byte) 0xC4, 0x0E};
                    System.out.println("发送的数据:" + b);
                    System.out.println("发出字节数:" + b.length);
                    outputStream.write(b);
                    outputStream.flush();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    try {
                        if (outputStream != null) {
                            outputStream.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                return;
            }
        }
    }
    

    工具类:

    
    import java.math.BigInteger;
    
    public class MyUtils {
    
        /**
         * 合并数组
         *
         * @param firstArray  第一个数组
         * @param secondArray 第二个数组
         * @return 合并后的数组
         */
        public static byte[] concat(byte[] firstArray, byte[] secondArray) {
            if (firstArray == null || secondArray == null) {
                if (firstArray != null)
                    return firstArray;
                if (secondArray != null)
                    return secondArray;
                return null;
            }
            byte[] bytes = new byte[firstArray.length + secondArray.length];
            System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
            System.arraycopy(secondArray, 0, bytes, firstArray.length, secondArray.length);
            return bytes;
        }
    
        public static void main(String[] args) {
            BigInteger bigint=new BigInteger("0403", 16);
            int numb=bigint.intValue();
            System.out.println(numb/100.00);
        }
    }
    
    展开全文
  • EXCEL 从串口接收数据。单片机AVR从串口发送数据
  • springboot多串口解析

    2021-05-31 10:08:32
    java解析硬件接口数据信息
  • 该labview程序实现了对下位机串口发来的float数据拼合和转换并在波形图中进行显示。同时有过零检测和FFT对采集到波形进行频率检测。还有PID调节部分,下位机带一个电机,该上位机可以设定PID数据并发送至下位机实现...
  • 串口数据解析,报文含义说明

    千次阅读 2021-12-24 16:15:37
    注意串口是用ASCII发送数据还是十六进制发送数据 一般的传感器十六进制指令及其含义 十六进制 十六进制 缩写(以ASCII发送) 含义 02 STX 本文开始 03 ETX 本文结束 04 EOT 传输结束 05 ENQ 请求 01

    注意串口是用ASCII发送数据还是十六进制发送数据

    一般的传感器十六进制指令及其含义

    十六进制      缩写(以ASCII发送)       含义
      02               STX              本文开始
      03               ETX              本文结束
      04               EOT              传输结束
      05               ENQ                请求
      01               SOH              标题开始
      06               ACK              确定回应
      43                                 图形C
      52                                 图形R
      57                                 图形W
      15               NAK              确定失败回应!(失败通信)
    

    BCC代表的是前面数据异或运算的结果!

    发送:02 43 B0 01 03 F2
    (本文开始,发图形C…)

    接收:
    02 06 数据 数据 03 校验位
    (本文开始,确定回应,…本文结束)

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,602
精华内容 10,240
关键字:

串口数据实时解析