c# - 0xFF 变成 0x3F

Question

我向串口发送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
                return;
            }

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

        }

        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;

                return;
            }

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

        }

    }

Answer 1

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

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

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

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