WinForms C# System.IO.Ports

[StarWars (Gast)]

Hallo und guten Morgen,

in einer WinForms C# Anwendung wird die Bibliothek "System.IO.Ports" 
verwendet serielle Daten von der UART eines Mikrocntrollers zu 
empfangen.
Für den Empfang von den seriellen Daten wird der Receive Hndler 
eingesetzt.

Der Mikrocontroller versendet zyklisch immer 10 Bytes. Der Empfang 
funktioniert nicht so stabil. Es kommen manchmal nur 2 Bytes an oder 5 
Bytes. Wenn ich das Hterm Tool benutzte sind alle Daten korrekt. WIe 
kann das sein.

private void Init_Click(object sender, EventArgs e)
{
  myPort = new SerialPort("COM2");

  myPort.BaudRate = 115200;
  myPort.Parity = Parity.None;
  myPort.StopBits = StopBits.One;
  myPort.DataBits = 8;
  myPort.Handshake = Handshake.None;
  myPort.ReadTimeout = 2000;

  myPort.Open();
  myPort.DataReceived += new SerialDataReceivedEventHandler(OnReceiveSerialData);
}

public void OnReceiveSerialData(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
  SerialPort sp = (SerialPort)sender;
  string indata = sp.ReadExisting();
  
  this.Invoke((MethodInvoker)delegate()
  {
    rtb_RecvData.Text += indata;
  });
}

[StarWars (Gast)]

Die Daten müssten eigentlich immer so angezeigt werden:
1012345678910

Wie kann es sein dass die Daten ab und zu so empfangen werden?

1012345678910
10123456
78910
1012345678910

[falscher Ansatz (Gast)]

Sobald der serial Port Daten empfängt, wird ein Interrupt erzeugt und Du 
liest sie aus. Ob die Daten dann schon vollständig sind, weißt Du zu dem 
Zeitpunkt nicht.

[StarWars (Gast)]

Ja und was kann ich da nun konkret tun?

WIe gesagt mit dem Hterm Tool funktioniert das ohne Probleme.

[abc (Gast)]

Einfach Bytes zählen

[Dirk K. (merciless)]

In der Doku

https://docs.microsoft.com/de-de/dotnet/api/system.io.ports.serialport?view=dotnet-plat-ext-6.0

erzeugen sie einen separaten Thread und lesen kontinuierlich.
Ausprobieren?

merciless

[Axel R. (axlr)]

sp.Readexisting  muss ja erstmal mit "to String" gewandelt werden, oder? 
So werden deine chars entsprechend der Nummerirung der Ascii-tabelle mit 
+= aufaddiert. Daher die unterschiedlich langen Zahlen, die du dort 
siehst. Was schickt der µC denn für Daten? "Hallo World"?

[Jim M. (turboj)]

StarWars schrieb:
> Wie kann es sein dass die Daten ab und zu so empfangen werden?
> 1012345678910
> 10123456
> 78910
> 1012345678910

Du hast einen USB2UART Chip dazwischen. Der fasst die Daten zu USB 
Paketen zusammen - aber er ist dumm und weiss nicht wo die Pakete 
anfangen und aufhören sollen.

Wenn dem µC beim Senden ein Interrupt dazwischen funkt, wird er die 10 
Bytes in 2 Pakete aufteilen, da ja für kuze zeit der UART Datenstrom 
unterbrochen ist.

Abhilfe: Auf PC Anwendungsseite nochmal vernünftig puffern und Daten neu 
zusammen setzen.

[blubb (Gast)]

Hier mal einen Code, mit dem ich einen LDM ausgelesen habe. Ist 
natürlich viel Overhead, aber das Prinzip ist klar.

using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Data;
using System.Linq;
using System.IO.Ports;

/// <summary>
/// Stellt Methoden und Funktionen zur Nutzung des optoNCDT ILR 1181 Laser-Distanzmesser bereit.
/// </summary>
namespace DriverExtension
{
    public class LaserDistanceMeter : IDisposable
    {
        // SerialPort _serialPort = new SerialPort();
        Measurement _measurement = new Measurement();
        optoNCDT _distanceMeter;

        bool _continuous = false;

        public event EventHandler<Measurement> PrecisionMeasurementCompleted;
        public event EventHandler<Measurement> SerialDataArrived;
        public event EventHandler<Measurement> SingeShotDataArrived;
        public event EventHandler<string> LaserDistanceMeterException;

