La idea del programa es almacenar los bytes recibidos y mostrarlo en pantalla.

Si no ha llegado nada, que diga que no hay nada con un mensaje.

Me ejecuta pero en pantalla no me muestra nada a la hora de enviar tramas de bytes para ver si lo capta. Si no hay nada, que también indique algo para saberlo.

Me equivoqué. La captura es esta:



Ver zoom.

Disculpen.

Hola:

En este código me sale un error y no se como corregirlo, ya que me interesa mostrar datos en pantalla y no me sale.

Ver error.

Código hecho hasta ahora.

using System;
using System.IO.Ports;
 
namespace Almacenar_byte_puerto_serie_Consola_01
{
    internal class Program
    {
        static SerialPort puertoSerie;
        static byte[] datoRecibido;
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Almacenar byte[] desde el puerto serie.";
 
            // Tamaño de la ventana, x, y, o ancho y alto.
            const byte ANCHO_X = 70, ALTO_Y = 25;
            Console.SetWindowSize(ANCHO_X, ALTO_Y);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Black;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Yellow;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            puertoSerie = new SerialPort()
            {
                // Configuración del puerto serie.
                PortName = "COM4",           // Nombre del puerto serie.
                BaudRate = 2400,             // Velocidad en baudios.
                Parity = Parity.None,        // Esquema para comprobar la paridad de cada byte recibido.
                StopBits = StopBits.One,     // Número de bits de parada por byte.
                DataBits = 8,                // Número de bits de datos por byte.
                Handshake = Handshake.None,  // Protocolo de establecimiento.
                DtrEnable = true,            // Línea de terminal de datos.
                RtsEnable = true,            // Línea de solicitud.
 
                // Establecer los tiempos de espera de lectura / escritura.
                ReadTimeout = 500,           // Tiempo de espera de escritura en ms.
                WriteTimeout = 500,          // Tiempo de espera de escritura en ms.
 
                // Más configuraciones.
                DiscardNull = false,         // Descartar bytes nulos recibidos.
                ParityReplace = 63,          // Reemplaza los bytes recibidos con errores de paridad.
                ReadBufferSize = 4096,       // Tamaño del búfer de lectura en bytes.
                WriteBufferSize = 2018,      // Tamaño del búfer de escritura en bytes.
                ReceivedBytesThreshold = 1   // Número de bytes que se necesitan.
            };
 
            puertoSerie.DataReceived += SerialPort_DataReceived;
            puertoSerie.Open();
 
            Console.WriteLine("Presiona cualquier tecla para detener la captura...");
            Console.ReadKey();
 
            puertoSerie.Close();
 
            Console.WriteLine("Datos recibidos:");
            MostrarBytes(datoRecibido);
        }
        static void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            int bytesToRead = sp.BytesToRead;
            byte[] buffer = new byte[bytesToRead];
            sp.Read(buffer, 0, bytesToRead);
 
            if (datoRecibido == null)
            {
                datoRecibido = buffer;
            }
            else
            {
                Array.Resize(ref datoRecibido, datoRecibido.Length + bytesToRead);
                Array.Copy(buffer, 0, datoRecibido, datoRecibido.Length - bytesToRead, bytesToRead);
            }
        }
 
        static void MostrarBytes(byte[] dato)
        {
            for (int i = 0; i < dato.Length; i++)
            {
                Console.Write($"{dato[i]} ");
            }
            Console.WriteLine();
        }
    }
}

Se trata de obtener bytes puro y duro desde el RS232 o puerto serie, almacenarlo en un array tipo byte[] y mostrarlo en pantalla.

¿Alguna idea?

Saludos.

Ya funciona, solo había que poner el encoder correcto.

using System.IO.Ports;
using System.Text;
 
namespace Termite_SAI_05_.NET_8._0
{
    public partial class Form1 : Form
    {
        SerialPort puertoSerie;
        bool verComandoBFlag = false;
        bool verComandoX72Flag = false;
        bool verComandoX5Flag = false;
        const string COMANDO_B = "B\r";
        const string COMANDO_X72 = "X72\r";
        const string COMANDO_X5 = "X5\r";
 
