C#控制台串行端口读丢失数据

我试着用微软的C#运行串行通信。连接HC-06蓝牙模块，该模块与Arduino纳米板相连

问题是当在我的笔记本电脑上运行它时，它似乎丢失了很多数据，我不确定是什么导致了这个问题。然而，当我在我的桌面上运行它时，似乎一切都很好。台式机每秒在200个样本中仅丢失1或2个数据，而笔记本电脑上的数据丢失约为50~70个样本。（我确信这并不是因为我的实验中的Arduino部分在桌面上一遍又一遍地接收到上面提到的每秒200个样本的数据）

它能由我的CPU引起吗？ *笔记本电脑CPU:Core-I7-6700 *桌面CPU:Core-i7-7700

（我将一些代码添加到原始代码中，将数据写入文本文件） 以下是C#控制台代码：

using System;
using System.IO.Ports;
using System.Threading;

public class PortChat
{
    static bool _continue;
    static SerialPort _serialPort;
    static String myPath;
    public static void Main()
    {
        string name;
        string message;
        StringComparer stringComparer = StringComparer.OrdinalIgnoreCase;
        Thread readThread = new Thread(Read);

        myPath = Mypath();
        // Create a new SerialPort object with default settings.
        _serialPort = new 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();
    }

    public static void Read()
    {
        while (_continue)
        {
            try
            {
                string time = DateTime.Now.ToString("h:mm:ss.ffffff");
                string message = _serialPort.ReadLine();
                string data = time + "," + message.Trim();
                Console.WriteLine(data);
                WriteFile(Path, data);
            }
            catch (TimeoutException) { }
        }
    }

    public static String Mypath()
    {
        string Path;
        Console.WriteLine("-> Logging Data <-");
        Console.Write("-> Input File Name: ");
        Path = Console.ReadLine();

        if(Path == "")
        {
            Path = DateTime.Now.ToString("h:mm:ss.ffffff");
        }

        return Path + ".txt";
    }

    static void WriteFile(String Path, String Data)
    {
        if (!File.Exists(Path))
        {
            using (StreamWriter sw = File.CreateText(Path))
            {
                sw.WriteLine(Data);
            }
        }
        using (StreamWriter sw = File.AppendText(Path))
        {
            sw.WriteLine(Data);
        }
    }

    // Display Port values and prompt user to enter a port.
    public static string SetPortName(string defaultPortName)
    {
        string portName;

        Console.WriteLine("Available Ports:");
        foreach (string s in SerialPort.GetPortNames())
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter COM port value (Default: {0}): ", defaultPortName);
        portName = Console.ReadLine();

        if (portName == "" || !(portName.ToLower()).StartsWith("com"))
        {
            portName = defaultPortName;
        }
        return portName;
    }
    // Display BaudRate values and prompt user to enter a value.
    public static int SetPortBaudRate(int defaultPortBaudRate)
    {
        string baudRate;

        Console.Write("Baud Rate(default:{0}): ", defaultPortBaudRate);
        baudRate = Console.ReadLine();

        if (baudRate == "")
        {
            baudRate = defaultPortBaudRate.ToString();
        }

        return int.Parse(baudRate);
    }

    // Display PortParity values and prompt user to enter a value.
    public static Parity SetPortParity(Parity defaultPortParity)
    {
        string parity;

        Console.WriteLine("Available Parity options:");
        foreach (string s in Enum.GetNames(typeof(Parity)))
        {
            Console.WriteLine("   {0}", s);
        }

        Console.Write("Enter Parity value (Default: {0}):", defaultPortParity.ToString(), true);
        parity = Console.ReadLine();

        if (parity == "")
        {
            parity = defaultPortParity.ToString();
        }

        return (Parity)Enum.Parse(typeof(Parity), parity, true);
    }
    // Display DataBits values and prompt user to enter a value.
    public static int SetPortDataBits(int defaultPortDataBits)
    {
        string dataBits;

        Console.Write("Enter DataBits value (Default: {0}): ", defaultPortDataBits);
        dataBits = Console.ReadLine();

        if (dataBits == "")
        {
            dataBits = defaultPortDataBits.ToString();
        }

        return int.Parse(dataBits.ToUpperInvariant());
    }