        /// <summary>
        /// Standardkonstruktor
        /// </summary>
        public LaserDistanceMeter()
        {
            try
            {
                _distanceMeter = new optoNCDT();

                _distanceMeter.OnValueReceived += LDM_OnValueReceived;
                _distanceMeter.OnSeriesMeasurementCompleted += LDM_OnSeriesMeasurementCompleted;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Standardkonstruktor
        /// </summary>
        /// <param name="serialPortName">Erwartet den Namen eines gültigen COM-Port.</param>
        public LaserDistanceMeter(string serialPortName)
        {
            try
            {
                _distanceMeter = new optoNCDT(serialPortName);

                _distanceMeter.OnValueReceived += LDM_OnValueReceived;
                _distanceMeter.OnSeriesMeasurementCompleted += LDM_OnSeriesMeasurementCompleted;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Ereignis, das nach erfolgter Serienmessung aufgerufen wird.
        /// </summary>
        private void LDM_OnSeriesMeasurementCompleted()
        {
            if (PrecisionMeasurementCompleted != null)
                PrecisionMeasurementCompleted(this, _measurement);
        }

        /// <summary>
        /// Wird aufgerufen, wenn die serielle Schnittstelle Daten empfangen hat, die als Messwerte ausgewertet werden konnten.
        /// </summary>
        private void LDM_OnValueReceived()
        {
            ConcurrentQueue<optoNCDT.ComPortDataAnalyzer> buffer;
            optoNCDT.ComPortDataAnalyzer data;

            _distanceMeter.Queue(out buffer);

            while (buffer.TryDequeue(out data))
            {
                List<double> lstBuffer = data.Values;

                _measurement.Values.AddRange(lstBuffer);

                string err = _distanceMeter.GetErrorDescription;

                if (err != null)
                {
                    if (LaserDistanceMeterException != null)
                        LaserDistanceMeterException(this, err);
                }
                else
                {
                    if (_continuous)
                    {
                        if (SerialDataArrived != null)
                            SerialDataArrived(this, _measurement);
                    } else
                    {
                        if (SingeShotDataArrived != null)
                            SingeShotDataArrived(this, _measurement);
                    }
                }
            }
        }

        /// <summary>
        /// Führt eine Einzelmessung durch.
        /// Achtung: Die Messgenauigkeit ist stark eingeschränkt!
        /// </summary>
        public void SingleShot()
        {
            // Felder bereinigen
            Clear();

            // Einzelmessung
            _continuous = false;

            // Einzelmessung durchführen
            _distanceMeter.OneShot();
        }

        /// <summary>
        /// Löscht alle aktuell vorhandenen Messwerte
        /// </summary>
        public void Clear()
        {
            _measurement.Values.Clear();
        }

        /// <summary>
        /// Setzt den Offset des optoNCDT 1181 auf die aktuelle Position.
        /// </summary>
        public void Zeroize()
        {
            _distanceMeter.SetNull();
        }

        /// <summary>
        /// Startet eine einzelne Präzisionsmessung.
        /// </summary>
        public void StartPrecisionMeasurement()
        {
            this.Clear();
            _distanceMeter.EnableAutoStop(5);
            _distanceMeter.DistanceTracking();
        }

        /// <summary>
        /// Startet eine Intervallmessung.
        /// </summary>
        public void StartContinuousMeasurement()
        {
            _continuous = true;

            this.Clear();
            _distanceMeter.DistanceTracking();
        }

        /// <summary>
        /// Beendet eine Intervallmessung.
        /// </summary>
        public void StopContinuousMeasurement()
        {
            _continuous = false;

            this.Clear();
            _distanceMeter.Stop();
        }

        /// <summary>
        /// Schließt die Verbindung zum optoNCDT ILR 1181.
        /// </summary>
        public void Dispose()
        {
            _distanceMeter.Stop();
            _distanceMeter.Dispose();
        }
    }

    /// <summary>
    /// Hilfsobjekt zur einfachen Handhabung der Messdaten
    /// </summary>
    public class Measurement
    {
        List<double> _measuredValues = new List<double>();

        double _min, _max, _diff, _avg, _mdn;
        double _fmin, _fmax, _fdiff, _favg, _fmdn;

        /// <summary>
        /// Hält die Messwerte, die übergeben wurden.
        /// </summary>
        public List<double> Values { get { return _measuredValues; } set { _measuredValues = value; } }
        /// <summary>
        /// Gibt den Minimalwert alle Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double Min { get { Calc(); return _min; } set { _min = value; } }
        /// <summary>
        /// Gibt den Maximalwert alle Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double Max { get { Calc(); return _max; } set { _max = value; } }
        /// <summary>
        /// Gibt die Differenz zwischen <see cref="Max"/> und <see cref="Min"/> zurück.
        /// </summary>
        public double Diff { get { Calc(); return _diff; } set { _diff = value; } }
        /// <summary>
        /// Gibt den Mittelwert alle Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double Avg { get { Calc(); return _avg; } set { _avg = value; } }
        /// <summary>
        /// Gibt den Median alle Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double Mdn { get { Calc(); return _mdn; } set { _mdn = value; } }

        /// <summary>
        /// Gibt den Minimalwert der letzten zehn Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double FloatingMin { get { Calc(); return _fmin; } set { _fmin = value; } }
        /// <summary>
        /// Gibt den Maximalwert der letzten zehn Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double FloatingMax { get { Calc(); return _fmax; } set { _fmax = value; } }
        /// <summary>
        /// Gibt die Differenz zwischen <see cref="Max"/> und <see cref="Min"/> zurück.
        /// </summary>
        public double FloatingDiff { get { Calc(); return _fdiff; } set { _fdiff = value; } }
        /// <summary>
        /// Gibt den Mittelwert der letzten zehn Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double FloatingAvg { get { Calc(); return _favg; } set { _favg = value; } }
        /// <summary>
        /// Gibt den Median der letzten zehn Elemente von <see cref="Values"/> zurück.
        /// </summary>
        public double FloatingMdn { get { Calc(); return _fmdn; } set { _fmdn = value; } }

        /// <summary>
        /// Führt die Berechnungen der einzelnen Parameter durch.
        /// </summary>
        private void Calc()
        {
            if (_measuredValues.Count == 0)
                return;

            // Berechnung über alle Werte
            _min = _measuredValues.Min();
            _max = _measuredValues.Max();
            _diff = _max - _min;
            _avg = _measuredValues.Average();

            List<double> median = _measuredValues;

            _mdn = Median(median.ToArray());

            // Berechnung über die letzten 10 Werte
            int offset = 0;
            int count = 0;

            offset = _measuredValues.Count < 5 ? 0 : _measuredValues.Count - 5;
            count = _measuredValues.Count < 5 ? _measuredValues.Count : 5;

            List<double> buffer = _measuredValues.GetRange(offset, count);

            _fmin = buffer.Min();
            _fmax = buffer.Max();
            _fdiff = _fmax - _fmin;
            _avg = buffer.Average();

            List<double> floatingMedian = buffer;

            _fmdn = Median(floatingMedian.ToArray());
        }

        /// <summary>
        /// Berechnet den Median aus einem Array.
        /// </summary>
        /// <param name="xs"></param>
        /// <returns></returns>
        private double Median(double[] xs)
        {
            var ys = xs.OrderBy(x => x).ToList();
            double mid = (ys.Count - 1) / 2.0;
            return (ys[(int)(mid)] + ys[(int)(mid + 0.5)]) / 2;
        }
    }

    /// <summary>
    /// Diese Klasse regelt den Zugriff auf das optoNCDT ILR 1181.
    /// </summary>
    sealed class optoNCDT : IDisposable
    {
        #region Fields

        /// <summary>
        /// Instanz des ComPortDataAnalyzer-Objektes.
        /// </summary>
        ComPortDataAnalyzer _comPortDataAnalyzer = new ComPortDataAnalyzer();

        /// <summary>
        /// Threadsichere <see cref="ConcurrentQueue{T}"/> zur Übergabe der Daten zwischen Listener-, ausführendem, und UI-Thread.
        /// </summary>
        ConcurrentQueue<ComPortDataAnalyzer> _dataQueue = new ConcurrentQueue<ComPortDataAnalyzer>();

        /// <summary>
        /// Hält, ob die Messung automatisch beendet wird (Intervallmessung).
        /// </summary>
        private bool _autoStop = false;

        /// <summary>
        /// Gibt die Anzahl an Messwerten an, ab der eine Serienmessung beendet wird.
        /// </summary>
        private int _autoStopNumOfMeasurements;

        /// <summary>
        /// Messwertzähler
        /// </summary>
        private int _autoStopCounter = 0;

        /// <summary>
        /// Signalisiert das Ende eines Befehls.
        /// </summary>
        private string _endOfCommand = "\r";

        /// <summary>
        /// Gibt an, ob Daten empfangen wurden. Falls true, finden sich die Werte in <see cref="_comPortDataAnalyzer.Data"/>.
        /// </summary>
        private bool _dataReceived = false;

        /// <summary>
        /// Beinhaltet die dem Fehlercode entsprechende Fehlerbeschreibung des optoNCDT Laser-Entfernungsmesser.
        /// </summary>
        private string _errorDescription = null;

        /// <summary>
        /// Speichert das aktive <see cref="SerialPort"/>-Objekt.
        /// </summary>
        private SerialPort _serialPort;

        /// <summary>
        /// Hält, ob ein Port gefunden wurde, und damit aktiv bleiben soll.
        /// </summary>
        private bool _dontClosePort = false;

        /// <summary>
        /// Hält, ob es sich um den Initialisierungsvorgang handelt.
        /// </summary>
        private bool _isInit = true;
        #endregion

        #region Constructors

        /// <summary>
        /// Erstellt eine neue Instanz der <see cref="optoNCDT"/>-Klasse.
        /// </summary>
        /// <param name="serialPort">Erwartet einen gültigen Bezeichner für eine serielle Schnittstelle.</param>
        public optoNCDT(string serialPort)
        {
            _serialPort = new SerialPort();

            // Events bei Dateneingang feuern
            _serialPort.DataReceived += SerialPort_DataReceived;

            // COM-Port vorbereiten
            SetUpSerialPort();

            // Alle Ports durchlaufen
            _serialPort.PortName = serialPort;

            try
            {
                // Versuche den COM-Port zu öffnen
                _serialPort.Open();

                // Befehl "id" schreiben, um Type des Sensors zu ermitteln
                _serialPort.Write("id" + _endOfCommand);

                int delayBeforeTrigger = 4000;
                int timeElapsed = 0;
                bool timeOut = false;

                // Warten, bis Daten angekommen sind
                while (_dataReceived == false && timeOut == false)
                {
                    System.Threading.Thread.Sleep(delayBeforeTrigger / 100);

                    timeElapsed += delayBeforeTrigger / 100;

                    // Wenn mittlerweile Daten empfangen wurden -> abbrechen
                    if (_dataReceived) break;

                    // Timeout?
                    if (timeElapsed >= delayBeforeTrigger)
                        timeOut = true;
                }

                // Auf empfangene Daten prüfen
                if (_dataReceived)
                {
                    ComPortDataAnalyzer data;

                    _dataQueue.TryDequeue(out data);

                    // Auswerten, ob die Daten von dem Laser-Distanzmesser stammen
                    if (data.Data.Left(7) == "ILR1181" || IsErrorCode(data.Data))
                    {
                        // Ausgewählten Port nicht schließen
                        _dontClosePort = true;

                    }
                }

                // Auf timeout prüfen
                if (timeOut)
                {
                    throw new optoNCDTTimeoutException();
                }

                // Puffer leeren
                _dataReceived = false;

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                // Port nicht gefunden?
                if (_dontClosePort == false)
                {
                    // Falschen COM-Port schließen
                    _serialPort.Close();
                }
                else
                {
                    // Port gefunden -> Initialisierung fertig
                    _isInit = false;
                }
            }
        }

        /// <summary>
        /// Erstellt eine neue Instanz der <see cref="optoNCDT"/>-Klasse.
        /// </summary>
        public optoNCDT()
        {
            // Hält, ob der Port mit angeschlossenem LDM gefunden wurde
            bool portFoundSuccessfully = false;

            _serialPort = new SerialPort();

            // Events bei Dateneingang feuern
            _serialPort.DataReceived += SerialPort_DataReceived;

            // COM-Port vorbereiten
            SetUpSerialPort();

            foreach (string port in GetAvailableComPorts().OrderBy(x => x).ToList())
            {
                // Abbrechen?
                if (portFoundSuccessfully)
                    break;

                // Alle Ports durchlaufen
                _serialPort.PortName = port;

                try
                {
                    // Versuche den COM-Port zu öffnen
                    _serialPort.Open();

                    // Befehl "id" schreiben, um Type des Sensors zu ermitteln
                    _serialPort.Write("id" + _endOfCommand);

                    int delayBeforeTrigger = 4000;
                    int timeElapsed = 0;
                    bool timeOut = false;

                    // Warten, bis Daten angekommen sind
                    while (_dataReceived == false && timeOut == false)
                    {
                        System.Threading.Thread.Sleep(delayBeforeTrigger / 100);

                        timeElapsed += delayBeforeTrigger / 100;

                        // Wenn mittlerweile Daten empfangen wurden -> abbrechen
                        if (_dataReceived) break;

                        // Timeout?
                        if (timeElapsed >= delayBeforeTrigger)
                            timeOut = true;
                    }

                    // Auf empfangene Daten prüfen
                    if (_dataReceived)
                    {
                        ComPortDataAnalyzer data;

                        _dataQueue.TryDequeue(out data);

                        // Auswerten, ob die Daten von dem Laser-Distanzmesser stammen
                        if (data.Data.Left(7) == "ILR1181" || IsErrorCode(data.Data))
                        {
                            // Ausgewählten Port nicht schließen
                            _dontClosePort = true;

                            // Weitern Suchvorgang abbrechen
                            portFoundSuccessfully = true;
                        }
                    }

                    // Auf timeout prüfen
                    if (timeOut)
                    {
                        throw new optoNCDTTimeoutException();
                    }

                    // Puffer leeren
                    _dataReceived = false;

                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    // Port nicht gefunden?
                    if (_dontClosePort == false)
                    {
                        // Falschen COM-Port schließen
                        _serialPort.Close();
                    }
                    else
                    {
                        // Port gefunden -> Initialisierung fertig
                        _isInit = false;
                    }
                }
            }
        }
        #endregion

        #region Destructors

        /// <summary>
        /// Alle Verbindungen schließen und Daten verwerfen
        /// </summary>
        public void Dispose()
        {
            // Stopp-Befehl senden
            Stop();

            // Puffer leeren
            _serialPort.DiscardOutBuffer();
            _serialPort.DiscardInBuffer();

            // Ereignisdelegat abmelden
            _serialPort.DataReceived -= SerialPort_DataReceived;

            // Seriellen Port schließen und verwerfen
            _serialPort.Close();
            _serialPort.Dispose();
        }
        #endregion

        #region Delegates

        /// <summary>
        /// Delegat, der beim Auslösen des <see cref="OnSeriesMeasurementCompleted"/>-Event aufgerufen wird.
        /// </summary>
        public delegate void SeriesMeasurementCompleted();

        /// <summary>
        /// Delegat, der beim Auslösen des <see cref="OnValueReceived"/>-Event aufgerufen wird.
        /// </summary>
        public delegate void ValueReceived();

        #endregion

        #region Events

        /// <summary>
        /// Wird ausgelöst, wenn Werte über die RS232-Schnittstelle empfangen wurden.
        /// </summary>
        public event ValueReceived OnValueReceived;

        /// <summary>
        /// Wird aufgerufen, wenn die Serienmessung abgeschlossen wurde.
        /// </summary>
        public event SeriesMeasurementCompleted OnSeriesMeasurementCompleted;

        #endregion

        #region Properties

        /// <summary>
        /// Gibt die Beschreibung des zuletzt aufgetretenen Fehler zurück.
        /// </summary>
        public string GetErrorDescription
        {
            get { return _errorDescription; }
        }

        /// <summary>
        /// Liefert den Gerätenamen des angeschlossenen Gerätes.
        /// </summary>
        public string GetDeviceName
        {
            get { return "ILR1181"; }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Führt eine Einzelmessung durch.
        /// </summary>
        public void OneShot()
        {
            _serialPort.WriteLine("dm" + _endOfCommand);
        }

        /// <summary>
        /// Führt das Distanztracking aus.
        /// </summary>
        public void DistanceTracking()
        {
            _serialPort.WriteLine("dt" + _endOfCommand);
        }

        /// <summary>
        /// Setzt den Nullpunkt des LDM.
        /// </summary>
        public void SetNull()
        {
            _serialPort.WriteLine("so" + _endOfCommand);
        }

        /// <summary>
        /// Beendet die Serienaufnahme.
        /// </summary>
        public void Stop()
        {
            _serialPort.WriteLine("lo" + _endOfCommand);
        }

        /// <summary>
        /// Liefert ein Objekt aus der <see cref="ComPortDataAnalyzer"/>-Queue.
        /// </summary>
        /// <param name="retval">Referenz auf ein <see cref="ComPortDataAnalyzer"/>-Objekt.</param>
        /// <returns>True, falls ein Element aus der Queue gelesen wurde.</returns>
        public bool Queue(out ComPortDataAnalyzer retval)
        {
            return _dataQueue.TryDequeue(out retval);
        }

        /// <summary>
        /// Liefert eine Referenz auf eine <see cref="ConcurrentQueue{T}"/>.
        /// </summary>
        /// <param name="retval"></param>
        public void Queue(out ConcurrentQueue<ComPortDataAnalyzer> retval)
        {
            retval = _dataQueue;
        }

        /// <summary>
        /// Aktiviert die Autostop-Funktion für Serienmessungen.
        /// </summary>
        /// <param name="numOfMeasurements">Die Anzahl an Messungen, nach der die Datenerfassung angehalten werden soll.</param>
        public void EnableAutoStop(int numOfMeasurements = 10)
        {
            _autoStopNumOfMeasurements = numOfMeasurements;
            _autoStopCounter = 0;
            _autoStop = true;
        }

        /// <summary>
        /// Liefert alle verfügbaren COM-Ports zurück.
        /// </summary>
        /// <returns></returns>
        private string[] GetAvailableComPorts()
        {
            return SerialPort.GetPortNames();
        }

        /// <summary>
        /// Setzt alle Einstellung zur Nutzung des COM-Port
        /// </summary>
        private void SetUpSerialPort()
        {
            _serialPort.ReadTimeout = 1000;
            _serialPort.WriteTimeout = 1000;
            _serialPort.BaudRate = 9600;
            _serialPort.DataBits = 8;
            _serialPort.StopBits = StopBits.One;
            _serialPort.Parity = Parity.None;
            _serialPort.DiscardNull = true;
        }

        /// <summary>
        /// Prüft, ob es sich bei einem String um einen Fehlercode handelt.
        /// </summary>
        /// <param name="stringToMatch">Der String, der untersucht werden soll.</param>
        /// <returns>Wahr, falls es sich um einen gültigen Fehlercode handelt.</returns>
        private bool IsErrorCode(string stringToMatch)
        {
            try
            {
                if (stringToMatch.Left(1) == "E")
                {
                    string substring = stringToMatch.Substring(1, 2);
                    int number;

                    if (int.TryParse(substring, out number))
                    {
                        string substring2;
                        substring2 = stringToMatch.Substring(3, 2);

                        if (substring2 == "\r\n")
                        {
                            return true;
                        }
                    }
                }
            }
            catch
            {
                return false;
            }

            return false;
        }

        /// <summary>
        /// Ereignis, welches beim Eintreffen von Daten am COM-Port ausgelöst wird.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Hält, ob die Datenaufzeichnung der Serienmessung abgeschlossen ist
            bool aquisitionFinished = false;

            // Lokale Instanz des Com
            ComPortDataAnalyzer comPortDataAnalyzer = new ComPortDataAnalyzer();

            // Lesepuffer der Daten
            string readBuffer;

            SerialPort sp = (SerialPort)sender;

            string[] lines;

            // Seriellen puffer für weiteren Zugriff sperren und fortfahren
            lock (_comPortDataAnalyzer)
            {
                // Daten in Puffer schreiben
                readBuffer = sp.ReadExisting();
                _comPortDataAnalyzer.Data += readBuffer;

                // Warten auf CRLF
                if (_comPortDataAnalyzer.Data.Right(2) == "\r\n")
                {
                    // Prüfen, ob der letzte Datenblock eine Fehlermeldung ist
                    lines = _comPortDataAnalyzer.Data.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);

                    // Letzten Eintrag extrahieren
                    string lastEntry = lines.Last().ToString();

                    // Fehlercode - falls vorhanden - umwandeln
                    if (lastEntry.IsErrorCode())
                    {
                        // Fehlercode parsen
                        _errorDescription = lastEntry.ToErrorDescription();
                    }
                    else {
                        _errorDescription = null;
                    }

                    // Angeben, dass Daten empfangen wurden
                    _dataReceived = true;

                    // Autostop durchführen?
                    if (_autoStop)
                    {
                        // Zähler aktualisieren
                        _autoStopCounter += lines.Count();

                        // Prüfen, ob Zählerendstand erreicht wurde
                        if (_autoStopCounter >= _autoStopNumOfMeasurements)
                        {
                            // Messdatenaufnahme beenden
                            _autoStop = false;
                            _autoStopCounter = 0;
                            Stop();

                            // angeben, dass die Messung vollständig ist
                            aquisitionFinished = true;
                        }
                    }
                }
                else {
                    // Die empfangenen Daten sind unvollständig, da der Abschlus "\r\n" fehlt
                    _dataReceived = false;
                }
            }

            // Prüfen, ob Daten *inklusive* EOB empfangen wurden
            if (_dataReceived)
            {
                // Daten aus lokalem Hilfsobjekt übernehmen
                comPortDataAnalyzer.Data = _comPortDataAnalyzer.Data;

                // Puffer leeren
                _comPortDataAnalyzer.Data = "";

                // ComPortDataAnalyzer-Objekt in die Queue einfügen
                _dataQueue.Enqueue(comPortDataAnalyzer);

                // Wird der COM-Port initialisiert?
                if (_isInit == false)
                {
                    // Empfangsereignis auslösen
                    OnValueReceived?.Invoke();

                    // Ereignis ausführen, wenn die Messung vollständig ist
                    if (aquisitionFinished)
                        OnSeriesMeasurementCompleted?.Invoke();
                }
            }
        }

        #endregion

        #region Classes

        /// <summary>
        /// Fehler wird ausgelöst, wenn ein Timeout bei der Suche nach einem Laser-Distanzsensor auftritt
        /// </summary>
        [Serializable]
        private class optoNCDTTimeoutException : Exception
        {
            public optoNCDTTimeoutException() : base() { }
        }

        /// <summary>
        /// Fehler wird ausgelöst, wenn kein Laser-Distanzsensor gefunden werden kann
        /// </summary>
        [Serializable]
        public class optoNCDTNotFoundException : Exception
        {
            public optoNCDTNotFoundException() : base() { }
        }

        /// <summary>
        /// Hilfsobjekt zur Datenverarbeitung und -auswertung.
        /// </summary>
        public class ComPortDataAnalyzer
        {
            /// <summary>
            /// Hält lokal in der Klasse die empfangenen Daten
            /// </summary>
            string _data = "";
            List<double> _values = new List<double>();

            /// <summary>
            /// Hält die vom COM-Port empfangenen Daten
            /// </summary>
            public string Data
            {
                get { return _data; }
                set { _data = value; ParseData(); }
            }

            /// <summary>
            /// Gibt die aus den empfangenen Daten geparsten Messwerte zurück.
            /// </summary>
            public List<double> Values
            {
                get { return _values; }
            }

            /// <summary>
            /// Wandelt die empfangenen Daten in eine <see cref="List{T}"/> um.
            /// </summary>
            public void ParseData()
            {
                double numBuffer;

                _values.Clear();

                // Sind Daten vorhanden?
                if (_data != "")
                {
                    // Daten am EOB-Separator auftrennen
                    string[] lines = _data.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);

                    // Alle Einzelwerte durchlaufen
                    foreach (string line in lines)
                    {
                        // Prüfen, ob es sich um Messwerte handelt
                        if (double.TryParse(line, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out numBuffer))
                        {
                            // Wert in Liste einfügen
                            _values.Add(numBuffer);
                        }
                    }
                }
            }
        }

        #endregion
    }

    /// <summary>
    /// Erweiterung der String-Klasse um einige zusätzliche Funktionen
    /// </summary>
    public static class StringExtensions
    {
        /// <summary>
        /// Wandelt einen String mit einem optoNCDT ILR 1181 / 1182 Fehler in eine Fehlerbeschreibung um.
        /// </summary>
        /// <param name="value">Der String, der geprüft werden soll.</param>
        /// <returns>Gibt die Fehlerbeschreibung zurück.</returns>
        public static string ToErrorDescription(this string value)
        {
            int errorCode = int.Parse(value.Right(2));
            string errorDescription;

            switch (errorCode)
            {
                case 15:
                    errorDescription = "Zu schwache Reflexe; Abstand Sensor (Vorderkante) gegen Ziel < 0,1m.";
                    break;
                case 16:
                    errorDescription = "Zu starke Reflexe.";
                    break;
                case 17:
                    errorDescription = "Gleichlicht zu stark (zum Beispiel Sonneneinstrahlung).";
                    break;
                case 18:
                    errorDescription = "Nur im DX-Mode (50 Hz): zu große Abweichungen zwischen gemessenem und vorberechnetem Wert.";
                    break;
                case 19:
                    errorDescription = "Nur im DX-Mode (50 Hz): Verfahrgeschwindigkeit > 10 m/s.";
                    break;
                case 23:
                    errorDescription = "Temperatur unter -10°C.";
                    break;
                case 24:
                    errorDescription = "Temperatur über +60°C.";
                    break;
                case 31:
                    errorDescription = "Prüfsumme EEPROM falsch; Hardware-Fehler.";
                    break;
                case 51:
                    errorDescription = "Avalanche-Spannung der Laserdiode konnte nicht eingestellt werden; Ursache kann\n1. Fremdlich oder\n2. Hardware-Fehler sein.";
                    break;
                case 52:
                    errorDescription = "Laserstrom zu hoch / defekter Laser.";
                    break;
                case 53:
                    errorDescription = "Ein oder mehrere Parameter im EEPROM nicht gesetzt (Folge: Division durch 0).";
                    break;
                case 54:
                    errorDescription = "Hardwarefehler (PLL).";
                    break;
                case 55:
                    errorDescription = "Hardwarefehler.";
                    break;
                case 61:
                    errorDescription = "Verwendeter Parameter unzulässig; ungültiges Komando gesendet.";
                    break;
                case 62:
                    errorDescription = "1. Hardwarefehler\n2. Falscher Wert in Schnittstellenkommunikation (Paritätsfehler SIO).";
                    break;
                case 63:
                    errorDescription = "Überlauf SIO.";
                    break;
                case 64:
                    errorDescription = "Framing-Error SIO.";
                    break;
                default:
                    errorDescription = "Es trat ein unbekannter Fehler auf.";
                    break;
            }

            return errorDescription;
        }

        /// <summary>
        /// Prüft, ob es sich um einen Fehler der optoNCDT ILR 1181 / 1182 handelt.
        /// </summary>
        /// <param name="value">Der String, der geprüft werden soll.</param>
        /// <returns>Wahr, falls es sich um einen gültigen Fehlercode handelt.</returns>
        public static bool IsErrorCode(this string value)
        {
            Int16 errorCode;

            // Stimmt das Format?
            if (value.Length != 3)
                return false;

            if (value.Left(1) == "E" && Int16.TryParse(value.Substring(1, 2), out errorCode))
            {
                // Es handelt sich um das Format "E##"
                return true;
            }
            else {

                return false;
            }
        }

        /// <summary>
        /// Gibt die angegebene Anzahl von Zeichen von links aus einem String zurück.
        /// </summary>
        /// <param name="value">Der String, der bearbeitet werden soll.</param>
        /// <param name="maxLength">Die Länge in Zeichen, die zurückgegeben werden soll.</param>
        /// <returns></returns>
        public static string Left(this string value, int maxLength)
        {
            if (string.IsNullOrEmpty(value)) return value;
            maxLength = Math.Abs(maxLength);

            return (value.Length <= maxLength
                   ? value
                   : value.Substring(0, maxLength)
                   );
        }

        /// <summary>
        /// Gibt die angegebene Anzahl von Zeichen von rechts aus einem String zurück.
        /// </summary>
        /// <param name="value">Der String, der bearbeitet werden soll.</param>
        /// <param name="maxLength">Die Länge in Zeichen, die zurückgegeben werden soll.</param>
        /// <returns></returns>
        public static string Right(this string value, int maxLength)
        {
            if (string.IsNullOrEmpty(value)) return value;
            maxLength = Math.Abs(maxLength);

            return (value.Length <= maxLength
                   ? value
                   : value.Substring(value.Length - maxLength, maxLength)
                   );
        }

        /// <summary>
        /// Konvertiert eine Zeichenfolge in einen HEX-String
        /// </summary>
        /// <param name="value">String, der konvertiert werden soll.</param>
        /// <returns>Liefert den String in der Form 0x00..0xFF zurück.</returns>
        public static string ToHex(this string value)
        {
            char[] charValues = value.ToCharArray();
            string hexOutput = "";


            foreach (char _eachChar in charValues)
            {
                int val = Convert.ToInt32(_eachChar);
                string buffer = String.Format("{0:X}", val);

                if (buffer.Length == 1)
                    buffer = "0" + buffer;

                hexOutput += "0x" + buffer + " ";
            }

            return hexOutput;
        }
    }
}

[blubb (Gast)]

Die Codeansicht ist ja ne Vollkatastrophe -.-

[Axel R. (axlr)]

Jim M. schrieb:
> Wenn dem µC beim Senden ein Interrupt dazwischen funkt, wird er die 10
> Bytes in 2 Pakete aufteilen, da ja für kuze zeit der UART Datenstrom
> unterbrochen ist.

Ist das so? Die Wartezeit steht bei original 16ms oder 4096Zeichen 
Puffergröße. Wenn einer der beiden Punkte erfüllt ist, schickt der 
Wandler die Daten raus. der weiss schon, was er macht. ganz so dumm ist 
er nicht. das ist jedenfalls nicht die Ursache, denke ich. Sber: sicher 
in ich mir auch nicht.
Wann wird denn "INTI_CLICK" aufgerufen. Muss er schon klicken, bevor das 
was reinkommt. Und nach den zehn Bytes rtb_RecvData.Text auch wieder auf 
"" setzen. Sonst werden die immer wieder draufaddiert.
Müsste man mal aufsetzen. Geht nur gerade nicht..

[StarWars (Gast)]

ALso der Mikrocontroller sendet zyklisch alle 500ms folgende Daten:

Data[0] = 10;
for(int i = 1; i < 11; i++)
{
  Data[i] = i;
}

Jim M. schrieb:
Abhilfe: Auf PC Anwendungsseite nochmal vernünftig puffern und Daten neu
zusammen setzen.

Was meinst du mit vernünftig puffern?

[Axel R. (axlr)]

StarWars schrieb:
> ALso der Mikrocontroller sendet zyklisch alle 500ms folgende Daten:
> Data[0] = 10;
> for(int i = 1; i < 11; i++)
> {
>   Data[i] = i;
> }

Welche Ausgabe erwartest Du am PC?
1
2
3
4
5
6
7
8
9
10usw?

[Wikipedia (Gast)]

Und was erwartest Du jetzt, das passiert? Hättest Du den obigen Code mal 
angesehen, wäre Dir längst aufgefallen, dass er auf einen CR/LF wartet.

Wenn Du deine Daten ohne Stopp-Byte schickst, dann wirst Du niemals 
erreichen, dass die Zeichenkette so ankommt, wie Du es gerne hättest.

Schicke ein CR/LF/00 oder sonstwas mit, das Du nicht verwendest und 
werte im C# code auf dieses Stoppbyte aus.

[StarWars (Gast)]

Das erste Byte hat den Wert 10 (Data[0] = 10;)
Danach folgen 10 Datenbytes.

Muss eine Endsequenz immer angehängt werden? Ich meine das muss doch 
nicht sein.

[StarWars (Gast)]

Habs nun gelöscht mit einem Thread.

[StarWars (Gast)]

Hab es nun gelöt mit einem Thread. Allerdings erhalte ich nicht die 
Daten ab dem ersten Byte. In msg steht dann immer die Daten ab n+1. WIe 
kann das sein?

public void OnReadSerialData()
        {
            while (true)
            {
                try
                {

                    string msg= mySerialPort.ReadLine();
                }
                catch (TimeoutException) { }
            }
        }

[StarWars (Gast)]

Die Daten sollen immer so ankommen:

10
1
2
3
4
5
6
7
8
9
10

[StarWars (Gast)]

In _inBuffer liegen die Daten korrekt an. WIe kann das sein?
Ich möchte nur Daten richtig und korrekt empfangen können.

[StarWars (Gast)]

Gibt es eigentlich eine bessere Alternative?

[Meine Güte! (Gast)]

Meine Güte liest Du eigentlich die Antworten?

Dein µC sendet asynchron, Dein Programm empfängt asynchron. Wie in 
gottes Namen stellst Du dir vor, dass die Daten bei asynchronem Senden 
und asynchronem Empfangen synchron ankommen?

Threats helfen Dir da überhaupt nicht. UART ist in C# bereits in einem 
eigenen Thread. Wenn Du im UI-Thread die Daten verarbeiten willst, musst 
Du sicherstellen, dass Du keine Race Condition erhälst und Du Daten 
verarbeitest, die gerade aktualisiert wurden.

Dein ReadLine() Befehl ist Grütze, weil Du kein CrLf (Newline) als 
Separator hast. Les doch mal die MSDN.

Bau Dir einen Ereignisdelegaten und werte den Interrupt der UART aus. 
https://docs.microsoft.com/de-de/dotnet/api/system.io.ports.serialdatareceivedeventhandler?view=dotnet-plat-ext-6.0

Dann hängst Du einfach solange alle Daten zusammen, bis du 10...10 
empfangen hast. Dann hast Du Deinen Datenblock.

[c-hater (Gast)]

StarWars schrieb:

> ALso der Mikrocontroller sendet zyklisch alle 500ms folgende Daten:
>
>

> Data[0] = 10;
> for(int i = 1; i < 11; i++)
> {
>   Data[i] = i;
> }
>

>
> Jim M. schrieb:
> Abhilfe: Auf PC Anwendungsseite nochmal vernünftig puffern und Daten neu
> zusammen setzen.
>
> Was meinst du mit vernünftig puffern?

Du hast da auf µC-Seite (wahrscheinlich ohne dir Gedanken darüber zu 
machen) ein Protokoll aufgesetzt, welches die Nachrichtensynchronisation 
allein über einen Timeout sicherstellt. Um das für dich zu übersetzen: 
Es gibt da eine große zeitliche "Lücke", in der keine Daten ankommen und 
diese Lücke (und nur diese Lücke!!!) ist ein zuverlässiger Trenner für 
die Nachrichten, da der Payload ganz offensichtlich auch die vermutlich 
als Trennzeichen vorgesehene 10 enthalten kann.

"Vernünftig puffern" bedeutet nun einfach, alle eingehenden Daten 
erstmal aneinander zu hängen und neu zu zerteilen, nämlich immer dann, 
wenn so eine Lücke zu sehen ist.

Mein Gott, ist das trivial.

[StarWars (Gast)]

Hi,

zunächst habe ich nun den Empfang über einen RecieveHandler realisiert.
Damit bekomme ich nun mal die empfangenen Daten.

private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
  {

    SerialPort sp = (SerialPort)sender;
    string rxdata = sp.ReadExisting();

    StringBuilder myBuilder = new StringBuilder();
    foreach (byte feb in rxdata)
    {
        myBuilder.AppendFormat("{0}", feb);
    }

    Debug.WriteLine("Data received:");
    Debug.Write(myBuilder.ToString() + "\n");
  }

Jetzt gibt es auch noch eine Möglichkeit die empfangenen Daten durch 
einen Puffer auszulsen mit:

mySPort.Read(buffer, 0, buffer.Length);

Wenn ich den Puffer mir anschauen ändern sich ja die Daten die dort 
abgelegt werden. Dies bedeutet es wird nicht immer ganz am Anfang die 
Daten im Puffer abgelegt.

[StarWars (Gast)]

Der buffer hat eine Größe von 20

Hier ist zu sehen, das manchmal die Daten nicht alle im buffer enthalten 
sind sondern nur ein Teil.

1012345678910000000000
1012345678910000000000
1012345678910000000000
1012345678910000000000
1012345678910000000000
1012345678910000000000
101230000000000000000
456789100000000000000
1012345678910000000000
1012345678910000000000
1012345678910000000000

[Genug gesagt (Gast)]

Es steht alles schon dar. Lesen, verstehen, anpassen.

[StarWars (Gast)]

Ja es steht vieles hier drin.

Wie kann ich ein delay festellen von Telegramm zu Telegramm?
Da weiß ich nicht wie ich das umsetzen könnte.

[Klaus P. (kpi6288)]

StarWars schrieb:
> this.Invoke((MethodInvoker)delegate()
>   {
>     rtb_RecvData.Text += indata;
>   });

Invoke ruft zwar eine Methode im GUI Thread auf, wartet aber, bis sie 
abgearbeitet ist. In dieser Zeit können weitere Events mit neuen Daten 
verloren gehen.

Du kannst das MSDN Beispiel mit dem einfachen Kommandozeilenprogramm 
nicht 1:1 in eine GUI Anwendung übernehmen. Du musst das GUI vom 
Daten-Thread trennen.

Dafür kannst Du die ankommenden Daten z.B. in eine ConcurrentQueue 
schreiben und im GUI Thread auslesen. Das Auslesen kannst Du z.B. mit 
einem Timer oder mit einem ResetEvent (AutoResetEvent / ManualResetEvent 
je nach Anforderungen) durchführen.

Hier ist ein Beispiel mit Read() statt ReadExisting(): 
https://stackoverflow.com/a/45432817/10035674

[c-hater (Gast)]

Klaus P. schrieb:

> StarWars schrieb:
>> this.Invoke((MethodInvoker)delegate()
>>   {
>>     rtb_RecvData.Text += indata;
>>   });
>
> Invoke ruft zwar eine Methode im GUI Thread auf, wartet aber, bis sie
> abgearbeitet ist. In dieser Zeit können weitere Events mit neuen Daten
> verloren gehen.

So ist es. Kann man mit minimaler Änderung des vorhandenen Code lösen, 
indem man anstatt Invoke einfach BeginInvoke aufruft. Das kehrt sofort 
zurück und nicht erst nach Abarbeitung des Delegaten.

[Klaus P. (kpi6288)]

c-hater schrieb:
> Kann man mit minimaler Änderung des vorhandenen Code lösen,
> indem man anstatt Invoke einfach BeginInvoke aufruft.

Ja, in diesem einfachen Fall (und beim klassischen .NET bis 4.8) reicht 
das sicher aus.
Ganz sauber ist das aber nicht, weil die Reihenfolge der Abarbeitung 
nicht definiert ist, wenn BeginInvoke mehrfach aufgerufen wird. Deshalb 
würde ich eine ConcurrentQueue benutzen - damit ist die Reihenfolge 
garantiert.

[c-hater (Gast)]

Klaus P. schrieb:

> Ganz sauber ist das aber nicht, weil die Reihenfolge der Abarbeitung
> nicht definiert ist, wenn BeginInvoke mehrfach aufgerufen wird.

Doch, ist sie. Das kommt genau in der Reihenfolgen der Aufrufe von 
BeginInvoke beim GUI-Thread an (wird intern letztlich mittels 
PostMessage() über die ganz normale MessageQueue des Win32-API 
verschickt).

Und da hier die Aufrufe aus einem einzigen Thread stammen (nämlich dem 
Reader-Thread des SerialPort), kann es nicht zu "überlappenden" Aufrufen 
von BeginInvoke kommen. Es ist absolut sicher, dass die Message geposted 
wurde, bevor der Aufruf zurückkehrt und damit der Readerthread überhaupt 
die Chance bekommt, in seiner Queue nach weiteren Bytes Ausschau zu 
halten und dann bei positivem Resultat erneut BeginInvoke aufzurufen.

> Deshalb
> würde ich eine ConcurrentQueue benutzen - damit ist die Reihenfolge
> garantiert.

Ist sie, wie oben gesagt, auch bei der Verwendung von BeginInvoke.

Ein ganz andere Sache ist allerdings, wenn das Ziel garnicht der 
GUI-Thread mit seinen Fenstern ist, die an der MessageQueue lauschen. 
Dann gibt's allerdings auch weder Invoke noch BeginInvoke. Dann muss man 
natürlich anders synchronisieren.

[StarWars (Gast)]

Hi ich melde mich nun doch nochmal.

ALso das Empfangen von Daten mittels eigenen Task und BlockingCollection 
funktioniert. Allerdings gibt es nun ein weiteres Problem sobald ich 
Daten versenden möchte. Da läuft das mit dem EMpfang nicht mehr richtig.

[Klaus P. (kpi6288)]

c-hater schrieb:
>> Ganz sauber ist das aber nicht, weil die Reihenfolge der Abarbeitung
>> nicht definiert ist, wenn BeginInvoke mehrfach aufgerufen wird.
>
> Doch, ist sie.

Hast Du eine Quelle für Deine Behauptung? Soweit ich weiß, ist 
BeginInvoke derzeit (im klassischen .NET Framework) zwar so 
implementiert, aber das Verhalten ist nicht definiert. Es kann im Grunde 
beliebig geändert werden.

Bei einer ConcurrentQueue ist es anders. Da ist das Verhalten definiert.

[c-hater (Gast)]

Klaus P. schrieb:

> Hast Du eine Quelle für Deine Behauptung?

Nein, habe ich nicht, ich bin aber ziemlich sicher, dass sie sich mit 
hinreichender Motivation finden lassen würde, weil...

> Soweit ich weiß, ist
> BeginInvoke derzeit (im klassischen .NET Framework) zwar so
> implementiert, aber das Verhalten ist nicht definiert. Es kann im Grunde
> beliebig geändert werden.

...weil: in mono/xamarin ist es mit den Mitteln der unterstützten 
Targets jedenfalls immer adäquat implentiert. Die haben dann zwar kein 
Win32-API, aber es wird immer irgendwas benutzt, was sich effektiv im 
GUI-Thread so verhält, wie das PostMessage() aus diesem API.

Irgendwo ist also vermutlich niedergeschrieben, dass das so sein muss.

Die genaue Doku-Stelle darfst du gern selbst suchen. Ich bin nicht dein 
Such-Sklave.