高速シリアル受信の実装方法について

Question

前提

Windows10のUSB仮想シリアルドライバを利用してUSBフルスピード機器から測定データ受信をさせようとしています。
バルク転送で理論ボーは約2.1Mbps相当となります。
USB機器は停止要求か通信エラーが発生するまで連続で絶えずデータを送ってきます。

実装としては、

• C#のSerialPortクラスDatarecievedイベントを利用して、Serialポートバッファにデータが溜まったら通知を受けてアプリのバッファに格納する処理を行っています。
• system.Timers.Timerで100ms間隔でアプリバッファの内容を解釈させております。

現状受信イベントが遅れることがあり、Serialバッファが溢れる問題に直面しております。

実現したいこと

目標として3h程度は安定して受信したい。(現状0分～30分で問題発生)
-> 他の処理があっても、Serial受信->バッファへ格納を最優先に処理させたいです。

発生している問題・エラーメッセージ

受信イベント発生が遅れSerrialバッファが溢れて、取りこぼしが発生します。
バッファ満タンの状態になると、USB機器が送信を停止し、一定時間以内に解消されなければエラーを出して送信を止めてしまいます。
serialPort.ReadBufferSizeを大きくしても内部的にはサイズが変わらないようです。(usbser.sysの制約？)

現状は以下がわかっています。
① 受信イベント発生が遅れ、急に大きなデータがSerialバッファ溜まる。大抵この時点でバッファが溢れる。
②windowsの他の操作をすると処理が遅れる・・・気がする。(word等のソフト立ち上がる、フォーカスを変える)
③100msタイマーを切ると、イベントの遅れが少なくなり、溢れるまでの時間が長くなる・・・気がする。

問題発生時のログ
No.26449:受信イベント6,サイズ2294,前回からの経過時間7.247ms
スレッド6:バッファ格納時間0.041ms,格納サイズ2294
No.26450:受信イベント6,サイズ2046,前回からの経過時間6.5969ms
スレッド6:バッファ格納時間0.1644ms,格納サイズ2046
No.26451:受信イベント17,サイズ1984,前回からの経過時間6.2961ms
スレッド17:バッファ格納時間0.3198ms,格納サイズ1984
No.26452:受信イベント21,サイズ1612,前回からの経過時間5.16ms
スレッド21:バッファ格納時間0.0484ms,格納サイズ1612
No.26453:受信イベント6,サイズ12338,前回からの経過時間156.9381ms　

※↑ここで問題が発生。通信が終了する。通常の10倍以上時間がかり、理論ボーからするとバッファが溢れているようです。

該当のソースコード

現状GUIは受信開始、停止ボタンのみのため、受信とタイマー関係のみ抜粋しています。
(定義が見えないものはstaticで宣言しております。)

//form.cs
 
public form()
{
 // タイマ準備(100ms)
  timer1 = new System.Timers.Timer(time_interval); 
  this.timer1.Elapsed += (sender, e) => Timer1_Tick(sender, e)
}

