serialport_serialport类 - CSDN
精华内容
参与话题
  • SerialPort串口通信实例

    热门讨论 2020-07-30 23:32:40
    使用SerialPort在WPF中进行串口通信的实例,实现了本机发送,本机接收,既可以同步接收又可以异步接收
  • C#SerialPort详细用法

    万次阅读 多人点赞 2018-11-07 11:15:59
    1。简介 随着USB的流行,串口通讯已经应用到日常生活的很多方面了,USB是一种高速的串口通讯协议,USB接口非常复杂,通常被用在需要传输大量数据数据的地方,如U盘、相机、打印机等。除了USB这种较为奢侈的串口外,...

    转自:https://www.cnblogs.com/fx2008/p/4317302.html

    1。简介

    随着USB的流行,串口通讯已经应用到日常生活的很多方面了,USB是一种高速的串口通讯协议,USB接口非常复杂,通常被用在需要传输大量数据数据的地方,如U盘、相机、打印机等。除了USB这种较为奢侈的串口外,在工控和嵌入式行业,大量被使用的是另一种古老的串口协议,RS-232串口。RS-232是一种非常简洁的低速串口通讯接口,它可以同时进行数据接收和发送的工作。

    2。.NET 2.0对串口的支持

    .NET 2.0提供了对串口通信功能的支持,有关类可以在命名空间System.IO.Ports下找到,这其中最为重要的是SerialPort类。

    通过创建一个新的SerialPort 对象,我们就可以在.NET程序中控制串口通讯的全过程。

    3。使用 SerialPort 设置串口属性

    进行串口通讯时,需要设置一些相关参数,可以通过设置SerialPort 类的属性来进行。串口属性主要包括

    .PortName 串口名称,COM1, COM2等。
    .BaudRate 波特率,也就是串口通讯的速度,进行串口通讯的双方其波特率需要相同,如果用PC连接其他非PC系统,一般地,波特率由非PC系统决定。
    .Parity 奇偶校验。可以选取枚举Parity中的值
    .DataBits 数据位
    .StopBits 停止位,可以选取枚举StopBits中的值
    .Handshake 握手方式,也就是数据流控制方式,可以选取枚举Handshake中的值

    4。打开与关闭串口


    在创建一个SerialPort 对象,设置串口属性后,可以通过 Open()方法打开串口。数据读写完成后,可以通过Close()方法关闭串口。

    根据经验,对于有些系统,在打开串口后,还需要将RtsEnable设置为True,这样才能读写数据,否则不能正常读写数据。

    5。读写行数据

    双方通讯时,一般都需要定义通讯协议,即使最简单的通过串口发送文本聊天的程序。

    通常是在当一方按下回车时,将其所数据的文本连同换行符发给另一方。在这个通讯事例中,协议桢是通过换行符界定的,每一桢数据都被换行符隔开,这样就很容易识别出通讯双发发送的信息。

    在以上的例子中,可以用WriteLine()来发送数据,用ReadLine()来读取数据。WriteLine发送完数据后,会将换行符作为数据也发送给对方。ReadLine()读取数据时,直至遇到一个换行符,然后返回一个字符串代表一行信息。换行符可以通过SerialPort 的属性NewLine来设置。一般地,Windows将CrLn作为换行符,而在Linux下,换行符则只用一个Ln表示。

    ReadLine()方法是阻塞的,直至遇到一个换行符后返回。在读取数据时,如果一直没有遇到换行符,那么在等待ReadTimeout时间后,抛出一个TimeoutException。默认情况下,ReadTimeout为InfiniteTimeout。这样,ReadLine一直处于阻塞状态,直至有新一行数据到达。

    WriteLine()方法也是阻塞的,如果另一方不能及时接收数据,就会引起TimeoutException异常。

    由于ReadLine()和WriteLine()方法都是阻塞式的,在程序使用SerialPort 进行串口通讯时,一般应该把读写操作交由其他线程处理,避免因为阻塞而导致程序不响应。

    6。读写字节或字符数据

    对于字节或字符数据,用Read()方法来读数据,该方法需要一个字节或字符数组作为参数来保存读取的数据,结果返回实际读取的字节或字符数。写数据使用Write()方法,该方法可以将字节数组、字符数据或字符串发送给另一方。

    如果通讯双方交换的数据位字节流数据,要构建一个使用的串口通讯程序,那么双方应该定义数据桢格式。通常数据桢由桢头和桢尾来界定。

    发送数据比较简单,只需要将构造好的数据用Write()方法发送出去即可。

    接收数据则比较复杂,通讯是以字节流的形式到达的,通过调用一次Read()方法并不能确保所读取的数据就是完整一桢。因此需要将每次读取的数据整合在一起,对整合后的数据进行分析,按照定义的桢格式,通过桢头和桢尾,将桢信息从字节流中抽取出来,这样才能获取有意义的信息。

    除了利用Read()方法来读数据,还可以使用ReadExisting()方法来读取数据。该方法读取当前所能读到的数据,以字符串的形式返回。

    7。事件

    SerialPort 提供了DataReceived事件。当有数据进入时,该事件被触发。该事件的触发由操作系统决定,当有数据到达时,该事件在辅助线程中被触发。辅助线程的优先级比较低,因此并不能确保每个字节的数据到达时,该事件都被触发。

    在使用该事件接收数据时,最好对定义通讯协议格式,添加桢头和桢尾。在DataReceived事件中接收数据时,把数据放在数组中或字符串中缓冲起来,当接收的包含桢头和桢尾的完整数据时,在进行处理,另外,为了有效地接收数据,可以在每次读取数据后,加入System.Threading.Thread.Sleep方法进行演示。

    8。其他
           用跳线使串口的第2、3针连接,可以在本地计算机上实现串口通信,所以,通过串口的第2、3针的连接可以对程序进行检测。


    .BytesToRead 该属性返回能够读到的字节数。

    方 法 名 称

    说  明

    Close

    关闭端口连接,将 IsOpen 属性设置为False,并释放内部 Stream 对象

    Open

    打开一个新的串行端口连接

    Read

    从 SerialPort 输入缓冲区中读取数据字节数

    ReadByte

    从 SerialPort 输入缓冲区中同步读取一个字节

    ReadChar

    从 SerialPort 输入缓冲区中同步读取一个字符

    ReadLine

    一直读取到输入缓冲区中的 NewLine 值

    ReadTo

    一直读取到输入缓冲区中指定 value 的字符串

    Write

    已重载。将数据写入串行端口输出缓冲区

    WriteLine

    将指定的字符串和 NewLine 值写入输出缓冲区

    DiscardInBuffer

    DiscardOutBuffer

    清空接收缓冲区数据

    清空输出缓冲去数据

    属性说明

    名  称

    说  明

    BaseStream

    获取 SerialPort 对象的基础 Stream 对象

    BaudRate

    获取或设置串行波特率

    BreakState

    获取或设置中断信号状态

    BytesToRead

    获取接收缓冲区中数据的字节数

    BytesToWrite

    获取发送缓冲区中数据的字节数

    CDHolding

    获取端口的载波检测行的状态

    CtsHolding

    获取“可以发送”行的状态

    DataBits

    获取或设置每个字节的标准数据位长度

    DiscardNull

    获取或设置一个值,该值指示 Null 字节在端口和接收缓冲区之间传输时是否被忽略

    DsrHolding

    获取数据设置就绪 (DSR) 信号的状态

    DtrEnable

    获取或设置一个值,该值在串行通信过程中启用数据终端就绪 (DTR) 信号

    Encoding

    获取或设置传输前后文本转换的字节编码

    Handshake

    获取或设置串行端口数据传输的握手协议

    IsOpen

    获取一个值,该值指示 SerialPort 对象的打开或关闭状态

    NewLine

    获取或设置用于解释 ReadLine( )和WriteLine( )方法调用结束的值

    Parity

    获取或设置奇偶校验检查协议

    ParityReplace

    获取或设置一个字节,该字节在发生奇偶校验错误时替换数据流中的无效字节

    PortName

    获取或设置通信端口,包括但不限于所有可用的 COM 端口

    ReadBufferSize

    获取或设置 SerialPort 输入缓冲区的大小

    ReadTimeout

    获取或设置读取操作未完成时发生超时之前的毫秒数

    ReceivedBytesThreshold

    获取或设置 DataReceived 事件发生前内部输入缓冲区中的字节数

    RtsEnable

    获取或设置一个值,该值指示在串行通信中是否启用请求发送 (RTS) 信号

    StopBits

    获取或设置每个字节的标准停止位数

    WriteBufferSize

    获取或设置串行端口输出缓冲区的大小

    WriteTimeout

    获取或设置写入操作未完成时发生超时之前的毫秒数

    展开全文
  • SerialPort串口通信(二)

    千次阅读 2019-06-13 19:12:01
    好吧,来看看如何使用SerialPort串口通信 1.首先我们来看一下,运行的效果图: 2.添加依赖,在app下的builder.gradle //gogle serialPort implementation 'com.aill:AndroidSerialPort:1.0.8' ...

    简化版的串口通信,非常的简单,看了以后,会很简洁,很清晰,本人亲测,这个博客的例子完美运行

    好吧,来看看如何使用SerialPort串口通信

    1.首先我们来看一下,运行的效果图:

    2.添加依赖,在app下的builder.gradle

      //gogle serialPort
        implementation 'com.aill:AndroidSerialPort:1.0.8'

    3.下发和接收数据:

    package com.example.administrator.testz;
    
    
    import android.content.Context;
    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v4.widget.TextViewCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.TextView;
    import com.aill.androidserialport.SerialPort;
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    
    /**
     * Created by jiang on 2017/12/28.
     */
    
    public class SerialportTestAct extends AppCompatActivity implements View.OnClickListener {
        private StringBuffer seriapPortMsg = new StringBuffer();
        private final String TAG = "SerialportTestAct:";
        private InputStream mInputStream;
        private OutputStream mOutputStream;
        private TextView log;
        private EditText serMsg;
        private Button sendMsg;
        private SerialPort serialPort;
        private final String SERIALPORT_NO3 = "/dev/ttyS1";//串口号3
        private final int BAUDRATE = 115200;//波特率
        private Context mContext;
    
        //记住  我们的程序  不管客户端还是硬件端 发送和接收的指令统一使用十六进制(HEX)来表示
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            mContext = this;
            setContentView(R.layout.act_serialport);
            log = (TextView) findViewById(R.id.log);
            sendMsg = (Button) findViewById(R.id.sendMsg);
            sendMsg.setOnClickListener(this);
            serMsg = (EditText) findViewById(R.id.serMsg);
            initSerialPort();  //初始化串口设置
        }
    
        @Override
        public void onClick(View view) {
            switch (view.getId()){
                case R.id.sendMsg:
                    //点击按钮向串口下发指令数据
                    String msg = serMsg.getText().toString().trim();
                    if(msg!=null&&!msg.equals("")){
                        //string转16进制的数据,下发的数据必须为byte数组,长度会根据协议来定
                        byte[] buff = fromHexString(msg);
                        try {
                            mOutputStream.write(buff,0,buff.length);
                            Log.e(TAG, "下发完成");
                        } catch (IOException e) {
                            e.printStackTrace();
                            Log.e(TAG, e.getMessage());
                        }
                    }
            }
        }
    
        private void initSerialPort() {
            try {
                serialPort = new SerialPort(new File(SERIALPORT_NO3), BAUDRATE, 0);
                mInputStream = serialPort.getInputStream();
                mOutputStream = serialPort.getOutputStream();
                //这个地方为什么要开线程? 因为这个线程是用于监听返回的数据的,必须开,一直开着
                new Thread(new ReadSerialPortMsgThread()).start();
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "打开串口失败");
            }
        }
    
        //接收硬件通过串口回应的数据
        private class ReadSerialPortMsgThread implements Runnable {
            @Override
            public void run() {
                int size;
                byte buff[] = new byte[1024];
                while (true) {
                    try {
                        if (mInputStream == null) {
                            return;
                        }
                        size = mInputStream.read(buff);
                        Log.e(TAG, "接收到串口回调w == " + size);
                        if (size > 0) {
                            for (int i = 0; i < size; i++) {
                                Log.e("TAG", "十进制=" + buff[i]);
                                final String res = hexToDecimal(buff[i]);
                                log.post(new Runnable() {
                                    @Override
                                    public void run() {
                                       // editIn.append(text)
                                        log.append("" + res);
                                    }
                                });
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    
        //十进制转16进制
        private String hexToDecimal(byte oneByte) {
            String str = "";
            int h = (oneByte >>> 4) & 0xF;
            int l = oneByte & 0xF;
            char ch = (char) ((h < 10) ? ('0' + h) : ('A' + h - 10));
            char cl = (char) ((l < 10) ? ('0' + l) : ('A' + l - 10));
            str = "";
            str += ch;
            str += cl;
            return str;
        }
    
        /**
         * 16进制字符串转换成字节数组。
         * <p>
         * param hex 16进制字符串
         *这个协议是  还的重订
         * @return 字节数组
         */
        private byte[] hexStringToByte(String hex) {
            if (hex == null || hex.equals(""))
                return null;
            String[] arry = hex.split(" ");
            byte[] data = new byte[arry.length];
            try {
                for (int i = 0; i < arry.length; i++) {
                    //这个地方在定协议
                    if (arry[i].length() > 2)
                        return null;
                    int d = Integer.parseInt(arry[i], 16);
                    data[i] = (byte) (d & 0xff);
                }
    
            } catch (Exception e) {
                return null;
            }
            return data;
        }
    
        public static byte[] fromHexString(String hexString) {
            if (null == hexString || "".equals(hexString.trim())) {
                return new byte[0];
            }
            byte[] bytes = new byte[hexString.length() / 2];
            // 16进制字符串
            String hex;
            for (int i = 0; i < hexString.length() / 2; i++) {
                // 每次截取2位
                hex = hexString.substring(i * 2, i * 2 + 2);
                // 16进制-->十进制
                bytes[i] = (byte) Integer.parseInt(hex, 16);
            }
    
            return bytes;
        }
    }
    

    4.贴一下布局吧,仅仅一个类,就解决串口数据通信的下发和接收问题,到这里基本就结束了

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="30dp">
    
        <TextView
            android:layout_width="match_parent"
            android:layout_height="30dp"
            android:text="串口接收数据:"
            android:textSize="20sp" />
    
        <TextView
            android:id="@+id/log"
            android:layout_width="match_parent"
            android:layout_height="80dp"
            android:background="@color/colorAccent" />
    
        <TextView
            android:layout_width="match_parent"
            android:layout_height="30dp"
            android:layout_marginTop="30dp"
            android:text="串口发送数据:"
            android:textSize="20sp" />
    
        <EditText
            android:id="@+id/serMsg"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:hint="输入下发的值" />
    
        <Button
            android:id="@+id/sendMsg"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:text="发送串口信息" />
    
    </LinearLayout>
    

     

    展开全文
  • C#中串口类serialPort的用法!

    万次阅读 2013-06-24 14:13:21
    最近由于任务需要,用到了serialPort类,在此记录重要步骤。   主要常用的属性为:  PortName //可用的COM端口号  BaudRate //波特率  DataBits //数据位  StopBits //停止位  Parity //奇偶校验 ...

    最近由于任务需要,用到了serialPort类,在此记录重要步骤。

        主要常用的属性为:

        PortName    //可用的COM端口号

        BaudRate    //波特率

        DataBits      //数据位

        StopBits      //停止位

        Parity           //奇偶校验

        BytesToRead //获取接收缓冲区的字节数

        BytesToWrite //获取发送缓冲区的字节数

    其中前五个属性是打开一个串口最基本的参数。比如一般的串口调试工具都是默认数据位为8,停止位1,奇偶校验0,如下:

    串口实例化后的对象为serialPort1,则

    serialPort1.Parity = Parity.None;

    serialPort1.DataBits = Convert.ToInt32(“8”);

    serialPort1.StopBits = StopBits.One;

    serialPort1.Open();

      常用的方法:

    DiscardInBuffer         //丢弃接收缓存区的内容

    DiscardOutBuffer     //丢弃发送缓冲区的内容

    Open                          //打开串口

    read                           //从输入缓冲区读取

    这个方法需要特别说明,一般用到的重载方法为  public int  Read(

                                                                                                                 byte[] buffer, //将输入写入到其中的字节数组

                                                                                                                 int offset,      //缓冲区数中开始写入的偏移量

                                                                                                                 int count       //要读取的字节数

                                                                                                                     )

    表示从 SerialPort输入缓冲区读取一些字节并将那些字节写入字节数组中指定的偏移量处。并且利用read读出来的是字节数组,如果要转换为字符串的话还需要System.Text.Encoding.ASCII.GetString(buffer);

    write(string)                         //将制定的字符串写入串行端口

    常用事件:

    DataReceived           //数据接收事件的方法

    从 serialPort 对象接收数据时,将在辅助线程上引发DataReceived 事件,因此貌似这个事件是一直在“循环的”(只要接收缓冲区有数据就出发)。如果不调用该事件也可以实现实时的接受数据,但应该就要另外开辟一条线程了,目前我还没研究,以后有机会了应该要探究下。

       

     

     

    展开全文
  • VS 串口通信SerialPort,官方demo

    万次阅读 2017-10-12 10:12:52
    网上有很多解决方案: 主流大概三种: 1、使用mscomm控件,是微软以前提供的控件,现在已经放弃了。...3、使用.net framework 中的SerialPort类。api地址为: https://msdn.microsoft.com/zh-cn/library/system

    网上有很多解决方案:

    主流大概三种:

    1、使用mscomm控件,是微软以前提供的控件,现在已经放弃了。当然在vs中可以手动集成这个控件,也能使用,但是需要注册。

    2、自己编程实现串口通信(这个以后有时间写个博客)

    3、使用.net framework 中的SerialPort类。api地址为:

    https://msdn.microsoft.com/zh-cn/library/system.io.ports.serialport(v=vs.110).aspx

    本文介绍这个里面demo导入vs控制台应用后的错误修复问题。

    在上面的那个网址中,官方的C++代码为:

    #using <System.dll>
    
    using namespace System;
    using namespace System::IO::Ports;
    using namespace System::Threading;
    
    public ref class PortChat
    {
    private:
        static bool _continue;
        static SerialPort^ _serialPort;
    
    public:
        static void Main()
        {
            String^ name;
            String^ message;
            StringComparer^ stringComparer = StringComparer::OrdinalIgnoreCase;
            Thread^ readThread = gcnew Thread(gcnew ThreadStart(PortChat::Read));
    
            // Create a new SerialPort object with default settings.
            _serialPort = gcnew SerialPort();
    
            // Allow the user to set the appropriate properties.
            _serialPort->PortName = SetPortName(_serialPort->PortName);
            _serialPort->BaudRate = SetPortBaudRate(_serialPort->BaudRate);
            _serialPort->Parity = SetPortParity(_serialPort->Parity);
            _serialPort->DataBits = SetPortDataBits(_serialPort->DataBits);
            _serialPort->StopBits = SetPortStopBits(_serialPort->StopBits);
            _serialPort->Handshake = SetPortHandshake(_serialPort->Handshake);
    
            // Set the read/write timeouts
            _serialPort->ReadTimeout = 500;
            _serialPort->WriteTimeout = 500;
    
            _serialPort->Open();
            _continue = true;
            readThread->Start();
    
            Console::Write("Name: ");
            name = Console::ReadLine();
    
            Console::WriteLine("Type QUIT to exit");
    
            while (_continue)
            {
                message = Console::ReadLine();
    
                if (stringComparer->Equals("quit", message))
                {
                    _continue = false;
                }
                else
                {
                    _serialPort->WriteLine(
                        String::Format("<{0}>: {1}", name, message) );
                }
            }
    
            readThread->Join();
            _serialPort->Close();
        }
    
        static void Read()
        {
            while (_continue)
            {
                try
                {
                    String^ message = _serialPort->ReadLine();
                    Console::WriteLine(message);
                }
                catch (TimeoutException ^) { }
            }
        }
    
        static String^ SetPortName(String^ defaultPortName)
        {
            String^ portName;
    
            Console::WriteLine("Available Ports:");
            for each (String^ s in SerialPort::GetPortNames())
            {
                Console::WriteLine("   {0}", s);
            }
    
            Console::Write("Enter COM port value (Default: {0}): ", defaultPortName);
            portName = Console::ReadLine();
    
            if (portName == "")
            {
                portName = defaultPortName;
            }
            return portName;
        }
    
        static Int32 SetPortBaudRate(Int32 defaultPortBaudRate)
        {
            String^ baudRate;
    
            Console::Write("Baud Rate(default:{0}): ", defaultPortBaudRate);
            baudRate = Console::ReadLine();
    
            if (baudRate == "")
            {
                baudRate = defaultPortBaudRate.ToString();
            }
    
            return Int32::Parse(baudRate);
        }
    
        static Parity SetPortParity(Parity defaultPortParity)
        {
            String^ parity;
    
            Console::WriteLine("Available Parity options:");
            for each (String^ s in Enum::GetNames(Parity::typeid))
            {
                Console::WriteLine("   {0}", s);
            }
    
            Console::Write("Enter Parity value (Default: {0}):", defaultPortParity.ToString());
            parity = Console::ReadLine();
    
            if (parity == "")
            {
                parity = defaultPortParity.ToString();
            }
    
            return (Parity)Enum::Parse(Parity::typeid, parity);
        }
    
        static Int32 SetPortDataBits(Int32 defaultPortDataBits)
        {
            String^ dataBits;
    
            Console::Write("Enter DataBits value (Default: {0}): ", defaultPortDataBits);
            dataBits = Console::ReadLine();
    
            if (dataBits == "")
            {
                dataBits = defaultPortDataBits.ToString();
            }
    
            return Int32::Parse(dataBits);
        }
    
        static StopBits SetPortStopBits(StopBits defaultPortStopBits)
        {
            String^ stopBits;
    
            Console::WriteLine("Available Stop Bits options:");
            for each (String^ s in Enum::GetNames(StopBits::typeid))
            {
                Console::WriteLine("   {0}", s);
            }
    
            Console::Write("Enter StopBits value (None is not supported and \n" +
                "raises an ArgumentOutOfRangeException. \n (Default: {0}):", defaultPortStopBits.ToString());
            stopBits = Console::ReadLine();
    
            if (stopBits == "")
            {
                stopBits = defaultPortStopBits.ToString();
            }
    
            return (StopBits)Enum::Parse(StopBits::typeid, stopBits);
        }
    
        static Handshake SetPortHandshake(Handshake defaultPortHandshake)
        {
            String^ handshake;
    
            Console::WriteLine("Available Handshake options:");
            for each (String^ s in Enum::GetNames(Handshake::typeid))
            {
                Console::WriteLine("   {0}", s);
            }
    
            Console::Write("Enter Handshake value (Default: {0}):", defaultPortHandshake.ToString());
            handshake = Console::ReadLine();
    
            if (handshake == "")
            {
                handshake = defaultPortHandshake.ToString();
            }
    
            return (Handshake)Enum::Parse(Handshake::typeid, handshake);
        }
    };
    
    int main()
    {
        PortChat::Main();
    }


    在vs(我使用的是vs2012)建立控制台应用后,把上述代码复制到项目中,会提示有错误:



    解决方案:

    在项目上右击,点击属性中公共语言运行时支持下拉菜单中选择公共语言运行时支持(/clr),如下图


    然后就可以运行了。


    展开全文
  • C# SerialPort():

    2019-04-02 17:03:51
    SerialPort(): //属性 .BaudRate;获取或设置波特率 .BytesToRead;得到 接收到数据的字节数 .BytesToWrites;得到送往串口的字节数 .DataBits;获取或设置数据位 .IsOpen;获取一个值,判断串口是否打开 .Pariy;...
  • Serialport_VS2019.rar

    2020-07-30 23:33:12
    采用C Sharp(C#)自带的SerialPort控件编写的串口调试器源代码,含SerialPort控件的属性、方法、事件等使用指南,原创代码,开发平台Visual studio2019。
  • C#串口通信 SerialPort

    万次阅读 多人点赞 2018-07-05 09:53:03
    因为公司项目需要将USB扫码枪改为串口扫码枪,串口扫码的好处在于不需要一个输入框来接受USB扫出来的文本,能解决多个扫码枪一起扫码时的并发问题,所以需要用到多线程及串口技术。一、串口通信简介串行接口(串口)...
  • C# 串口类SerialPort的使用方法

    千次阅读 2018-08-25 00:09:38
    序言:最近做了一个智能体育项目——跆拳道积分系统,硬件部分会向软件传入振动值等数据,链接方式为串口,所以用到SerialPort类。 值得注意的是:  DataReceived 方法,当串口缓冲区有数据时执行该方法。  ...
  • SerialPort 串口编程知识整理(一)

    万次阅读 2010-04-23 10:01:00
    1、基本概念 MS在 .NET FrameWork2.0中对串口通讯进行了封装,我们可以在.net2.0及以上版本开发时直接使用SerialPort类对串口进行读写操作。SerialPort类的属性主要包括:串口名称(PortName)波特率(BaudRate)...
  • serialPort

    千次阅读 2008-08-07 14:42:00
    //<![CDATA[var theForm = document.forms[aspnetForm];if (!theForm) { theForm = document.aspnetForm;}function __doPostBack(eventTarget, eventArgument) { if (!theForm.onsubmi
  • SerialPort

    2019-06-24 11:45:06
    using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.IO.Ports...
  • Nodejs Serialport文档翻译

    千次阅读 2017-09-21 16:40:05
    那个世界就是这儿,现在使用node serialport。它提供一个非常简单的接口所需要的串口程序代码Arduino 单片机, X10 无线通信模块, 或者甚至是上升到 Z-Wave 和Zigbee . 在这个物理世界,你可以随心所欲(The ...
  • c# serialport sample(1)

    万次下载 热门讨论 2020-07-30 23:31:08
    http://blog.csdn.net/wuyazhe/archive/2010/05/17/5598945.aspx 博客文章的配套代码。希望能帮助到你。
  • 串口通信类SerialPort

    千次下载 热门讨论 2020-07-29 14:21:03
    从网上搜集的各种串口通信类,源代码库和Demo代码,赋有下载连接说明。
  • C# SerialPort 串口读写

    万次阅读 2016-10-16 22:42:21
    串口发送接收数据,支持大量数据交互
  • 利用SerialPort类实现收发短信(C# 2.0)

    万次阅读 热门讨论 2006-06-22 13:26:00
    作者:veryhappy(wx.net) 在.NET 1.1版本中微软并没有封装一个串口操作的类,但是我们可以在网络上找到通过WIN32 API读写文件方式访问串口的开源类库,比如:JustinIO。但是最近笔者在写一个短信猫池(支持8块SIM,...
  • 串口通信serialport

    千次阅读 2013-08-28 17:51:21
    private void button1_Click(object sender, EventArgs e)   {   serialPort1.PortName = "COM1";   serialPort1.BaudRate = 9600;   serialPort1.Open();   byte[] data = Encoding.
  • RXTX简介 RXTX是一个提供串口和并口通信的开源java类库,由该项目发布的文件均遵循LGPL协议。 RXTX项目提供了Windows,Linux,Mac os X,Solaris操作系统下的兼容javax.comm串口通讯包API的实现,为其他开发人员在此类...
  • 最全的基于c++的serialport.cpp与serialport.h类文件(解析版) 备注 参考原文件为:serialport.cpp与serialport.h类文件源代码 作者:c344935 链接:https://blog.csdn.net/c344935/article/details/81133308 ...
1 2 3 4 5 ... 20
收藏数 11,150
精华内容 4,460
关键字:

serialport