        public Form1()
        {
            InitializeComponent();
            InicioPuertoSerie();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            //timer1.Start();
            timer1.Enabled = true;
        }
        /* Iniciar y configurar el puerto serie */
        private void InicioPuertoSerie()
        {
            try
            {
                puertoSerie = new SerialPort()
                {
                    // Configuración del puerto serie.
                    PortName = "COM3",           // Nombre del puerto serie.
                    BaudRate = 2400,             // Velocidad en baudios.
                    Parity = Parity.None,        // Esquema para comprobar la paridad de cada byte recibido.
                    StopBits = StopBits.One,     // Número de bits de parada por byte.
                    DataBits = 8,                // Número de bits de datos por byte.
                    Handshake = Handshake.None,  // Protocolo de establecimiento.
                    Encoding = Encoding.GetEncoding(28591),
                    DtrEnable = true,            // Línea de terminal de datos.
                    RtsEnable = true,            // Línea de solicitud.
 
                    // Establecer los tiempos de espera de lectura / escritura.
                    ReadTimeout = 500,           // Tiempo de espera de escritura en ms.
                    WriteTimeout = 500,          // Tiempo de espera de escritura en ms.
 
                    // Más configuraciones.
                    DiscardNull = false,         // Descartar bytes nulos recibidos.
                    ParityReplace = 63,          // Reemplaza los bytes recibidos con errores de paridad.
                    ReadBufferSize = 4096,       // Tamaño del búfer de lectura en bytes.
                    WriteBufferSize = 2018,      // Tamaño del búfer de escritura en bytes.
                    ReceivedBytesThreshold = 1   // Número de bytes que se necesitan.
                };
 
                // Abrir puerto serie.
                puertoSerie.Open();
 
                // Subscribir el evento DatosRecividos cuando lleguen datos.
                puertoSerie.DataReceived += DatosRecibidos;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                timer1.Stop();
                puertoSerie.Close(); // Cierra el puerto en caso de error                
            }
        }
 
        /* Evento para leer asíncronamente datos del puerto serie */
        void DatosRecibidos(object sender, SerialDataReceivedEventArgs e)
        {
            Task.Run(async () =>
            {
                try
                {
                    await Task.Delay(500); // Pausa para recibir datos.
                    string cadena = puertoSerie.ReadExisting();
                    if (!string.IsNullOrEmpty(cadena))
                    {
                        if (verComandoBFlag == true) { ProcesoCOMANDO_B(cadena); }
                        if (verComandoX72Flag) { ProcesoCOMANDO_X72(cadena); }
                        if (verComandoX5Flag) { ProcesoCOMANDO_X5(cadena); }
                    }
                    else
                    {
                        Console.Write("Datos leídos corruptos.");
                    }
                }
                catch (IndexOutOfRangeException ex)
                {
                    Console.Write("Índice fuera de los límites de la matriz.");
                    MessageBox.Show(ex.Message);
                }
                catch (FormatException ex)
                {
                    Console.Write("La cadena de entrada no tiene el formato correcto.");
                    MessageBox.Show(ex.Message, "Error");
                }
            });
        }
 
        /* Procesar COMANDO_X5 */
        private void ProcesoCOMANDO_X5(string cadena)
        {
            verComandoX5Flag = false;
            char[] separadores = { '#', ',', '\r' };
            string[] salida = cadena.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia.
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoX5(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoX5(salida);
            }
        }
 