private void Timer1_Tick(object sender, EventArgs e)
        {
            timer1.Stop();
            time_cnt += 1;
            if (timerThread != null && !timerThread.IsCompleted)
                return;
            timerThread = Task.Run(() =>
            {
                      // 解析
                       data_analysis();
           }
          timer1.Start();
      }

/* 動作開始*/
private void start_button_Click(object sender, EventArgs e)
{

 // USB機器へ送信要求
  usb_start();
  timer1.Start();
}
 

// com.cs

private void serialPort_DataReceivedobject sender, SerialDataReceivedEventArgs e)
        {
            // イベント停止(あってもなくても結果は変わらない模様)
           serialPort.DataReceived -= new SerialDataReceivedEventHandler(serialPort_DataReceived);
　　　　    lock (lockObject)
           {
            int id = 0;
            int worker = 0;
            int io = 0;

              // ポートチェック
              if (serialPort != null && serialPort.IsOpen)
              {
                SerialPort sp = (SerialPort)sender;
                id = System.Threading.Thread.CurrentThread.ManagedThreadId;

                try
                {
                    // バッファサイズ確認
                    int rs = sp.BytesToRead;
                    TimeSpan span = sw.Elapsed;
                    sw.Stop();
                    Console.WriteLine($"No.{cnt}:受信イベント{id},サイズ{rs},前回からの経過時間{span.TotalMilliseconds}ms");
                    sw.Restart();

       　　　　　　　// データがあれば処理
                    if (0 != rs)
                    {
　　　　　　　　　　　　　// 解析を考慮してパケットサイズで格納(あってもなくても結果は変わらない模様)
                        rs = (rs / Constants.PACKET_SIZE) * Constants.PACKET_SIZE;　//
                        
                         // バッファ格納(関数で飛ばさず、ここでSerialReadして読み捨てても結果は変わらない模様。)
                         set_buffer(ref rs); 
                        
                        //Console.WriteLine($"No.{cnt}:スレッド{id},終了:経過時間{span.TotalMilliseconds}ms");
                        cnt++;

                    }
                    else
                    {
                        Console.WriteLine("受信なしで抜けている");
                    }     
                }
                catch {
                    Console.WriteLine("異常発生")
　　　　　　　　　　　　}
              }
          }
　　　　   // イベント許可(あってもなくても結果は変わらない模様)
          serialPort.DataReceived += new SerialDataReceivedEventHandler(serialPort_DataReceived);
        }

// rec.cs
public void set_buffer(ref Int32 size)
{
  Int32 id;
  id = System.Threading.Thread.CurrentThread.ManagedThreadId;
  sw.Restart();
  // バッファ格納実体
  sp.Read(log_buffer, wp, size);
  wp += (Int32)size;
  if (wp >= max_index)
  {
      wp = 0;
  }
 TimeSpan span = sw.Elapsed;
 Console.WriteLine($"スレッド{id}:バッファ格納時間{span.TotalMilliseconds}ms,格納サイズ{size}");
}

試したこと

最小コードとして以下のみを実行しました。
発生までの時間は伸びた気がしますが、限定的な改善でした。

//form.cs

private void start_button_Click(object sender, EventArgs e)
{

 // USB機器へ送信要求
  usb_start();
  // タイマ動作なし
}

private void serialPort_DataReceivedobject sender, SerialDataReceivedEventArgs e)
        {
            int id = 0;
            int worker = 0;
            int io = 0;

       　  SerialPort sp = (SerialPort)sender;
            id = System.Threading.Thread.CurrentThread.ManagedThreadId;

             // バッファサイズ確認
             Int rs = sp.BytesToRead;
             TimeSpan span = sw.Elapsed;
             sw.Stop();
             Console.WriteLine($"No.{cnt}:受信イベント{id},サイズ{rs},前回からの経過時間{span.TotalMilliseconds}ms");
             sw.Restart();

       　　  // データがあれば処理
                    if (0 != rs)
                    {
　                        
                         // 読み捨て
                         sp.read(buf,0,rs); 
                        
                        Console.WriteLine($"No.{cnt}:スレッド{id},終了:経過時間{span.TotalMilliseconds}ms");
                        cnt++;

                    }
                    else{ }     

            return;
        }

補足情報（FW/ツールのバージョンなど）

VisualStudioExpress 2017
C#
ここにより詳細な情報を記載してください。

Comments

[ozwk]

GUIなしでコンソールで作るとどうなります?

[Zuishin]

読み出しルーチンをタイマー起動してロックしてるからじゃないんですか？

[KOZ6.0]

