Обработка данных с COM порта без использования Sleep

        private void DataReceivedHandler(object sender,SerialDataReceivedEventArgs e) //Скан текста на COM порте
        {
            READ = serialPort.ReadLine();
        }

// Для порта
private const int _BaudRate = 57600;
private const int _ReadTimeout = 2000;
private const int _WriteBufferSize = 2048;
private const bool _RtsEnable = true;
private const int _DataBits = 8;
 
// Буфер и его размер для чтения данных из порта
private int _Size = 399;
private byte[] _TmpBuffer = new byte[400];
 
// Текущий порт
private SerialPort _CurentPort;
 
// Завершение чтения пакета
public event EventHandler EndOfReading;
 
// Читаем наиболее актуальные данные из буфера СОМ порта
        private void ReadData()
        {
            try
            {
                _TmpBuffer = new byte[256];
                int size = _CurentPort.Read(_TmpBuffer, 0, 256/*4096*/);
 
                // Вначале оттделим команды и сохраним их в списке команд CommandList,
                // в данном списке команда с одним кодом будет в единственном экземляре
                // таким образом команда с конкретным кодом будет являться последней пришедшей с устройства, т.е. актуальной
                for (int i = 0; i < size; ++i)
                {
                    // Пытаемся поймать ответы на наши действия
                    if (i < _TmpBuffer.Length - 16)
                    {
                        if (_TmpBuffer[i] == 0xff && _TmpBuffer[i + 1] == 0xff && _TmpBuffer[i + 2] == 0x63 && _TmpBuffer[i + 4] != 0)
                        {
                            ReturnPost[0] = 0xff;
                            ReturnPost[1] = 0xff;
                            ReturnPost[2] = _TmpBuffer[i + 4];
                            ReturnPost[3] = _TmpBuffer[i + 5];
                            ReturnPost[4] = _TmpBuffer[i + 6];
                            ReturnPost[5] = _TmpBuffer[i + 7];
                            ReturnPost[6] = _TmpBuffer[i + 8];
                            ReturnPost[7] = _TmpBuffer[i + 9];
                            ReturnPost[8] = _TmpBuffer[i + 10];
                            ReturnPost[9] = _TmpBuffer[i + 11];
                            ReturnPost[10] = _TmpBuffer[i + 12];
                            ReturnPost[11] = _TmpBuffer[i + 13];
                        }
 
                        if (_TmpBuffer[i] == 0xff && _TmpBuffer[i + 1] == 0xff && _TmpBuffer[i + 2] == 0x64 && _TmpBuffer[i + 4] != 0)
                        {
                            ReturnPost[12] = _TmpBuffer[i + 4];
                            ReturnPost[13] = _TmpBuffer[i + 5];
                            ReturnPost[14] = _TmpBuffer[i + 6];
                            ReturnPost[15] = _TmpBuffer[i + 7];
                            ReturnPost[16] = _TmpBuffer[i + 8];
                            ReturnPost[17] = _TmpBuffer[i + 9];
 
                            // Событие отклик на наши действия
                            if (ResponseOnComand != null) ResponseOnComand(this, ReturnPost);
                        }
                    }
 
                    // Получен маркер нового пакета данных в то время как предыдущий пакет не был дополучен 
                    // (обеспечивается условием DataBufferSize > 1)
                    if (_TmpBuffer[i] == 0xff && DataBufferSize > 1 && DataBuffer[DataBufferSize - 1] == 0xff)
                    {
                        // Обнулим буффер данных от устройства
                        DataBuffer[0] = 0xff;
                        DataBufferSize = 1;
                    }
 
                    DataBuffer[DataBufferSize] = _TmpBuffer[i];
                    ++DataBufferSize;
 
                    // Пакеты данных всегда по MAX_DATA_SIZE байт
                    if (DataBufferSize >= MAX_DATA_SIZE)
                    {
                        AddCommand(DataBuffer, DataBufferSize);
 
                        // После разбора данных обнулим буффер
                        DataBufferSize = 0;
                    }
                }
 
                // После получения всех команд обработаем  все данные пришедшие в _актуальных_ командах
                IEnumerator<KeyValuePair<byte, byte[]>> enumerator = CommandList.GetEnumerator();
 
                while (enumerator.MoveNext())
                {
                    KeyValuePair<byte, byte[]> item = enumerator.Current;
                    ParseData(item.Value, item.Value.Length);
 
                    // Событие окончания
                    if (EndOfReading != null) EndOfReading(this, EventArgs.Empty);
                }
                enumerator = null;
                CommandList.Clear();
            }
            catch (Exception)
            {
                _On = false;
            }
        }

