C#上位机—事件传参

最新推荐文章于 2024-09-02 00:15:14 发布
最新推荐文章于 2024-09-02 00:15:14 发布
阅读量460 收藏 2
点赞数 2
分类专栏： 上位机 文章标签： c# 开发语言 java
SY
本文链接：https://blog.csdn.net/qq_45159887/article/details/127842155
版权
本文介绍了如何在C#中使用事件机制实现实时串口通信，包括主窗口控制串口操作、子窗口展示和处理接发数据，以及如何通过TransmitEventArgs进行参数传递。涉及事件委托、接收缓冲区管理和数据解析。
摘要由CSDN通过智能技术生成

C#上位机—事件传参

在这里插入图片描述
在这里插入图片描述
主窗口的操作
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
子窗口的操作
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO.Ports;
using System.Text;
using System.Windows.Forms;

namespace 串口助手
{
    public partial class Form1 : Form
    {
        private bool isOpen = false;

        private bool isRxShow = true;

        private List<byte> reciveBuffer = new List<byte>();

        private List<byte> sendBuffer = new List<byte>();

        private int reciveCount = 0;

        private int sendCount = 0;

        private Queue<byte> bufferQueue = null;

        private bool isHeadRecive = false;

        private int frameLenth = 0;

        public TransmitData transmitData;

        public event TransmitEventHandler transmitData2;
        //SerialPort
        public Form1()
        {
            InitializeComponent();

            Control.CheckForIllegalCrossThreadCalls = false;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //在设计页面已经预先添加了COM1 COM2 COM3 
            //this.port_cbb.Items.Add("COM4");
            //this.port_cbb.Items.Add("COM5");

            //this.port_cbb.SelectedIndex = 2;

            //this.baud_cbb.SelectedIndex = 1;

            //this.check_cbb.SelectedIndex = 0;

            //this.databit_cbb.SelectedIndex = 3;

            //this.stopbit_cbb.SelectedIndex = 0;

            // 给发送框添加预设文本
            //  this.send_rtb.Text = "我是发送框";

            // 给接收框添加预设文本
            //  this.recive_rtb.Text = "我是接收框";

            serialLoad();
            
            // 实例化
            bufferQueue = new Queue<byte>();

            Form2 fr2 = new Form2();
            // 接收数据委托窗体2 ReciveData 执行显示
            //transmitData += fr2.ReciveData;
            // 接收数据事件窗体2 ReciveData2 执行显示
            transmitData2 += new TransmitEventHandler(fr2.ReciveData2);
            // 窗体2发送委托窗体1 sendBytes 执行发送
            // fr2.useForm1Send += sendBytes;
            // 窗体2发送事件窗体1 sendbytes2 执行发送
            fr2.useForm1Send2 += new TransmitEventHandler(sendbytes2);
            fr2.Show();
        }

        private void sendbytes2(object sender, TransmitEventArgs e)
        {
            serialPort1.Write(e.data, 0, e.data.Length);
            sendCount += e.data.Length;
            sencount_tssl.Text = sendCount.ToString();
        }

        private void sendBytes(byte[] data)
        {
            serialPort1.Write(data, 0, data.Length);
            sendCount += data.Length;
            sencount_tssl.Text = sendCount.ToString();
        }

        private void serialLoad()
        {

            EncodingInfo[] encodingInfos = Encoding.GetEncodings();


            RegistryKey keyCom = Registry.LocalMachine.OpenSubKey(@"Hardware\DeviceMap\SerialComm");

            string[] sSubKeys = keyCom.GetValueNames();
            port_cbb.Items.Clear();
            foreach (var sValue in   sSubKeys)
            {
                string portName = (string)keyCom.GetValue(sValue);
                port_cbb.Items.Add(portName);
            }

            this.port_cbb.SelectedIndex = 0;

            this.baud_cbb.SelectedIndex = 1;

            this.check_cbb.SelectedIndex = 0;

            this.databit_cbb.SelectedIndex = 3;

            this.stopbit_cbb.SelectedIndex = 0;
        }

        private void sendData()
        {

            serialPort1.Write(sendBuffer.ToArray(),0,sendBuffer.Count);
            sendCount += sendBuffer.Count;
            sencount_tssl.Text = sendCount.ToString();
        }