ハンドシェイクを有効にできないでしょうか？(Handshake プロパティを RequestToSend にする）
パフォーマンスは落ちてしまいますが、取りこぼしが起きるより良いと思います。

[dodox86]

最近は少ないかもしれませんが、USB/シリアル変換のチップ自体やそのサードパーティ製のデバイスドライバーの性能、出来が悪い場合があります。FTDI社製など有名どころのものでは問題無いと思いますが。

デバイスマネージャーで、該当デバイスの低レベルの設定ができるかもしれないので、覗いてみてください。

[dodox86]

> デバイスマネージャーで、該当デバイスの低レベルの設定ができるかもしれないので、覗いてみてください。

得体の知れないサードパーティ製USBシリアル変換アダプターではなく、デバイスマネージャーで確認してデバイスが正常に稼働しているのであれば先にコメントをいただいている皆さんのアドバイスのようにまず、ソフト（アプリ）側の問題解決を優先すべきではあります。

[KOZ6.0]

ググってたら面白い記事をみつけました。
【ググっても無駄！】WindowsのRS-232Cシリアル通信で受信データに欠落が発生する
https://gabekore.org/windows-rs232c-deficit-recv-data
アレコレやってダメなら、ここに書かれているようにハードウエアを交換するしかないでしょうね。

[pitagora]

説明が悪くて申し訳ございません。
シリアル変換器は介在しません。ネイティブUSB機器とPCUSBポートの接続です。
ドライバが仮想シリアルで、アプリ層からはシリアルとしてアクセスしています。
(PCまで完全にUSB接続。FTDIのようなICはいません。)

[dodox86]

USBデバイスのネイティブのバルク転送を使っているということですか。そうであると事情はちょっと特殊で、シリアル通信として一般的なRS-232Cでの通信の話にはならないので、ソフトだけの問題ではなさそうです。ハード側（USBデバイス側）の仕様を意識しつつ、問題に触れないよう、注意深くソフトを作るしかなさそうです。

[KOZ6.0]

matukeso さんの回答にあるように、受信専用スレッドを作るのがよさそうに思います。
SerialPort.BaseStream で Stream オブジェクトが取れるので、非同期メソッドを使って常に受信しつつバッファに格納するといいんじゃないでしょうか。

[pitagora]

ありがとうございます。
専用スレッド、BaseStreamあたりを調べてみます。
単純なEventで受信すると他の処理が重なった場合に遅れるのでしょうか。
組込みのベクタテーブルの優先順位同等の設定ができれば良いのかな？というイメージです。

[KOZ6.0]

>単純なEventで受信すると他の処理が重なった場合に遅れるのでしょうか。
通知をうけてから受信処理するのと、常に受信処理しているのとを比べると、後者のほうがおそらく速いのかなと思いますが、やってみないとわからないところではあります。
サンプルを書いてみたので確認してみてください。
読み取りバッファを２つ用意して、片方読み取りしている間に読み取り済みのバッファを処理するのがキモです。
SerialPort の設定や PACKET_SIZE が不明でしたので実際の値に修正してください。

Answer 1

USB 機器がフロー制御に対応していないと十分なスピードマージンがない限り取りこぼしを完全に防ぐことはできないでしょう。
https://blog.oino.li/posts/usbcdc/
またはアプリケーションレベルでパケットの再送やエラー訂正をおこなうことになりますが、こちらも機器側での対応が必要です。

Answer 2

処理を書いてみたんですがテスト環境がないのでテストできてません。
読み込みバッファを２つ用意して切り替えながら受信します。

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

class Program
{
    static void Main(string[] args) {
        SerialPort sp = new SerialPort();
        // SerialPort の設定を書く
        sp.PortName = "COM1";
        sp.Open();

        var th1 = new Thread(new ParameterizedThreadStart(ReadTask));
        th1.Priority = ThreadPriority.AboveNormal; // 優先度を少し上げる
        th1.Start(sp);

        var th2 = new Thread(new ParameterizedThreadStart(AnalizeTask));
        var signal = new ManualResetEvent(false);
        th2.Start(signal);

        Thread.Sleep(1000);
        Console.WriteLine("何かキーを押すと終了します。");
        Console.ReadKey();

        sp.Close();
        th1.Join();
        signal.Set();
        th2.Join();
    }

    class Constants
    {
        public const int PACKET_SIZE = 64; // パケット長？
        public const int BLOCK_SIZE = 10; // 一度に読むパケット数
        public const int READ_SIZE = PACKET_SIZE * BLOCK_SIZE; // 一度に読むバイト数

        public const int LOG_SIZE = 1024; // リングバッファに格納するパケットの数
        public const int ANALIZE_SLEEP = 100; // 解析処理の Sleep 間隔
        // SerialPort を Close したときに発生する IOException の HResult
        public const int APPLICATION_CANCEL = unchecked((int)0x800703e3);
    }

    static void ReadMain(SerialPort serialPort) {
        var stream = serialPort.BaseStream;
        var current = SwitchBuffer(null);
        // 1回目は同期
        var readedLength = stream.Read(current, 0, Constants.READ_SIZE);
        while (true) {
            // 2回目以降は非同期
            var buffer = SwitchBuffer(current);
            var task = stream.ReadAsync(buffer, 0, Constants.READ_SIZE);
            if (readedLength > 0) {
                // バッファに格納
                logBuffer.SetData(current, readedLength);
            }
            task.Wait();
            readedLength = task.Result;
            current = buffer;
        }
    }

    static byte[] buffer1 = new byte[Constants.READ_SIZE];
    static byte[] buffer2 = new byte[Constants.READ_SIZE];

    static byte[] SwitchBuffer(byte[] current) {
        if (ReferenceEquals(buffer1, current)) {
            return buffer2;
        } else {
            return buffer1;
        }
    }

    static void ReadTask(object obj) {
        Console.WriteLine("受信処理を開始しました。");
        SerialPort sp = (SerialPort)obj;
        try {
            ReadMain(sp);
        } catch (AggregateException aex) { 
            foreach (var ex in aex.InnerExceptions) {
                var ioex = ex as IOException;
                if (ioex != null && ioex.HResult == Constants.APPLICATION_CANCEL) {
                    return;
                } else {
                    Console.WriteLine(ex.Message);
                }
            }
            throw;
        } catch (IOException ioex) {
            if (ioex.HResult == Constants.APPLICATION_CANCEL) {
                return; 
            }
            Console.WriteLine(ioex.Message);
            throw;
        } finally {
            Console.WriteLine("受信処理を終了しました。");
        }
    }


    static void AnalizeTask(object obj) {
        Console.WriteLine("解析処理を開始しました。");
        WaitHandle waitHandle = (WaitHandle)obj;
        while (!waitHandle.WaitOne(Constants.ANALIZE_SLEEP)) {
            byte[] packet;
            while (logBuffer.GetData(Constants.PACKET_SIZE, out packet)) {
                // packet を処理
            }
        }
        Console.WriteLine("解析処理を終了しました。");
    }

    static RingBuffer logBuffer = new RingBuffer(Constants.PACKET_SIZE * Constants.LOG_SIZE);

    class RingBuffer
    {
        byte[] dataStore;
        int capacity;
        int top = 0;
        int bottom = 0;

        public RingBuffer(int capacity) {
            this.capacity = capacity;
            dataStore = new byte[capacity];
        }

        public int StoreLength {
            get {
                return bottom < top ? bottom + capacity - top : bottom - top;
            }
        }

        public void SetData(byte[] data, int length) {
            lock (this) {
                if (length + StoreLength > capacity) {
                    throw new InternalBufferOverflowException();
                }
                if (bottom + length > capacity) {
                    int copyLength = capacity - bottom;
                    if (copyLength > 0) {
                        Array.Copy(data, 0, dataStore, bottom, copyLength);
                    }
                    bottom = length - copyLength;
                    Array.Copy(data, copyLength, dataStore, 0, bottom);
                } else {
                    Array.Copy(data, 0, dataStore, bottom, length);
                    bottom += length;
                }
            }
        }

        public bool GetData(int length, out byte[] data) {
            lock (this) {
                if (length > StoreLength) {
                    data = null;
                    return false;
                }
                data = new byte[length];
                if (top + length > capacity) {
                    int copyLength = capacity - top;
                    if (copyLength > 0) {
                        Array.Copy(dataStore, top, data, 0, copyLength);
                    }
                    top = length - copyLength;
                    Array.Copy(dataStore, 0, data, copyLength, top);
                } else {
                    Array.Copy(dataStore, top, data, 0, length);
                    top += length;
                }
                return true;
            }
        }
    }
}

Comments

[pitagora]

ありがとうございます。
元々リングバッファを構成していたので既存コードには簡単に繋がりました。
しかし、すぐにバッファオーバーとなり送信側が止めています。
Constants.READ_SIZE=1984なのですが、
var task = stream.ReadAsync(buffer, 0, Constants.READ_SIZE);
この結果は1984となるのでしょうか？(現状1,124,1984,372とまばらです。)

[KOZ6.0]

>元々リングバッファを構成していたので既存コードには簡単に繋がりました。
ってことは、このコードにコマンド送信の部分をつけて動かしたのでなく、元のプログラムに手を加えたわけですね？
手を加えた状態のコードがわからないので何とも言えないです。
戻り値については、まばらになるかもしれません。

[KOZ6.0]

ところで、1984 という数字の根拠は？
大きくしても効果ないでしょうか？

[KOZ6.0]

このコードにコマンド送信の部分をつけて動かすことはできないですか？
元のコードは見えないところが多いので他に原因があったとしても把握できません。

[pitagora]

>>ところで、1984 という数字の根拠は？
>>大きくしても効果ないでしょうか？

1フレーム62バイト(エンドポイント64バイトに対して余裕がある模様)の定数倍です。
最小の62バイトでは即止まったので、大きくしていって今に至ります。
解析スレッドは開始せず、受信スレッドのみ回し、アプリバッファへの転送もしない以下のコードを走らせてみました。その他タイマー等一切動かしていません。

``` C#
private void stream_read(SerialPort serialPort)
{
TimeSpan span;
var stream = serialPort.BaseStream;
var current = SwitchBuffer(null);
var readLength = stream.Read(current, 0, Constants.REC_PACKET_SIZE);
Console.WriteLine($"1回目は同期受信{readLength}");
rec_buffer_size += readLength;// 総受信データ数(クラス変数)
while(true)
{
#if DEBUG
sw.Restart();
Console.WriteLine($"スレッド{System.Threading.Thread.CurrentThread.ManagedThreadId}:非同期受信開始");
#endif
var burst_buf = SwitchBuffer(current);
var task = stream.ReadAsync(burst_buf, 0, Constants.REC_PACKET_SIZE);
if(readLength > 0)
{
#if DEBUG
Console.WriteLine($"ポートバッファ残量{serialPort.BytesToRead}");
#endif
}

task.Wait();
readLength = task.Result;//非同期受信結果
#if DEBUG
sw.Stop();
span = sw.Elapsed;
Console.WriteLine($"スレッド{System.Threading.Thread.CurrentThread.ManagedThreadId}:受信終了経過時間{span.TotalMilliseconds},受信サイズ{readLength}");
#endif
rec_buffer_size += readLength;
current = burst_buf;

}
}
```

```C#
// 受信開始
private void start_button_Click(object sender, EventArgs e)
{
Thread rec_th = new Thread( new ThreadStart(test));
rec_th.Priority = ThreadPriority.Highest;
var th_analize = new Thread(new ParameterizedThreadStart(Analize_task));
var signal = new ManualResetEvent(false);
var th_read = new Thread(new ParameterizedThreadStart(Read_task));
th_read.Priority = ThreadPriority.Highest;
th_read.Start(sp_inst);
Console.WriteLine("データ要求コマンド->0x01送信");
Ctrl.Set_logger_start();
//th_analize.Start(signal);
}
```

* Consoleログ
データ要求コマンド->0x01送信
1回目は同期受信1
スレッド12:非同期受信開始
ポートバッファ残量62
スレッド12:受信終了経過時間0.4659,受信サイズ185
スレッド12:非同期受信開始
ポートバッファ残量0
スレッド12:受信終了経過時間0.624,受信サイズ186
スレッド12:非同期受信開始
ポートバッファ残量62
スレッド12:受信終了経過時間0.1062,受信サイズ124
スレッド12:非同期受信開始
ポートバッファ残量0
スレッド12:受信終了経過時間0.0855,受信サイズ62
スレッド12:非同期受信開始
ポートバッファ残量0
スレッド12:受信終了経過時間0.085,受信サイズ62
スレッド12:非同期受信開始
ポートバッファ残量0
スレッド12:受信終了経過時間0.3001,受信サイズ1
スレッド12:非同期受信開始
ポートバッファ残量0
～　何回か経過　～
ポートバッファ残量61
スレッド12:受信終了経過時間0.1272,受信サイズ1
スレッド12:非同期受信開始
ポートバッファ残量0
スレッド12:受信終了経過時間79.381,受信サイズ61
スレッド12:非同期受信開始
ポートバッファ残量10354
スレッド12:受信終了経過時間0.0984,受信サイズ1984
スレッド12:非同期受信開始
ポートバッファ残量8370
～　数回受信し、データが来なくなったので停止　～
ログ停止
total_read_size = 23372Byte

* Wiresharkログ
95 0.000668 1.13.1 host USB 89 URB_BULK in (受信開始)
97 0.000105 1.13.1 host USB 89 URB_BULK in
99 0.000143 1.13.1 host USB 89 URB_BULK in
～　総計377回受信 ～
PC自身は遅れても最大0.250msで受信している模様です。
ペイロード62Byteなので総受信データは23,374Byteとなり、アプリで受信した数と合致します。
つまり、USB->アプリ間の取りこぼしはなし。
アプリ側で非同期受信完了に79msかかっている箇所でUSBポートがパンク、デバイス側が送信停止するという流れになります。

[pitagora]

イベントで行っていた時と同じく次の受信が安定に実施できていないような感じです。
※コメントでマークダウンを使う方法がわからなくてコード部が見にくくなっています。申し訳ございません。

追記:
上手くパターン？？にはまったら以下の繰り返しで30分ぐらい動きました。(何故かメモリ消費が肥大してましたが。)
スレッド15:受信終了経過時間0.0483,受信サイズ61
スレッド15:非同期受信開始
ポートバッファ残量0
スレッド15:受信終了経過時間0.1693,受信サイズ1
スレッド15:非同期受信開始
ポートバッファ残量0
スレッド15:受信終了経過時間0.1008,受信サイズ61
スレッド15:非同期受信開始
ポートバッファ残量0

>>このコードにコマンド送信の部分をつけて動かすことはできないですか？
その実装になっているつもりですが、新たなプロジェクト起こして試してみます。
(現状、元々宣言していたタイマー等はそのまま存在してます。startしていないだけだと影響ありますかね)

[KOZ6.0]

コメントでは MarkDown は使えません。質問を編集して追記すれば良いと思います。
現状、受信が追いつかなくて困っているのですから、ログ出力は最小限にしてください。
３点ほど気になったので挙げておきます。

(1) Console にログを出力
Console出力は遅いので、ファイルに出力するようにしたほうが良いです。
var writer = new StreamWriter(@"c:\test\logger.log", true);
writer.WriteLine("test");
writer.Flush();
writer.BaseStream.SetLength(st.BaseStream.Position);
こんな感じで、WriteLine ～ BaseStream.SetLength までをひとつのメソッドとしておけば、StreamWriter を閉じなくても書いたものが失われることはありません。

(2) ログを出力する位置。
ReadAsync ～ Task.Wait の間なら影響は少ないですが、Task.Wait ～ 次の ReadAsync に入れるのは良くないです。
せっかくバッファ切り替えして、常に読み取り要求を実行している状態を保とうとしているのに意味がなくなってしまいます。

(3) serialPort.BytesToRead
このメソッドは、ClearCommError API を呼び出して、通信デバイスの現在の状態を確認するため、パフォーマンスに影響を及ぼす可能性があります。
極力避けてください。

[KOZ6.0]

SerialPort クラスではいろいろ処理が行われていますので、どうしても処理が追いつかない場合は、API を直に呼び出のもひとつの手かと思います。
その場合、SerialPort の実装部分は SerialStream クラスに集約されていますので、参考にすると良いでしょう。
「SerialStream.cs」
https://referencesource.microsoft.com/#System/sys/system/io/ports/SerialStream.cs,b120632fda7c01ba

他には、LibUsbDotNet なんてのもあるようです。
「LibUsbDotNet」
https://www.nuget.org/packages/LibUsbDotNet/3.0.97-alpha
LibUsbDotNetを使ってUSB機器と通信するアプリケーションを作成する (C#プログラミング)
https://www.ipentec.com/document/libusbdotnet-app-create

[pitagora]

ご返信ありがとうございます。

>>(1) Console にログを出力
>>(2) ログを出力する位置
なるほど・・・表示でリソースを使うのも問題なんですね。
試しにConsole出力を全部切っても状況か変わらずでしたので、
今回の件では影響度は小さかったようですが注意したいと思います。

>>SerialPort クラスではいろいろ処理が行われていますので

提案いただいたAPIを直接操作するのも試してみようと思います。
(単純にwin32apiのラッパーになっているのならそんなに大変ではなさそう？)

ふと、試しにスレッド立てた後に一定時間ごとに同期受信で処理してもダメなのか？と思い試してみました。
結果としては3h程度問題なく動作するケースも出てきましたが、相変わらずコケる場合もあります。
(ご指摘頂きましたがそのままBytesToRead使っています。)
状況を整理したいのですが知識が足りず、何で成立するのか、デメリットは何かというのがわかっていません。
ご助言いただけましたら幸いです。

↓試したコード

// 発火
private void start_button_Click(object sender, EventArgs e)
{
Thread serial_th = new Thread( new ThreadStart(thead_serial_read));
serial_th.Priority = ThreadPriority.AboveNormal;
serial_th.start();
}

// スレッド内処理
void thread_serial_read()
{
Int32 size = 0;
while(true)
{
radLength = serialPort.BytesToRead();
if(readLength >= Constants.PACKET_SIZE)// 62Byte以上来たら
{
serialPort.Read(buffer,wp,readedLength);// 直接リングバッファに格納
}
Thread.Sleep(15); //理論上バッファ溢れない&GUIに返したい
　　　　　if(stop_button)
{
break;
}
}
}

[KOZ6.0]

試したパターンを整理し、ログ出力や StopWatch など余計な操作を外して同じ条件でテストしてみてはいかがでしょうか？
優先度を Hiest から AboveNormal にしてみたり、WireShark をつかって監視もしてるようなので、本当に同じ条件でテストした結果なのかわからないです。

[pitagora]

色々ありがとうございました。再度勉強していきます。

Answer 3

DataRecvedイベントに期待せず、専用スレッドとかで読み続けてみては？
Threadを使ってもいいし、

void ReadThreadProc(){
  while( SerialPort.IsOpen) {
   byte[] arr = new byte[1024];
   int readlen = SerialPort.BaseStream.Read( arr, 0, arr.Length );
    OnRead( arr, readlen);
 }
}

ReadAsyncとか使ってもいいし。

Task ReadAsync( byte[] buffer){
   return  SerialPort.BaseStream.ReadAsync(buffer, 0, buffer.Length).ContinueWith((Task<int> len) => OnRead(buffer, len.Result));
}
void OnRead(byte[] buffer, int len){
    if( len > 0){
      //なんか受信後処理をここに書く

      ReadAsync(buffer);  //受信処理が終わったので読み込み
    }
 }

//ダブルバッファリング
byte[] buffer1 = new byte[4096];
byte[] buffer2 = new byte[4096];
void start()
{
    ReadAsync(buffer1);
    ReadAsync(buffer2);
}

Comments

[pitagora]

ありがとうございます。
専用スレッドというのはTaskで起動できるようなものではなく、Threadを用いるようなものでしょうか。
読み続ける簡単なコード例があればありがたいです。

Answer 4

こういうことをするなら、受信バッファをもっと大きな値にしておいて、他の処理が走って受信処理ができない間のデータをバッファで貯めるようにする必要があります、が、あなたが目指しているリアルタイムの処理はできません

そもそも最初からムリなことをさせようとしてます。

Comments

[pitagora]

曖昧な表現にしか見えないのですが・・・具体的に説明していただけないでしょうか。