Funciona tu código.   
Estás hecho un campeón. Gracias a todos. 

El primer código funciona si pongo en vez de byte[] ponerlo a char[], cosa que no me interesa. El tuyo es el que quiero.

Y si, estoy aprendiendo con ejemplos sueltos antes de meterle mano al puerto serie.

Felices fiestas 2023. 

Lo intenté hacer de esta otra forma.

using System;
using System.Text;
 
namespace Almacenar_datos_en_un_array_tipo_byte_Consola_01
{
    internal class Program
    {
        static void Main(string[] args)
        {
 
            // Tamaño máximo del array de bytes.
            byte[] byteArray = new byte[1024]; 
 
            // Convertir de byte[] a char[]
            char[] charArray  = Encoding.Default.GetString(byteArray).ToCharArray();
 
            Console.WriteLine("Escribe un texto y pulsa Enter:");
 
            // Lee los bytes desde la consola y los guarda en el array.
            int leerBytes = Console.In.Read(charArray, 0, charArray.Length); 
 
            Console.WriteLine("Datos almacenados en el array:");
            for (int i = 0; i < leerBytes; i++)
            {
                Console.Write(byteArray[i] + " ");
            }
            Console.WriteLine();
 
            Console.WriteLine("Texto almacenado en el array:");
 
            // Convierte los bytes a una cadena de texto.
            string texto = Encoding.Default.GetString(byteArray, 0, leerBytes); 
            Console.WriteLine(texto);
 
            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

Me lee todo como ceros.

En string no lo prefiero, porque ahora prefiero hacer pruebas directamente en un array, ya que los datos me vienen directamente del puerto serie y debo capturar todo tipo de datos en Bytes, incluyendo /r y /n por poner un ejemplo.

Aún así cuando llegue a mi casa pruebo tu código y muchas gracias.

Luego te comento.

Hola:

Tengo este código y me salta este error. Supuestamente es todo a byte[], nada de char[].

using System;
using System.Text;
 
namespace Almacenar_datos_en_un_array_tipo_byte_Consola_01
{
    internal class Program
    {
        static void Main(string[] args)
        {
            byte[] dataArray = new byte[1024]; // Tamaño máximo del array de bytes.
 
            Console.WriteLine("Escribe un texto y pulsa Enter:");
            int bytesRead = Console.In.Read(dataArray, 0, dataArray.Length); // Lee los bytes desde la consola y los guarda en el array.
 
            Console.WriteLine("Datos almacenados en el array:");
            for (int i = 0; i < bytesRead; i++)
            {
                Console.Write(dataArray[i] + " ");
            }
            Console.WriteLine();
 
            Console.WriteLine("Texto almacenado en el array:");
            string text = Encoding.Default.GetString(dataArray, 0, bytesRead); // Convierte los bytes a una cadena de texto.
            Console.WriteLine(text);
        }
    }
}

Justo aquí.

int bytesRead = Console.In.Read(dataArray, 0, dataArray.Length); // Lee los bytes desde la consola y los guarda en el array.

En el primer dataArray.

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.