        private void send_btn_Click(object sender, EventArgs e)
        {
            // 如果发送的数据不为空，则接收
            if (this.send_rtb.Text != "" && serialPort1.IsOpen)
            {
                Console.WriteLine(Transform.ToHexString(sendBuffer.ToArray()));
                sendData();
            }
            else
            {
                MessageBox.Show("请先输入发送数据！");

            }
        }

        private void open_btn_Click(object sender, EventArgs e)
        {
            try
            {
                if (serialPort1.IsOpen == false)
                {
                    serialPort1.PortName = port_cbb.Text;
                    serialPort1.BaudRate = Convert.ToInt32(baud_cbb.Text);
                    serialPort1.DataBits = Convert.ToInt32(databit_cbb.Text);
                    switch (check_cbb.SelectedIndex)
                    {
                        //  none  odd  even 
                        case 0:
                            serialPort1.Parity = Parity.None;
                            break;
                        case 1:
                            serialPort1.Parity = Parity.Odd;
                            break;
                        case 2:
                            serialPort1.Parity = Parity.Even;
                            break;
                        default:
                            serialPort1.Parity = Parity.None;
                            break;
                    }
                    switch (stopbit_cbb.SelectedIndex)
                    {
                        // 1 1.5 2
                        case 0:
                            serialPort1.StopBits = StopBits.One;
                            break;
                        case 1:
                            serialPort1.StopBits = StopBits.OnePointFive;
                            break;
                        case 2:
                            serialPort1.StopBits = StopBits.Two;
                            break;
                        default:
                            serialPort1.StopBits = StopBits.One;
                            break;
                    }

                    serialPort1.Open();
                    isOpen = true;
                    open_btn.Text = "关闭串口";


                }
                else
                {
                    serialPort1.Close();
                    isOpen = false;
                    open_btn.Text = "打开串口";

                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString()+serialPort1.PortName.ToString());
            }
        }

        private void serialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (isRxShow == false) return;
            // 1,需要读取有效的数据 BytesToRead
            byte[] dataTemp = new byte[serialPort1.BytesToRead];
            serialPort1.Read(dataTemp,0,dataTemp.Length);

            reciveBuffer.AddRange(dataTemp);

            reciveCount += dataTemp.Length;

            //?. = 如果transmitData !=null
           // transmitData?.Invoke(dataTemp);
            transmitData2?.Invoke(this, new TransmitEventArgs { data = dataTemp });
            this.Invoke(new EventHandler(delegate
            {
                // 显示接收数据的长度
                recivecount_tssl.Text = reciveCount.ToString();
                if (startData_chb.Checked == false)
                {
                    if (!recivehex_chb.Checked)
                    {
                        // 2, 编码格式的选择
                        string str = Encoding.GetEncoding("gb2312").GetString(dataTemp);
                        // 3，0x00 -> \0 结束 不会显示
                        str = str.Replace("\0", "\\0");

                        recive_rtb.AppendText(str);

                        // recive_rtb.AppendText(Encoding.GetEncoding("gb2312").GetString(dataTemp).Replace("\0", "\\0"));
                    }
                    else
                    {
                        //  十六进制是选中的状态下
                        recive_rtb.AppendText(Transform.ToHexString(dataTemp, " "));
                    }
                }
                else
                {
                    // 解析数据 queue

                    foreach (byte item in dataTemp)
                    {
                        // 入列
                        bufferQueue.Enqueue(item);
                    }

                    // 解析获取帧头
                    if (isHeadRecive == false)
                    {

                        foreach (byte item in bufferQueue.ToArray())
                        {
                            if (item != 0x7f)
                            {
                                // 出列
                                bufferQueue.Dequeue();
                                Console.WriteLine("not 0x7f, Dequeue !!");
                            }
                            else
                            {
                                // get 0x7f from bufferQueue
                                isHeadRecive = true;
                                Console.WriteLine("0x7f is recived !!");
                                break;
                            }
                        }
                    }

                    if (isHeadRecive == true)
                    {
                        // 判断有数据帧长度
                        if (bufferQueue.Count >= 2)
                        {
                            Console.WriteLine(DateTime.Now.ToLongTimeString());
                            Console.WriteLine($"show the data in bufferQueue{Transform.ToHexString(bufferQueue.ToArray())}");
                            Console.WriteLine($"frame lenth ={String.Format("{0:X2}", bufferQueue.ToArray()[1])}");
                            frameLenth = bufferQueue.ToArray()[1];
                            // 一帧完整的数据长度判断，不代表数据是正确的
                            if(bufferQueue.Count>=1+1+frameLenth+2)
                            {
                                byte[] frameBuffer = new byte[1 + 1 + frameLenth + 2];
                                Array.Copy(bufferQueue.ToArray(), 0, frameBuffer, 0, frameBuffer.Length);
                                if(crc_chech(frameBuffer))
                                {
                                    Console.WriteLine("frame is check ok,pick it");
                                    data_txb.Text = Transform.ToHexString(frameBuffer);
                                    data1_txb.Text = String.Format("{0:X2}", frameBuffer[2]);
                                    data2_txb.Text = String.Format("{0:X2}", frameBuffer[3]);
                                    data3_txb.Text = String.Format("{0:X2}", frameBuffer[4]);
                                    data4_txb.Text = String.Format("{0:X2}", frameBuffer[5]);

                                }
                                else
                                {
                                    // 无效数据
                                    Console.WriteLine("bad frame, drop it");
                                    
                                }


                                for(int i=0; i<1 + 1+frameLenth+2;i++)
                                {
                                    bufferQueue.Dequeue();
                                }

                                isHeadRecive = false;
                            }
                        }
                        //接续接收数据
                    }
                }
            }));
        }