        /* Procesar COMANDO_X72 */
        private void ProcesoCOMANDO_X72(string str)
        {
            verComandoX72Flag = false;
            char[] separadores = { '#', ',', '\r' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia.
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoX72(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoX72(salida);
            }
        }
 
        /* Procesar COMANDO_B */
        private void ProcesoCOMANDO_B(string str)
        {
            verComandoBFlag = false;
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia.
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoB(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoB(salida);
            }
        }
 
        /* Mostrar datos COMANDO_X5 */
        private void ActualizarUIControlComandoX5(string[] salida)
        {
            label_Resultado_Tension_nominal.Text
                = salida[0] + " V";
            label_Resultado_Cantidad_del_paquete.Text
                = salida[1] + " Baterías";
            label_Resultado_Capacidad_del_paquete.Text
                = salida[2] + " Ah";
            label_Resultado_Cantidad_externa.Text
                = salida[3];
            label_Resultado_Descarga_maxima.Text
                = salida[4] + " Minuto";
 
            // Convertir variable tipo string a tipo uint, es decir, la variable tipo string "salida[5]"
            // se convierte en tipo uint "resultadoSalida5".
            uint resultadoSalida5 = UInt32.Parse(salida[5]);
 
            // Cálculos.
            uint horas = resultadoSalida5 / 60;
            //uint minutos = resultadoSalida5 % 60;
 
            label_Resultado_Carga_maxima.Text
                = $"{horas} Horas";
 
        }
        /* Mostrar datos COMANDO_X72 */
        private void ActualizarUIControlComandoX72(string[] salida)
        {
            label_Resultado_valores_nonimales_de_alimentacion.Text
               = salida[0] + " VA / " + salida[1] + " W";
            label_Resultado_voltaje_nominal.Text
                = salida[2] + " Vac";
            label_Resultado_corriente_nominal.Text
                = salida[5] + " A";
            label_Resultado_valores_nominales_de_frecuencia.Text
                = salida[3] + " ~ " + salida[4] + " Hz";
        }
 
        /* Mostrar datos COMANDO_B */
        private void ActualizarUIControlComandoB(string[] salida)
        {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0').PadLeft(1, '0') + " %"; // Quita los ceros de la izquierda y pone un cero si no hay nada.
            label_B.Text
                = salida[3].TrimStart('0').PadLeft(1, '0') + " %"; // Quita los ceros de la izquierda y pone un cero si no hay nada.
            label_V.Text
                = salida[4] + " Vdc";
            label_F.Text
                = salida[5].PadRight(5, '0') + " Hz"; // Añade ceros a la derecha.
            label_H.Text
                = salida[6].PadRight(5, '0') + " Hz";
 
            // Convertir variable tipo string a tipo uint, es decir, la variable tipo string "salida[7]"
            // se convierte en tipo uint "resultadoSalida7".
            uint resultadoSalida7 = uint.Parse(salida[7]);
 
            #region Horas y minutos.
            // Cálculos.
            uint horas = resultadoSalida7 / 60;
            uint minutos = resultadoSalida7 % 60;
 
            // ¿0 horas y 1 minuto?
            if ((horas == 0) && (minutos == 1))
            {
                label_R.Text = $"{minutos} minuto.";
            }
 
            // ¿0 horas y 0 minuto?
            if ((horas == 0) && (minutos == 0))
            {
                label_R.Text = $"{minutos} minutos";
            }
 
            // ¿0 horas y más de 1 minuto?
            if ((horas == 0) && (minutos > 1))
            {
                label_R.Text = $"{minutos} minutos.";
            }
 
            // ¿1 hora y 0 minutos?
            if ((horas == 1) && (minutos == 0))
            {
                label_R.Text = $"{horas} hora.";
            }
 
            // ¿Más de una hora y 0 minutos?
            if ((horas > 1) && (minutos == 0))
            {
                label_R.Text = $"{horas} horas.";
            }
 
            // ¿1 hora y 1 minuto?
            if ((horas == 1) && (minutos == 1))
            {
                label_R.Text = $"{horas} hora y {minutos} minuto";
            }
 
            // ¿1 hora y más de 1 minuto?
            if ((horas == 1) && (minutos > 1))
            {
                label_R.Text = $"{horas} hora y {minutos} minutos.";
            }
 
            // ¿Más de 1 hora y 1 minuto?
            if ((horas > 1) && (minutos == 1))
            {
                label_R.Text = $"{horas} horas y {minutos} minuto.";
            }
 
            // ¿Más de 1 horas y más de 1 minuto?
            if ((horas > 1) && (minutos > 1))
            {
                label_R.Text = $"{horas} horas y {minutos} minutos.";
            }
            #endregion
 
            // Mostrar nivel barra de progreso.
            uint barraProgresoL = uint.Parse(salida[2]);
            progressBar_L.Value = (int)barraProgresoL;
 
            uint barraProgresoB = uint.Parse(salida[3]);
            progressBar_B.Value = (int)barraProgresoB;
 
            uint[] numeros = new uint[8];
            uint contador = 0;
            richTextBox1.Clear(); // Limpiar.
            foreach (uint elemento in salida[8])
            {
                richTextBox1.Text += Environment.NewLine; // Nueva línea.
                richTextBox1.Text += $"Array: {numeros[contador] = elemento}";
                ++contador;
            }
 
            // Mostrar información configuración del puerto serie.
            statusStrip1.Items[0].Text = @$"{puertoSerie.PortName} {puertoSerie.BaudRate} {puertoSerie.DataBits} {puertoSerie.Parity} {puertoSerie.StopBits}";
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "B" */
        private void button_Comando_B_Click(object sender, EventArgs e)
        {
            verComandoBFlag = true;
            puertoSerie.Write(COMANDO_B);
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "X72" */
        private void button_Comando_X72_Click(object sender, EventArgs e)
        {
            timer1.Enabled = false;
            Thread.Sleep(1000);
            verComandoX72Flag = true;
            puertoSerie.Write(COMANDO_X72);
            timer1.Enabled = true;
        }
 
        private void button_Comando_X5_Click(object sender, EventArgs e)
        {
            timer1.Enabled = false;
            Thread.Sleep(1000);
            verComandoX5Flag = true;
            puertoSerie.Write(COMANDO_X5);
            timer1.Enabled = true;
        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            timer1.Stop();          // Detiene el temporizador.
            Thread.Sleep(700);      // 0.7 segundos. 700 milisegundos.
            puertoSerie.Close();    // Cierra el puerto serie.
        }
 
        private void timer1_Tick_1(object sender, EventArgs e)
        {
            verComandoBFlag = true;
            // Enviar comando B al puerto serie.
            puertoSerie.Write(COMANDO_B);
        }
    }
}

Muchas gracias.

Buenas.

Lo estaba guardado los bytes en tipo string.

Como indicas, mejor usar sin codificación alguna los bytes recibidos para ternerlo tal cual. Se ve que la mejor opción para recibir los bytes tal cual natural es usando lo que dijiste.

ReadByte()

https://learn.microsoft.com/es-es/dotnet/api/system.io.ports.serialport.readbyte?view=dotnet-plat-ext-8.0&viewFallbackFrom=net-6.0
https://learn.microsoft.com/es-es/dotnet/api/system.io.filestream.readbyte?view=net-6.0

https://learn.microsoft.com/es-es/dotnet/api/system.runtime.interopservices.marshal.readbyte?view=net-6.0


El que estaba usando es este.
https://learn.microsoft.com/es-es/dotnet/api/system.io.ports.serialport.readexisting?view=dotnet-plat-ext-8.0&viewFallbackFrom=net-6.0

No parece ser el más adecuado por lo que se ve.

Estoy gracias a ti, que estos códigos, pero quiero leer bien la parte S y mostrarlo todos los datos en decimal de la trama de bytes que vienen el puerto tal cual. Lo hace bien el RealTerm como se mostró en la imagen de arriba.

using System.IO.Ports;
using System.Text;
 
namespace Termite_SAI_05_.NET_8._0
{
    public partial class Form1 : Form
    {
        SerialPort puertoSerie;
        bool verComandoBFlag = false;
        bool verComandoX72Flag = false;
        bool verComandoX5Flag = false;
        const string COMANDO_B = "B\r";
        const string COMANDO_X72 = "X72\r";
        const string COMANDO_X5 = "X5\r";
 
        public Form1()
        {
            InitializeComponent();
            InicioPuertoSerie();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            //timer1.Start();
            timer1.Enabled = true;
        }
        /* Iniciar y configurar el puerto serie */
        private void InicioPuertoSerie()
        {
            try
            {
                puertoSerie = new SerialPort()
                {
                    // Configuración del puerto serie.
                    PortName = "COM3",           // Nombre del puerto serie.
                    BaudRate = 2400,             // Velocidad en baudios.
                    Parity = Parity.None,        // Esquema para comprobar la paridad de cada byte recibido.
                    StopBits = StopBits.One,     // Número de bits de parada por byte.
                    DataBits = 8,                // Número de bits de datos por byte.
                    Handshake = Handshake.None,  // Protocolo de establecimiento.
                    DtrEnable = true,            // Línea de terminal de datos.
                    RtsEnable = true,            // Línea de solicitud.
 
                    // Establecer los tiempos de espera de lectura / escritura.
                    ReadTimeout = 500,           // Tiempo de espera de escritura en ms.
                    WriteTimeout = 500,          // Tiempo de espera de escritura en ms.
 
                    // Más configuraciones.
                    DiscardNull = false,         // Descartar bytes nulos recibidos.
                    ParityReplace = 63,          // Reemplaza los bytes recibidos con errores de paridad.
                    ReadBufferSize = 4096,       // Tamaño del búfer de lectura en bytes.
                    WriteBufferSize = 2018,      // Tamaño del búfer de escritura en bytes.
                    ReceivedBytesThreshold = 1   // Número de bytes que se necesitan.
                };
 
                // Abrir puerto serie.
                puertoSerie.Open();
 
                // Subscribir el evento DatosRecividos cuando lleguen datos.
                puertoSerie.DataReceived += DatosRecibidos;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Aviso",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                timer1.Stop();
                puertoSerie.Close(); // Cierra el puerto en caso de error
 
            }
        }
 
        /* Evento para leer asíncronamente datos del puerto serie */
        void DatosRecibidos(object sender, SerialDataReceivedEventArgs e)
        {
            Task.Run(async () =>
            {
                try
                {
                    await Task.Delay(500); // Pausa para recibir datos
                    string cadena = puertoSerie.ReadExisting();
                    if (!string.IsNullOrEmpty(cadena))
                    {
                        if (verComandoBFlag == true) { ProcesoCOMANDO_B(cadena); }
                        if (verComandoX72Flag) { ProcesoCOMANDO_X72(cadena); }
                        if (verComandoX5Flag) { ProcesoCOMANDO_X5(cadena); }
                    }
                    else
                    {
                        Console.Write("Datos leídos corruptos.");
                    }
                }
                catch (IndexOutOfRangeException ex)
                {
                    Console.Write("Índice fuera de los límites de la matriz.");
                    MessageBox.Show(ex.Message);
                }
                catch (FormatException ex)
                {
                    Console.Write("La cadena de entrada no tiene el formato correcto.");
                    MessageBox.Show(ex.Message, "Error");
                }
            });
        }
 
        /* Procesar COMANDO_X5 */
        private void ProcesoCOMANDO_X5(string cadena)
        {
            verComandoX5Flag = false;
            char[] separadores = { '#', ',', '\r' };
            string[] salida = cadena.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia.
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoX5(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoX5(salida);
            }
        }
 
        /* Procesar COMANDO_X72 */
        private void ProcesoCOMANDO_X72(string str)
        {
            verComandoX72Flag = false;
            char[] separadores = { '#', ',', '\r' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia.
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoX72(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoX72(salida);
            }
        }
 
        /* Procesar COMANDO_B */
        private void ProcesoCOMANDO_B(string str)
        {
            verComandoBFlag = false;
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r' };
            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            // Al manipular controles de Windows Forms desde un hilo diferente al
            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    ActualizarUIControlComandoB(salida);
                }));
            }
            else
            {
                ActualizarUIControlComandoB(salida);
            }
        }
 