    // Display StopBits values and prompt user to enter a value.
    public static StopBits SetPortStopBits(StopBits defaultPortStopBits)
    {
        string stopBits;

        Console.WriteLine("Available StopBits options:");
        foreach (string s in Enum.GetNames(typeof(StopBits)))
        {
            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(typeof(StopBits), stopBits, true);
    }
    public static Handshake SetPortHandshake(Handshake defaultPortHandshake)
    {
        string handshake;

        Console.WriteLine("Available Handshake options:");
        foreach (string s in Enum.GetNames(typeof(Handshake)))
        {
            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(typeof(Handshake), handshake, true);
    }
}

使用系统；
使用System.IO.Ports；
使用系统线程；
公共类端口聊天
{
静态布尔继续；
静态串行端口_SerialPort；
静态字符串myPath；
公共静态void Main（）
{
字符串名；
字符串消息；
StringComparer StringComparer=StringComparer.OrdinalIgnoreCase；
线程读取线程=新线程（已读取）；
myPath=myPath（）；
//使用默认设置创建新的SerialPort对象。
_serialPort=新的serialPort（）；
//允许用户设置适当的属性。
_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）；
//设置读/写超时
_serialPort.ReadTimeout=500；
_serialPort.WriteTimeout=500；
_serialPort.Open（）；
_继续=真；
readThread.Start（）；
控制台。写（“名称：”）；
name=Console.ReadLine（）；
Console.WriteLine（“键入QUIT以退出”）；
while（_continue）
{
message=Console.ReadLine（）；
if（stringComparer.Equals（“退出”，消息））
{
_continue=false；
}
其他的
{
_serialPort.WriteLine(
格式（“：{1}”，名称，消息））；
}
}
readThread.Join（）；
_serialPort.Close（）；
}
公共静态无效读取（）
{
while（_continue）
{
尝试
{
字符串时间=DateTime.Now.ToString（“h:mm:ss.ffffff”）；
字符串消息=_serialPort.ReadLine（）；
字符串数据=时间+”，“+消息.Trim（）；
控制台写入线（数据）；
写文件（路径、数据）；
}
捕获（TimeoutException）{}
}
}
公共静态字符串Mypath（）
{
字符串路径；
Console.WriteLine（“->日志数据输入文件名：”）；
Path=Console.ReadLine（）；
如果（路径==“”）
{
Path=DateTime.Now.ToString（“h:mm:ss.ffffff”）；
}
返回路径+“.txt”；
}
静态void WriteFile（字符串路径、字符串数据）
{
如果（！File.Exists（Path））
{
使用（StreamWriter sw=File.CreateText（路径））
{
软件写入线（数据）；
}
}
使用（StreamWriter sw=File.AppendText（路径））
{
软件写入线（数据）；
}
}
//显示端口值并提示用户输入端口。
公共静态字符串SetPortName（字符串defaultPortName）
{
字符串端口名；
Console.WriteLine（“可用端口：”）；
foreach（SerialPort.GetPortNames（）中的字符串s）
{
Console.WriteLine（“{0}”，s）；
}
Write（“输入COM端口值（默认值：{0}）：”，defaultPortName）；
portName=Console.ReadLine（）；
if（portName==“”| |！（portName.ToLower（））.StartsWith（“com”））
{
portName=defaultPortName；
}
返回端口名；
}
//显示波特率值并提示用户输入值。
公共静态int SetPortBaudRate（int defaultPortBaudRate）
{
字符串波特率；
Write（“波特率（默认值：{0}）：”，defaultPortBaudRate）；
波特率=Console.ReadLine（）；
如果（波特率==“”）
{
波特率=defaultPortBaudRate.ToString（）；
}
返回int.Parse（波特率）；
}
//显示端口奇偶校验值并提示用户输入值。
公共静态奇偶校验集端口奇偶校验（奇偶校验默认端口奇偶校验）
{
字符串奇偶校验；
Console.WriteLine（“可用奇偶校验选项：”）；
foreach（Enum.GetNames（typeof（奇偶校验））中的字符串s）
{
Console.WriteLine（“{0}”，s）；
}
Write（“输入奇偶校验值（默认值：{0}）：”，defaultPortParity.ToString（），true）；
奇偶校验=Console.ReadLine（）；
如果（奇偶校验==“”）
{
奇偶校验=defaultPortParity.ToString（）；
}
返回（奇偶校验）枚举解析（typeof（奇偶校验），奇偶校验，true）；
}
//显示其值并提示用户输入值。
公共静态int-SetPortDataBits（int-defaultPortDataBits）
{
字符串数据位；
Write（“输入数据位值（默认值：{0}）：”，defaultPortDataBits）；
dataBits=Console.ReadLine（）；
如果（数据位==“”）
{
dataBits=defaultPortDataBits.ToString（）；
}
返回int.Parse（dataBits.ToUpperInvariant（））；
}
//显示停止位值并提示用户输入值。
公共静态停止位SetPortStopBits（停止位defaultPortStopBits）
{
字符串停止位；
Console.WriteLine（“可用停止位选项：”）；
前面
#include <TimerOne.h>
#include <SoftwareSerial.h>
SoftwareSerial HC06(2, 3);

void setup() {
HC06.begin(115200);
Timer1.initialize(5000); // micro second
Timer1.attachInterrupt(printout);
Timer1.start();
}

void printout()
{
  HC06.println(data());
}

String data()
{
  int d1 = analogRead(A0);
  int d2 = analogRead(A1);
  String d = String(d1) +","+ String(d2);
  return d;  
}

void loop() 
{

}