        private bool crc_chech(byte[] frameBuffer)
        {
            /*大端模式: 是指数据的高字节保存在内存的低地址中，
             * 而数据的低字节保存在内存的高地址中，这样的存储
             * 模式有点儿类似于把数据当作字符串顺序处理：地址
             * 由小向大增加，而数据从高位往低位放；这和我们的
             * 阅读习惯一致。
             * 
             * 小端模式: 是指数据的高字节保存在内存的高地址中，
             * 而数据的低字节保存在内存的低地址中，这种存储模
             * 式将地址的高低和数据位权有效地结合起来，高地址
             * 部分权值高，低地址部分权值低。
             */
            bool ret = false;

            byte[] temp = new byte[frameBuffer.Length-2];
            Array.Copy(frameBuffer, 0, temp, 0, temp.Length);
            byte[] crcdata = DataCheck.DataCrc16_Ccitt(temp, DataCheck.BigOrLittle.BigEndian);
            if (crcdata[0] == frameBuffer[frameBuffer.Length - 2] &&
                crcdata[1]== frameBuffer[frameBuffer.Length-1])
            {
                // check ok
                ret = true;
            }

            return ret;

        }

        private void stop_btn_Click(object sender, EventArgs e)
        {
            if (isRxShow == true)
            {
                isRxShow = false;
                stop_btn.Text = "取消暂停";
            }
            else
            {
                isRxShow = true;
                stop_btn.Text = "暂停";
            }
        }

        private void recivehex_chb_CheckedChanged(object sender, EventArgs e)
        {
            if (recive_rtb.Text == "") return;
            if (recivehex_chb.Checked)
            {
                recive_rtb.Text = Transform.ToHexString(reciveBuffer.ToArray()," ");
            }
            else
            {
                recive_rtb.Text = Encoding.GetEncoding("gb2312").GetString(reciveBuffer.ToArray()).Replace("\0","\\0");
            }
        }

        private void clear_btn_Click(object sender, EventArgs e)
        {
            reciveBuffer.Clear();
            reciveCount = 0;
            recivecount_tssl.Text = "0";
            recivecount_tssl.Text = "";
            recive_rtb.Text = "";
        }

