我向串口发送0xFF

结果是 0x3F。

所有其他字节都是正确的。

情况是这样的……

外部盒子将这些字节发送到 PC...

0xFF, 0x0D, 0x00, 0x30, 0x31, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53

C# 在缓冲区中产生这个...

0x3F, 0x0D, 0x00, 0x30, 0x31, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53

第一个字节缺少前两位。有人以前见过这个吗？

如果这里有一篇文章解释了正在发生的事情，更重要的是为什么，甚至最重要的是，如何修复它，请指给我看。谢谢。

这是代码；我希望我已经了解 StackOverFlow 系统；仍然是这个社区的新人，我的 C# 知识大约只有 1 或 2 个月。

 public static void OurBackGroundSerialPortReceiver(object sender, SerialDataReceivedEventArgs e )
    {
                                                                //// Item 1, tell the world, particularly the
                                                                //// chief dispatch routin, that we are receiving

        aUartSemaphoreThatTells.WhatTheUartBackgroundRxIsDoing = (int)aValueWhichIndicatesThat.theUARTisReceivingData;

        SerialPort CurrentPort = (SerialPort)sender; //// Int routine gave is this in the arguments

        int LastByteInUartBuffer = CurrentPort.ReadBufferSize;
        int TheLastByteTheBoxSent = CurrentPort.BytesToRead;
        string inputData = CurrentPort.ReadExisting(); //// This is a C# property method of ports

        int Dest;
        Dest = UartPlaceHolders.RxBufferLeader; //// Will index into buffer for Chief dispatch

        int Source; //// Will index into Uart buffer to fish it out
        Source = 0; //// therefore, we start at zero

        int TopEdge; //// We'll calculate this here once instead of in the loops below
        TopEdge = (int)TheSizeOf.OneSecondsWorthOfData; //// This will tell us when to wrap around


        if (Dest < UartPlaceHolders.RxBufferTrailer) //// Half the time we'll have wrap-around
        { //// If that's the case, then the trailer > the leader
            while (
                  (Dest < UartPlaceHolders.RxBufferTrailer) //// If we are wrapped, make sure we don't
                   && //// overtake either the trailer or
                   (Dest < TopEdge) //// go over the top edge
                   && //// At the same time, make sure that
                   (Source <= LastByteInUartBuffer) //// we don't fish out more than is there
                   )
            {
                UartData.TheImmediateSecondOfData[Dest] = (byte)inputData[Source]; //// Move bytes into buff for chief
                Dest = Dest + 1;
                Source = Source + 1;
            }

            if (Source >= LastByteInUartBuffer) //// Have we done all the bytes for this event ?            
            { //// Yes, therefore we will update the leader
                UartPlaceHolders.RxBufferLeader = Dest; //// This tells us where to start next time

                aUartSemaphoreThatTells.WhatTheUartBackgroundRxIsDoing = (int)aValueWhichIndicatesThat.WeHaveReceivedSomeData;

                return; //// and we are done
            }
                                                                //// // // Else no, more bytes so...
            else if (Dest >= TopEdge) //// Did we wrap around ?
            { //// Yes, so
                Dest = 0; //// wrap around to the start
                while ( //// Now we do the same thing again
                      Dest < UartPlaceHolders.RxBufferTrailer //// C# and windows keep buffers at 4K max, 
                      && //// so we will wrap only once
                      Source < LastByteInUartBuffer //// May not even need that other test
                      ) //// This will finish the rest of the bytes
                {
                    UartData.TheImmediateSecondOfData[Dest] = (byte)inputData[Source]; //// There they go
                    Dest = Dest + 1;
                    Source = Source + 1;
                }

                UartPlaceHolders.RxBufferLeader = Dest; //// This tells us where to start next time
                trở lại;
            }

            else //// Dest is neither <, >, nor =, we have logic error
            {
                ErrorFlags.SerialPortErrorDescription = (int)AnError.ExistsInTheSerialPortBufferPointers;
                trở lại;
            }

        }

        if (Dest >= UartPlaceHolders.RxBufferTrailer) //// Now, if the Trailer is ahead of the leader, here we go
        { //// If that's the case, then the trailer > the leader
            while (
                //(Dest < UartPlaceHolders.RxBufferTrailer) //// This is the first major difference twixt this time & previous...
                // && //// ...because This condition is defacto guarateed to be false now
                   (Dest < TopEdge) //// We still want to stop before we hit the top edge
                   && //// At the same time, make sure that we go past...
                   (Source < LastByteInUartBuffer) //// ...the last byte the Uart gave us
                   &&
                   (Source < TheLastByteTheBoxSent)
                   )
            {
                UartData.TheImmediateSecondOfData[Dest] = (byte)inputData[Source]; //// Move bytes into buff for chief
                Dest = Dest + 1;
                Source = Source + 1;
            }

            if (Source >= LastByteInUartBuffer) //// Have we done all the bytes for this event ?
            { //// Yes, therefore we will update the leader
                UartPlaceHolders.RxBufferLeader = Dest; //// This tells us where to start next time
                return; //// and we are done
            } //// // Else no, we have more bytes to move, so...
            else if (Dest >= TopEdge) //// Did we wrap around ?
            { //// Yes, so...
                Dest = 0; //// wrap around to the start
                while ( //// Now we do the same thing again
                      Dest < UartPlaceHolders.RxBufferTrailer //// C# and windows keep buffers at 4K max, 
                      && //// so we will wrap only once
                      Source < LastByteInUartBuffer
                      )
                {
                    UartData.TheImmediateSecondOfData[Dest] = (byte)inputData[Source];
                    Dest = Dest + 1;
                    Source = Source + 1;
                }

                UartPlaceHolders.RxBufferLeader = Dest; //// This tells us where to start next time

                aUartSemaphoreThatTells.WhatTheUartBackgroundRxIsDoing = (int)aValueWhichIndicatesThat.WeHaveReceivedSomeData;

                trở lại;
            }

            else //// Dest is neither <, >, nor =, we have logic error
            {
                ErrorFlags.SerialPortErrorDescription = (int)AnError.ExistsInTheSerialPortBufferPointers;
                trở lại;
            }

        }

    }

câu trả lời hay nhất

这里是找到答案的地方......

http://msdn.microsoft.com/en-us/library/system.io.ports.serialport.aspx

向下滚动到“阅读”，它将详细说明用于执行此操作的方法，可在此处找到...

http://msdn.microsoft.com/en-us/library/ms143549.aspx

这是暂时解决这个问题的代码(也许是好的)

        SerialPort CurrentPort = (SerialPort)sender; //// caller gave us this in the arguments

        int TheNumberOfBytes = CurrentPort.BytesToRead; // The system will tell us how large our array should be

        byte[] inputData = new byte[TheNumberOfBytes]; // Our array is not that large

        int WeReadThisMany = CurrentPort.Read(inputData, 0, TheNumberOfBytes); //// This is a C# property method of ports

希望我在这里的回答是正确的。

无论如何，此方法的最终结果是此方法读取真正的字节，作为字节，由另一端的任何内容发送到串行端口。

关于c# - 0xFF 变成 0x3F，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13980631/