        /* Mostrar datos COMANDO_X5 */
        private void ActualizarUIControlComandoX5(string[] salida)
        {
            label_Resultado_Tension_nominal.Text
                = salida[0] + " V";
            label_Resultado_Cantidad_del_paquete.Text
                = salida[1] + " Baterías";
            label_Resultado_Capacidad_del_paquete.Text
                = salida[2] + " Ah";
            label_Resultado_Cantidad_externa.Text
                = salida[3];
            label_Resultado_Descarga_maxima.Text
                = salida[4] + " Minuto";
 
            // Convertir variable tipo string a tipo uint, es decir, la variable tipo string "salida[5]"
            // se convierte en tipo uint "resultadoSalida5".
            uint resultadoSalida5 = UInt32.Parse(salida[5]);
 
            // Cálculos.
            uint horas = resultadoSalida5 / 60;
            //uint minutos = resultadoSalida5 % 60;
 
            label_Resultado_Carga_maxima.Text
                = $"{horas} Horas";
 
        }
        /* Mostrar datos COMANDO_X72 */
        private void ActualizarUIControlComandoX72(string[] salida)
        {
            label_Resultado_valores_nonimales_de_alimentacion.Text
               = salida[0] + " VA / " + salida[1] + " W";
            label_Resultado_voltaje_nominal.Text
                = salida[2] + " Vac";
            label_Resultado_corriente_nominal.Text
                = salida[5] + " A";
            label_Resultado_valores_nominales_de_frecuencia.Text
                = salida[3] + " ~ " + salida[4] + " Hz";
        }
 