        private void autoclear_chb_CheckedChanged(object sender, EventArgs e)
        {
            if (autoclear_chb.Checked)
            {


                timer1.Start();
            }
            else
            {
                timer1.Stop();
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (recive_rtb.Text.Length > 4096)
            {
                reciveBuffer.Clear();
                recive_rtb.Text = "";
                recivecount_tssl.Text = "";
            }
        }

        private void send_rtb_Leave(object sender, EventArgs e)
        {
            if (sendhex_chb.CheckState == CheckState.Checked)
            {
                if (DataEncoding.IsHexString(send_rtb.Text.Replace(" ", "")))
                {
                    sendBuffer.Clear();
                    sendBuffer.AddRange(Transform.ToBytes(send_rtb.Text.Replace(" ", "")));

                }
                else
                {
                    MessageBox.Show("请输入正确的十六进制数据！！");
                    send_rtb.Select();
                }
            }
            else
            {
                sendBuffer.Clear();
                sendBuffer.AddRange(Encoding.GetEncoding("gb2312").GetBytes(send_rtb.Text));
            }
        }

        private void send_rtb_TextChanged(object sender, EventArgs e)
        {
            // 十六进制切换 会出现问题  这问题就是0x00 转换
        }

        private void sendhex_chb_CheckedChanged(object sender, EventArgs e)
        {
            if (send_rtb.Text == "") return;

            if (sendhex_chb.Checked == true)
            {
                send_rtb.Text = Transform.ToHexString(sendBuffer.ToArray(), " ");
            }
            else 
            { 
                send_rtb.Text = Encoding.GetEncoding("gb2312").GetString(sendBuffer.ToArray()).Replace("\0","\\0");

            }
        }

        private void sendclear_btn_Click(object sender, EventArgs e)
        {
            sendBuffer.Clear();

            send_rtb.Text = "";

            sendCount = 0;

            sencount_tssl.Text = "0";
        }
    }
}
傻童:CPU
关注
专栏目录
在C#里传送事件的参数
大坡3D软件开发
10-25 1387
传送参数可以使用三种情况，一种是直接使用EventHandler，内部定义事件类型，大多数情况下可以这样使用；最后一种是使用范型参数的方式。很多情况下，我们需要传送事件，并且顺带参数传送过去，在事件传送参数是比较常用的功能，现在就来熟悉这方面的内容。这两个类主要区别是第一个不是范型，第二个是范型，所以后面一个可以任何类型的数据。最后只需要定义事件对象和设置事件响应函数即可。把事件封装到一个类里，这样方便后面定义对象。这三种方式是实现事件传送参数的基本方式。//创建范型事件参数。
C#消息队列发送及接收
03-25
C#消息队列发送及接收
C# 串口助手
小平科技创新
05-12 437
在做项目的过程中频繁接触串口通信，积累了C#相关知识，业余时间编辑了最基本的串口助手，添加了自己所需要的功能。 主要功能：1.数据的发送、接收 2.HEX的发送和显示 3.增加常用几种编码 /*****************************************************...
c#事件 （重点是自定义事件）
最新发布
qq_61441003的博客
09-02 1333
c#规定，我们在使用委托来声明事件的时候，委托的名称需要叫做：事件名称+EventHandler，这个事件需要两个参数，一个是事件的拥有者，一个是事件参数，c#规定事件参数需要命名为：事件名称+EventArgs。如果某个类作为EventArgs来使用，那么它应该继承（也叫派生）自EventArgs这个类。set;set;i < 5;i++)= null)e.DishName = "宫保鸡丁";WalkIn();
C#上位机——串口助手高级03
小柚子的博客
11-11 512
【代码】C#上位机——串口助手高级03。
C#队列的使用
Tiger_shl的博客
12-30 1029
队列的封装类: public class QueueManager { //<>角括号中写入的是加入队列的元素的类型 private Queue<byte[]> queue = new Queue<byte[]>(); /// <summary> /// 加入队列 ...
C#环形缓冲区（队列）完全实现
weixin_30673715的博客
07-27 345
公司项目中经常设计到串口通信，TCP通信，而且大多都是实时的大数据的传输，然后大家都知道协议通讯肯定涉及到什么，封包、拆包、粘包、校验……什么鬼的概念一大堆，说简单点儿就是要一个高效率可复用的缓存区。按照码农的惯性思维就是去百度、谷歌搜索看有没有现成的东西可以直接拿来用，然而我并没有找到，好吧不是很难的东西自己实现一个呗。开扯…… 为什么要用环形队列？ 环形队列是在实际编程极为有用的数据结构,它有...
完整教程_上位机_c#上位机教程_
09-29
【标题】"完整教程_上位机_c#上位机教程_"揭示了本教程的核心内容，即关于如何使用C#编程语言开发上位机应用程序的全面指导。上位机，通常指的是与下位机（如PLC、单片机等）进行数据交互的计算机系统，用于监控、...
C#上位机实战开发指南
12-05
因此，选择VS2015作为C#上位机开发工具是明智之选。 C#语法基础对于初学者而言是上位机开发入门的关键。C#作为一种高级语言，其语法与C语言存在很多相似之处，这也意味着拥有C语言基础的学习者可以较快地掌握C#。C#...
C#上位机开发-串口通信，读取并处理数据
03-13
总结来说，C#上位机开发中的串口通信主要包括配置串口参数、监听数据接收事件以及解析和处理接收到的16进制数据。理解这些概念并熟练应用，可以帮助我们构建能够读取和处理串口数据的高效上位机应用程序。通过不断...
C#上位机与PanasonicPLC通讯
11-28
【亲测有效】C#上位机与PanasonicPLC通讯 文件类型：c# 主要功能： 写PLC单个外部输出 写PLC单个内部继电器 写PLC数据寄存器 写PLC多个外部输出触电 写PLC多个内部寄存器 获取PLC运行状态 读PLC多个外部输出触电 读...
基于C#的串口调试助手，支持进制转换，可编辑发送队列，支持XModem,YModem，基于.net 2.0开发，单文件免费串口调
06-02
基于C#的串口调试助手，支持进制转换，可编辑发送队列，支持XModem,YModem。基于.net 2.0开发，单文件免费串口调试工具。基本功能:自动识别系统串口号并显示相应的驱动名称。支持常用波特率选择，也可手动输入波特率。支持串口流控控制（使用时需要硬件支持）。支持十六进制收发功能。可一键恢复默认设置。统计收发字节数。支持窗体置顶功能。关闭后自动保存上次设置。
C# .NET工控上位机开发
06-04
学习C#时，需要掌握类、对象、接口、继承、多态等面向对象概念，以及异常处理、委托和事件等特性。 二、.NET Framework与.NET Core .NET Framework是微软的开发框架，包含了大量的库和服务，如Windows Forms、WPF、...
C#中利用事件来传递数据(EventArgs)
热门推荐
讲述工作、生活、技术中的日常与感悟。
01-28 1万+
前言 前文介绍在GUI编程中的事件，其中说到EventHandler委托类型在声明时，必须有两个参数变量，第一个是object类型，第二个是EventArgs类型。 对于EventArgs类型，有2个作用。当不需要使用事件传递参数时，此变量传递null即可；当需要使用事件传递参数时，该类型当作基类使用，可传递其的子类(存储数据)，用于传递数据。 在事件中利用EventArgs传递数据 那么我们修改之前的例子，阿辉继续订阅报社的报纸，当报社发报后，阿辉可第一时间进行阅读。修改后变为报社发报的文章里面包含阿辉名
C#之参数传递
weixin_42035462的博客
11-22 786
C#之参数传递
C语言实现队列接收数据
C++无脑入~~~~
09-11 614
队列是一种特殊的线性表，其特点是先进先出（FIFO）的原则。队列只允许在表的一端进行插入操作，在另一端进行删除操作。插入操作叫做入队，删除操作叫做出队。队列的两个基本操作是入队和出队。数组实现是一种比较简单的队列实现方法。可以通过定义一个数组和两个指针front和rear来实现。front指向队头元素，rear指向队尾元素。当队列为空时，front和rear指向同一个位置。数组实现的优点是简单易懂，适用于数据量比较小的情况。但是当数据量比较大时，需要频繁地进行数据搬移，效率比较低。链表实现是一种比较灵活的队
c# event事件传递参数
weixin_30922589的博客
05-13 1083
public class SeatChoosenEventArgs : EventArgs { public 呼叫中心工号核对表Entity SeatChoosen; } public partial class UCSeatIcon : UserControl { private 呼叫中心工号核对表Entity _enti...
C#解决串口数据丢失问题
qq_41816727的博客
09-19 4348
C# 解决串口数据丢失问题 C # 串行类( SerialPort )是.NET Framework version 2.0 中一个新增的类，该类将串口操作了封装，从而为串口通信提供了简便方法。 但在实际串口通信的应用中，在串口高波特率大信息量的数据通信时，会出现丢失数据的问题。 通常我们使用SerialPort类接收串口发送过来的数据时，只需要写一个事件函数。 即DataReceived 事件绑定一个处理函数，然后就可以在该函 数中实现对串口数据的读取。 这个函数的内容可以根据我们的需求自行修改。就单纯从
c# com口通讯（2）- 代码及16CRC校验
Java_c#
04-21 3262
public partial class SerialportSampleForm : Form { private SerialPort comm = new SerialPort(); private StringBuilder builder = new StringBuilder();//避免在事件处理方法中反复的创建，定义到外面。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

傻童:CPU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值