/// <summary>
/// Отправка/приём данных через SerialPort.
/// </summary>
/// <param name="connection">SerialPort, используемый для связи.</param>
/// <param name="sendBuffer">Массив отправляемых байт.</param>
/// <param name="waitingForStart">Время ожидания от отправки до начала ответа.</param>
/// <param name="waitForEnd">Время ожидания после завершения ответа.</param>
/// <param name="cancellationToken">Токен отмены.</param>
/// <param name="recvBuffer">Массив буфера для приёма байт.</param>
/// <param name="received">Количество принятых байт.</param>
/// <returns>Получен ли какой-нибудь ответ.</returns>
public bool SendRecv(SerialPort connection, byte[] sendBuffer, int waitingForStart, int waitForEnd, CancellationToken cancellationToken, ref byte[] recvBuffer, out int received)
{
    bool result = false;
    received = -1;
 
    try
    {
        // Порт должен быть открыт.
        if (connection.IsOpen)
        {
            // Сброс буферов.
            connection.DiscardInBuffer();
            connection.DiscardOutBuffer();
 
            if (connection.BytesToRead > 0)
            {
                connection.ReadExisting();
            }
 
            // Установка таймаута начала ответа.
            connection.ReadTimeout = waitingForStart;
 
            // Отправка данных.
            connection.Write(sendBuffer, 0, sendBuffer.Length);
 
            int readed = 0;
 
            try
            {
                // Ожидание первого байта. Если ничего не придёт за waitingForStart мс, то вылетит TimeoutException.
                recvBuffer[readed++] = Convert.ToByte(connection.ReadByte());
 
                // Установка таймаута для определения завершения ответа.
                connection.ReadTimeout = waitForEnd;
 
                try
                {
                    // Временный буфер для приёма частями.
                    byte[] temp = new byte[16];
 
                    do
                    {
                        // Чтение и заполнение буфера.
                        // Если ничего не принято, то вылетит TimeoutException.
                        // Если считано меньше или равно размеру буфера, это число возвращается функцией.
                        int b = connection.Read(temp, 0, 16);
 
                        // Копирование в выходной буфер.
                        for (int i = 0; i < b; i++)
                        {
                            recvBuffer[readed++] = temp[i];
                        }
 
                        // Повтор до явной отмены.
                        // Также, выход доступен по таймауту чтения.
                    } while (!cancellationToken.IsCancellationRequested);
                }
                catch (TimeoutException)
                {
                }
                finally
                {
                    // Количество считанного.
                    received = readed;
                    // Возвращаемый результат: принято ли что-нибудь.
                    result = readed > 0;
                }
            }
            catch (TimeoutException)
            {
            }
        }
    }
    catch
    {
        result = false;
    }
 
    return result;
}

        void myComPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {           
            SerialPort myPort = (SerialPort)sender;
            int needBytes = myPort.BytesToRead;     // определяем количество ожидаемых байт
            if (needBytes <= 0)
                return;
            byte[] newData = new byte[needBytes];   // выделяем буфер под полученные байты
            int readBytes = 0;
            while (readBytes != needBytes) // пока количество прочитанных байт не сравняется с количеством ожидаемых...
            {
                changeSignalEvent(Signals.RX, true); // зажигаем индикатор RX
                Thread.Sleep(30); // здесь слип нужен только для того, чтобы в интерфейсе мигание индикатора было заметно
                // считываем данные из порта в массив newData
                // начиная с позиции readBytes
                // количество читаемых байт needBytes - readBytes (количество ожидаемых минус количество считанных)
                // количество считанных данным методом байт прибавляем к readBytes
                readBytes += myPort.Read(newData, readBytes, needBytes - readBytes);
            }
            changeSignalEvent(Signals.RX, false); // гасим индикатор RX
            bool isNullData = true;
            for (int i = 0; i < needBytes; i++)
            {
                if (newData[i] != 0) // обходим багу, когда вместо ответа одни нули
                {
                    isNullData = false;
                    break;
                }
            }
            if (isNullData)
            {
                newDataEvent(MdbResult.EMPTY, inData.ToArray());
                timeout.Stop();
                return;
            }
            inData.AddRange(newData); // прибавляем полученные байты к общему буферу ответа          
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.ComponentModel;
using System.IO.Ports;
 
using sqlitedb.Models;
                          
namespace MON08_Code_Searcher {
    /// <summary>
    /// Класс-генератор для перебора всех кодов, предоставленных алгоритмом поиска
    /// </summary>
    public class CodeGenerator : BackgroundWorker {
 
        SerialPort _port = null; //Поле последовательного порта
        IAlgorithm _algo = null; //Поле алгоритма поиска
        uint _pause = 0;         //Поле задержки между запросами
        TargetModel _target;      //Тип устройства
        public string CurrentCode { get; private set; }  //Автосвойство, текущий код 
 
        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="algorythm">Алгоритм поиска</param>
        /// <param name="target">Модель выбранного мк</param>
        /// <param name="portName">Номер последовательного порта</param>
        /// <param name="baudRate">Скорость последовательного порта</param>
        public CodeGenerator(IAlgorithm algorythm, TargetModel target, string portName, int baudRate) {
            _port = new SerialPort {
                PortName = portName,
                BaudRate = baudRate
            };
            _algo = algorythm;
            _pause = target.Pause;
            _target = target;
 
            this.WorkerReportsProgress = true;
            this.WorkerSupportsCancellation = true;
        }
 
        /// <summary>
        /// Переопределенный метод OnDoWork()
        /// </summary>
        /// <param name="e"></param>
        protected override void OnDoWork(DoWorkEventArgs e) {
            using (_port) {
                _port.Open();
                StartSearch(e);
            }
        }
 
        /// <summary>
        /// Основной метод поиска кода
        /// </summary>
        /// <param name="e"></param>
        void StartSearch(DoWorkEventArgs e) {
            //Событие старта поиска, с общим размером текущего диапазона
            this.ReportProgress(0, ProgressState.START);
            //Цикл поиска
            while (_algo.NextResult()) {
                //Проверка признака отмены операции
                if (this.CancellationPending) {
                    e.Cancel = true;
                    //Событие отмены операции поиска
                    this.ReportProgress(0, ProgressState.CANCELED);
                    return;
                }
 
                //Массив байт кода запроса
                byte[] code = Convert(_algo.Current);
                //Установка текущего кода из диапазона
                CurrentCode = _algo.Current.ToString();
 
                //Событие шага прогресса
                this.ReportProgress(0, ProgressState.STEP);
 
                //Включение DTR порта
                _port.DtrEnable = true;
 
                //Векторный запрос
                if (SendVectorAsc(code)) {
                    //Адресный запрос
                    if (SendAddressAsc(code)) {
                        e.Result = true;
                        return;
                    }
                }
                //Отключение DTR порта
                _port.DtrEnable = false;
                //Задержка между запросами
                Thread.Sleep((int)_target.Pause);
            }
            //Событие окончания поиска
            e.Result = false;
            this.ReportProgress(0, ProgressState.END);
        }
 
        /// <summary>
        /// Векторный запрос
        /// </summary>
        /// <param name="vector">Вектор для запроса</param>
        /// <returns>Результат запроса</returns>
        bool SendVectorAsc(byte[] vector) {
            for (int i = 0; i < vector.Count(); i++) {
                int count = i != vector.Count() - 1 ? 2 : 3;
                ReadBlock(vector[i], count, null);
            }
            return true;
        }
        
        /// <summary>
        /// Адресный запрос
        /// </summary>
        /// <param name="vector">Вектор для адресного запроса</param>
        /// <returns>Результат запроса</returns>
        bool SendAddressAsc(byte[] vector) {
            byte readCommand = 0x4A;
            byte vectorAddress = 0xF6;
            List<byte> temp = new List<byte>();
 
            for (int i = 0; i < vector.Count(); i++) {
                ReadBlock(readCommand, 2, null);
                ReadBlock(0xFF, 2, null);
                ReadBlock((byte)(vectorAddress + i), 3, temp);
                if (temp[2] != vector[i]) {
                    return false;
                }
            }
            return true;
        }
 
        /// <summary>
        /// Метод записи/чтения блока данных из последовательного порта
        /// </summary>
        /// <param name="code">Блок данных для записи в порт</param>
        /// <param name="readCount">Количество байт читаемых из порта</param>
        /// <param name="temp">Маасив данных для считанных данных</param>
        void ReadBlock(byte code, int readCount, List<byte> temp) {
            for (int i = 0; i < 10; i++) {
                _port.DiscardInBuffer();
                _port.Write(new byte[] { code }, 0, 1);
                for (int j = 0; j < 10; j++) {
                    if (_port.BytesToRead == readCount) {
                        byte[] data = new byte[readCount];
                        _port.Read(data, 0, readCount);
                        if (temp != null) {
                            temp.Clear();
                            temp.AddRange(data);
                        }
                        return;
                    }
                    else {
                        Thread.Sleep(100);
                    }
                }
            }
            throw new TimeoutException("NO ANSWER FROM DEVICE");
        }
 
        /// <summary>
        /// Метод создания кода запроса (Vector >>> byte[])
        /// </summary>
        /// <param name="vector">Вектор запроса</param>
        /// <returns>Маасив байт для запроса</returns>
        byte[] Convert(Vector4 vector) {
            List<byte> temp = new List<byte>();
            for (int i = 0; i < vector.Count; i++) {
                temp.Add((byte)(vector[i] / 0x100));
                temp.Add((byte)(vector[i] & 0xFF));
            }
            return temp.ToArray();
        }
 
        /// <summary>
        /// Метод проверки корректности установленных диапазонов
        /// </summary>
        /// <param name="code">Массив ushort запроса в порт</param>
        /// <returns>Результат проверки корректности</returns>
        bool IsRangeCorrected(ushort[] code) {
            if (code.All((c) => c >= _target.Memory.Start & c <= _target.Memory.End)) {
                return true;
            }
            return false;
        }
    }
 
    /// <summary>
    /// Перечисление этапов прогресса оперции
    /// </summary>
    internal enum ProgressState {
        START,
        END,
        STEP,
        CANCELED
    } 
}