        /* Mostrar datos COMANDO_B */
        private void ActualizarUIControlComandoB(string[] salida)
        {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0').PadLeft(1, '0') + " %"; // Quita los ceros de la izquierda y pone un cero si no hay nada.
            label_B.Text
                = salida[3].TrimStart('0').PadLeft(1, '0') + " %";
            label_V.Text
                = salida[4] + " Vdc";
            label_F.Text
                = salida[5].PadRight(5, '0') + " Hz"; // Añade ceros a la derecha.
            label_H.Text
                = salida[6].PadRight(5, '0') + " Hz";
 
            // Convertir variable tipo string a tipo uint, es decir, la variable tipo string "salida[7]"
            // se convierte en tipo uint "resultadoSalida7".
            uint resultadoSalida7 = UInt32.Parse(salida[7]);
 
            #region Horas y minutos.
            // Cálculos.
            uint horas = resultadoSalida7 / 60;
            uint minutos = resultadoSalida7 % 60;
 
            // ¿0 horas y 1 minuto?
            if ((horas == 0) && (minutos == 1))
            {
                label_R.Text = $"{minutos} minuto.";
            }
 
            // ¿0 horas y 0 minuto?
            if ((horas == 0) && (minutos == 0))
            {
                label_R.Text = $"{minutos} minutos";
            }
 
            // ¿0 horas y más de 1 minuto?
            if ((horas == 0) && (minutos > 1))
            {
                label_R.Text = $"{minutos} minutos.";
            }
 
            // ¿1 hora y 0 minutos?
            if ((horas == 1) && (minutos == 0))
            {
                label_R.Text = $"{horas} hora.";
            }
 
            // ¿Más de una hora y 0 minutos?
            if ((horas > 1) && (minutos == 0))
            {
                label_R.Text = $"{horas} horas.";
            }
 
            // ¿1 hora y 1 minuto?
            if ((horas == 1) && (minutos == 1))
            {
                label_R.Text = $"{horas} hora y {minutos} minuto";
            }
 
            // ¿1 hora y más de 1 minuto?
            if ((horas == 1) && (minutos > 1))
            {
                label_R.Text = $"{horas} hora y {minutos} minutos.";
            }
 
            // ¿Más de 1 hora y 1 minuto?
            if ((horas > 1) && (minutos == 1))
            {
                label_R.Text = $"{horas} horas y {minutos} minuto.";
            }
 
            // ¿Más de 1 horas y más de 1 minuto?
            if ((horas > 1) && (minutos > 1))
            {
                label_R.Text = $"{horas} horas y {minutos} minutos.";
            }
            #endregion
 
            uint barraProgresoB = UInt32.Parse(salida[2]);
            progressBar_B.Value = (int)barraProgresoB;
 
            uint[] numeros = new uint[6];
            uint contador = 0;
 
            foreach (uint elemento in Encoding.Default.GetBytes(salida[8]))
            {
                //richTextBox1.Text += b.ToString();
                richTextBox1.Text += Environment.NewLine; // Nueva línea.
                richTextBox1.Text += $"Array: {numeros[contador] = elemento}";
                ++contador;
            }
            statusStrip1.Items[0].Text = @$"{puertoSerie.PortName} {puertoSerie.BaudRate} {puertoSerie.DataBits} {puertoSerie.Parity} {puertoSerie.StopBits}";
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "B" */
        private void button_Comando_B_Click(object sender, EventArgs e)
        {
            verComandoBFlag = true;
            puertoSerie.Write(COMANDO_B);
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "X72" */
        private void button_Comando_X72_Click(object sender, EventArgs e)
        {
            verComandoX72Flag = true;
            puertoSerie.Write(COMANDO_X72);
        }
 
        private void button_Comando_X5_Click(object sender, EventArgs e)
        {
            verComandoX5Flag = true;
            puertoSerie.Write(COMANDO_X5);
        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            timer1.Stop();          // Detiene el temporizador.
            Thread.Sleep(700);      // 0.7 segundos. 700 milisegundos.
            puertoSerie.Close();    // Cierra el puerto serie.
        }
 
        private void timer1_Tick_1(object sender, EventArgs e)
        {
            verComandoBFlag = true;
            // Enviar comando B al puerto serie.
            puertoSerie.Write(COMANDO_B);
        }
    }
}
 

A ver si hay suerte y me sale las cosas.

Al final se hace así:

            foreach (byte elemento in recibidos)
            {
                richTextBox1.Text += Convert.ToDecimal(elemento);
            }

Cuyo resultado no es el esperado.

Me da esto:
35735049574657795050484655764849496649484886505446487053484650725348465082484851568363636363636313

El 83 es la S y el 13 es este \r, entre medio hay seis veces el 63, que no debería mostrar porque la conversión está mal, no es el real, el real es el que indiqué antes.
35 73 50 50 51 46 52 79 50 50 52 46 50 76 48 48 55 66 49 48 48 86 50 54 46 48 7
0 53 48 46 49 72 53 48 46 49 82 48 48 56 48 83 144 132 128 136 132 192 13

Se ve que a la hora de recibir datos uso esta variable tipo string.

string recibidos;

Por lo que se ve, no es el adecuado cuando quieres los byte tal cual vienen sin modificar o usar encoder.

Parece ser que la mejor manera es usar una array o matriz como esta:
byte[] = cadenaByte;

Buenas:

Todavía sigo chamusqueándome las neuronas.

Teniendo estos resultados que viene tipo string, lo convierto en hexadecimal y en binario con Windows Form.

¿Cómo se puede capturar los datos exactamente sin editar tal como se recibieron tal como si se muestra abajo?

Precisamente son estos:
35 73 50 50 51 46 52 79 50 50 52 46 50 76 48 48 55 66 49 48 48 86 50 54 46 48 7
0 53 48 46 49 72 53 48 46 49 82 48 48 56 48 83 144 132 128 136 132 192 13

Ver imagen con un terminal que si lo hace.

Ver zoom.

Lo marcado en rojo arriba es justo lo que quiero meter en un array para luego mostrarlo uno a uno en Windows form con su label correspondiente.

Espero que así se entienda mejor.

Código hecho en Windows Form en C# es este:

private void Actualizar(object sender, EventArgs e)
{
 
    // Asignar el valor de la trama al richTextBox.
    richTextBox1.Text += recibidos;
    // Nueva línea.
    richTextBox1.Text += Environment.NewLine;
 
    // Pasar a hexadecimal.
    //foreach (byte b in recibidos)
    foreach (byte b in recibidos.Select(v => (byte)v))
    {
        // x = minúscula, X = mayúscula.
        richTextBox1.Text += b.ToString("X2");
    }
 
    // Nueva línea.
    richTextBox1.Text += Environment.NewLine;
    richTextBox1.Text += Environment.NewLine;
 
    // Pasar a binario.
    foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
    {
        richTextBox1.Text += leer.ToString();
    }
 
    // Nueva línea.
    richTextBox1.Text += Environment.NewLine;
    richTextBox1.Text += Environment.NewLine;
 
    // Selecciona la posición final para leer los mensajes entrantes.
    richTextBox1.SelectionStart = richTextBox1.Text.Length;
 
    // Mantiene el scroll en la entrada de cada mensaje.
    richTextBox1.ScrollToCaret();
 
    // Limpiar.
    recibidos = "";
}

¿Alguna idea?

Saludos.

Una consulta.

A partir de la S en el delimitador indicado abajo.

string entrada = "#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„\r";

Concretamente esto de abajo.

S€„€ˆ„\r

Más aún el:

€„€ˆ„

En realidad es un binario mezclado con caracteres tipo string del principio. Por muy encoder que use el ponerlo en un Windows Form siempre me suelta 63 en decimal.

            foreach (uint b in Encoding.Default.GetBytes(salida[8]))
            {
                //richTextBox1.Text += b.ToString();
                richTextBox1.Text += Environment.NewLine; // Nueva línea.
                richTextBox1.Text += $"Array: {numeros[j] = b}";
                ++j;
            }

Ya que al capturar datos en el puerto serie lo almaceno tipo String.

Parece ser que es mejor optar por almacenar los datos o tramas de bytes que llegan desde el puerto serie en tipo byte[] y usar read.

Uso el protocolo este para el puerto serie.

                puertoSerie = new SerialPort()
                {
                    // Configuración del puerto serie.
                    PortName = "COM3",           // Nombre del puerto serie.
                    BaudRate = 2400,             // Velocidad en baudios.
                    Parity = Parity.None,        // Esquema para comprobar la paridad de cada byte recibido.
                    StopBits = StopBits.One,     // Número de bits de parada por byte.
                    DataBits = 8,                // Número de bits de datos por byte.
                    Handshake = Handshake.None,  // Protocolo de establecimiento.
                    DtrEnable = true,            // Línea de terminal de datos.
                    RtsEnable = true,            // Línea de solicitud.
 
                    // Establecer los tiempos de espera de lectura / escritura.
                    ReadTimeout = 500,           // Tiempo de espera de escritura en ms.
                    WriteTimeout = 500,          // Tiempo de espera de escritura en ms.
 
                    // Más configuraciones.
                    DiscardNull = false,         // Descartar bytes nulos recibidos.
                    ParityReplace = 63,
                    ReadBufferSize = 4096,
                    WriteBufferSize = 2018,
                    ReceivedBytesThreshold = 1
                };

A la hora de recibir datos, mejor obtener ***** bytes sin formato, tal como vienen y almacenarlo.

¿Cuál es la mejor forma para almacenar datos en un array de bytes?

Ya que luego la parte de la S, quiero mostrarlo en decimal para luego verlo en binario.

Saludos.

Muy bueno la idea.

Estaba intentado guardar en un array los resultado que suelta la variable B.

Luego escojo cualquier valor en decimal y lo muestro en pantalla.

¿Cuál es la mejor manera?

El programa tuyo funciona a la primera.

Edito:

            string entrada = "#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„\r";
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r' };
            string[] salida = entrada.Split(separadores);
            uint[] numeros = new uint[6];
            uint j = 0;
 
            for (int i = 2; i < 10; i++)
            {
                Console.WriteLine($"> {salida[i]}");
            }
 
            foreach (uint b in Encoding.Default.GetBytes(salida[10]))
            {
                Console.WriteLine($"> {b}");
                Console.WriteLine($"Array: {numeros[j] = b}");
                ++j;
            }