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;
            }

Esta parte de la trama.

S€„€ˆ„\r

No hay que hacer caso.

Si no leerlo justo cuando entra antes del string, aunque en realidad mejor pasarlo a byte[] ya que lee bien, justo lo que es, y luego pasarlo a decimales.

Es lo que quiero hacer. Porque ahora mismo da lectura erronea.

Hola:

En una variable tipo string[] tengo esto usando el lenguaje C# en decimal.

#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„\r

En otra variable string[] tengo lo mismo pero los datos en decimales.

string entrada2 = "35 73 50 51 53 46 51 79 50 51 53 46 55 76 48 48 54 66 49 48 48 86 50 54 46 48 70 53 48 46 50 72 53 48 46 50 82 48 48 56 48 83 144 132 128 136 132 192 13";

Si te fijas bien en el primer delimitador a partir de la S son bits, la trama comparte entre string y nivel a bits, es decir, usa distinto tipos de datos.

La S muestra esto.
S€„€ˆ„\r

Siempre estas cadenas empieza con # y acaba con \r. No se si hace falta usar StartsWith y EndsWith.

Tabla ASCII.


Fijándose en la tabla ASCII la S rn decimal es 83. A partir de ahí en la cadena entrada2 tiene 144 132 128 136 132 192 y el final que es retorno de carro es el 13 en decimal.

Ya que se lee bien los string de esta linea I225.7O226.2L006B100V25.7F50.2H50.2R0080S y después de la S me da disparates como esto: S€„€ˆ„\r, mejor pasarlo a decimal que es esto otro 144 132 128 136 132 192.

El resultado si ejecuto el código completo es este:


La idea es que muestre bien los datos completo al recibirlos, no en en tipo string y entre medio bit, es decir, datos de distintos tipos.

Parece ser que debo capturar o coger estos datos:
I225.7O226.2L006B100V25.7F50.2H50.2R0080

Separarlos y mostralo así:
225.7
226.2
006
100
25.7
50.2
50.2
0080
€„€ˆ„

Como se puede ver, se muestra esto de la S.
€„€ˆ„

Es ilegible, debería mostrarse así y separados al menos en decimal que se entiende mejor como muestra justo abajo.
144
132
128
136
132
192

¿Existe alguna forma posible que muestre bien la trama completa?

Dejo el código de ejemplo en Visual C#:

namespace Probando_tramas_para_el_SAI_UPS_01___.NET_6._0
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.Text = "Probando tramas de bytes";
        }
 
        private void button_Ver_Click(object sender, EventArgs e)
        {
            // Tramas de bytes con diferentes tipos de datos. A partir de la S, son bits.
            // Siempre la trama empieza con # y acaba con retorno de carro \r. <cr>.
            string entrada = "#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„\r";
            string entrada2 = "35 73 50 51 53 46 51 79 50 51 53 46 55 76 48 48 54 66 49 48 48 86 50 54 46 48 70 53 48 46 50 72 53 48 46 50 82 48 48 56 48 83 144 132 128 136 132 192 13";
 
            // Delimitador para separar tramas.
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r' };
 
            // Cortar tramas y lo alacemna en una variable array tipo string.
            string[] salida = entrada.Split(separadores);
 
            foreach (string item in salida)
            {
                richTextBox1.Text += item;
                richTextBox1.Text += Environment.NewLine;
            }
 
            // Nueva línea.
            richTextBox1.Text += Environment.NewLine;
            richTextBox1.Text += Environment.NewLine;
 
            // --------------
 
            string[] salida2 = entrada2.Split(separadores);
 
            foreach (string item2 in salida2) 
            {
                richTextBox1.Text += item2;
            }
        }
    }
}

Un cordial saludos.

Saludos.

Hola:

Quiero enviar el comando B cada 3 segundos (3000 milisegundos) y el timer no funciona. Estoy trabajando en el :NET 8.0 y la verdad que falla más que una escopeta de feria, a parte que los textos de ayuda o errores del compilador se quitó el español y está en Inglés, un desastre.

En fin, dejo el código haber si sabes hacerlo o me quedo otra vez con el .Net 4.8.


Ver zoom.

Código C#:

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;
        public const string COMANDO_B = "B\r";
        const string COMANDO_X72 = "X72\r";
        const string COMANDO_X5 = "X5\r";
 
        public Form1()
        {
            InitializeComponent();
            InitSerialPort();
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            timer1.Start();
        }
        /* Iniciar y configurar el puerto serie */
        private void InitSerialPort()
        {
            try
            {
                //Encoding cp437 = Encoding.GetEncoding(437);
 
                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
                };
 
                // Abrir puerto serie.
                puertoSerie.Open();
 
                // Subscribir el evento DatosRecividos cuando lleguen datos.
                puertoSerie.DataReceived += DatosRecividos;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                puertoSerie.Close(); // Cierra el puerto en caso de error
            }
        }
 
        /* Evento para leer asíncronamente datos del puerto serie */
        void DatosRecividos(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) { ProcessCOMANDO_B(cadena); }
                        if (verComandoX72Flag) { ProcessCOMANDO_X72(cadena); }
                        if (verComandoX5Flag) { ProcessCOMANDO_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 ProcessCOMANDO_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(() =>
                {
                    UpdateUIControlsComandoX5(salida);
                }));
            }
            else
            {
                UpdateUIControlsComandoX5(salida);
            }
        }
 
        /* Procesar COMANDO_X72 */
        private void ProcessCOMANDO_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(() =>
                {
                    UpdateUIControlsComandoX72(salida);
                }));
            }
            else
            {
                UpdateUIControlsComandoX72(salida);
            }
        }
 
        /* Procesar COMANDO_B */
        private void ProcessCOMANDO_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(() =>
                {
                    UpdateUIControlsComandoB(salida);
                }));
            }
            else
            {
                UpdateUIControlsComandoB(salida);
            }
        }
 
        /* Mostrar datos COMANDO_X5 */
        private void UpdateUIControlsComandoX5(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 UpdateUIControlsComandoX72(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 UpdateUIControlsComandoB(string[] salida)
        {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
            label_B.Text
                = salida[3].TrimStart('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[3]);
            progressBar_B.Value = (int)barraProgresoB;
        }
 
        /* 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.5 segundos. 500 milisegundos.
            puertoSerie.Close();    // Cierra el puerto serie.
        }
 
        private void timer1_Tick_1(object sender, EventArgs e)
        {
            // Enviar comando B al puerto serie.
            puertoSerie.Write(COMANDO_B);
        }
    }
}

En resumen, quiero que se active el timer, por mucho que le de estas instrucciones que hace lo mismo, no funciona.

timer1.Enable = true;
 
timer1.Start();

Gracias.
Gracias.

Funciona gracias a ti. 

Eso sí, cambiaré en vez de recoger una cadena tipo string mejor tipo byte ya que en la tabla ASCII usa las 255 caracteres y muchos no son visuales sino de comportamientos.

https://learn.microsoft.com/es-es/dotnet/api/system.io.ports.serialport.read?view=dotnet-plat-ext-7.0

Haber si puedo cambiarlo sin que afecte su funcionamiento.

Buenos días.

El puertoSerie.Open(); se tiene que poner desde el principio, para que quede abierto siempre.

Ahora el programa si funciona.

Lo tendré que pulir después cuando salga de trabajar.

Dejo el código aquí y gracias a tu ayuda ya funciona todo.

A parte de esto, hay más comandos que enviar, espero que tu programa me sirva de ejemplo para que se me ejecuten todos.

Dejar claro que si hay algún error, me por ejemplo, al enviar un comando que no existe me viene con este error:
#-0\r

Si lo has hecho bien, en algunos comando devuelve uno similar pero sin guión en medio -.
#0\r

Otro errores que no se cual es son.
#3\r
#4\r
#10\r

Y no recuerdo más. Son errores que ya pondré en un label.

using System.IO.Ports;
 
namespace Termite_SAI_05_.NET_8._0
{
    public partial class Form1 : Form
    {
        SerialPort puertoSerie;
        bool verComandoBFlag = false;
        bool verComandoX72Flag = false;
        readonly string verComandoBReq = "B\r";
        readonly string verComandoX72Req = "X72\r";
 
        private void Form1_Load(object sender, EventArgs e)
        {
 
        }
 
        public Form1()
        {
            InitializeComponent();
            InitSerialPort();
        }
 
        /* Iniciar y configurar el puerto serie */
        private void InitSerialPort()
        {
            try
            {
                puertoSerie = new SerialPort("COM3", 2400,
                    Parity.None, 8, StopBits.One)
                {
                    Handshake = Handshake.None,
                    ReadTimeout = 500,
                    WriteTimeout = 500,
                    DtrEnable = true,
                    RtsEnable = true,
                    DiscardNull = false,
                    ParityReplace = 63,
                    ReadBufferSize = 4096,
                    WriteBufferSize = 2018,
                    ReceivedBytesThreshold = 1
                };
 
                // Abrir puerto serie.
                puertoSerie.Open();
 
                // Subscribir el evento Sp_DataReceived cuando lleguen datos
                puertoSerie.DataReceived += Sp_DataReceived;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                puertoSerie.Close(); // Cierra el puerto en caso de error
            }
        }
 
        /* Evento para leer asíncronamente datos del puerto serie */
        void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                Task.Run(async () =>
                {
                    try
                    {
                        await Task.Delay(500); // Pausa para recibir datos
                        string str = puertoSerie.ReadExisting();
                        if (!String.IsNullOrEmpty(str))
                        {
                            if (verComandoBFlag) { ProcessverComandoBReq(str); }
                            if (verComandoX72Flag) { ProcessverComandoX72Req(str); }
                        }
                        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 verComandoX72Req */
        private void ProcessverComandoX72Req(string str)
        {
            verComandoX72Flag = false;
            char[] separadores = { '#', ',' };
            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(() =>
                {
                    UpdateUIControlsComandoX72(salida);
                }));
            }
            else
            {
                UpdateUIControlsComandoX72(salida);
            }
        }
 
        /* Procesar verComandoBReq */
        private void ProcessverComandoBReq(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(() =>
                {
                    UpdateUIControlsComandoB(salida);
                }));
            }
            else
            {
                UpdateUIControlsComandoB(salida);
            }
        }
 
        /* Mostrar datos verComandoX72Req */
        private void UpdateUIControlsComandoX72(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 verComandoBReq */
        private void UpdateUIControlsComandoB(string[] salida)
        {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
            label_B.Text
                = salida[3] + " %";
            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 int, es decir, la variable tipo string "salida[7]"
            // se convierte en tipo int "resultadoSalida7".
            int resultadoSalida7 = Int32.Parse(salida[7]);
 
            #region Horas y minutos.
            // Cálculos.
            int horas = resultadoSalida7 / 60;
            int 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
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "B" */
        private void button_Comando_B_Click(object sender, EventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                verComandoBFlag = true;
                //puertoSerie.Open();
                puertoSerie.Write(verComandoBReq);
            }
            else
            {
                MessageBox.Show("Puerto cerrado. " +
                "No se puede solicitar datos.");
 
            }
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "X72" */
        private void button1_Click(object sender, EventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                verComandoX72Flag = true;
                //puertoSerie.Open();
                puertoSerie.Write(verComandoX72Req);
            }
            else
            {
                MessageBox.Show("Puerto cerrado. " +
                    "No se puede enviar datos.");
            }
        }
    }
}

Una cosa muy importante. No sé si se puede corregir con estos código o hay que empezar desde cero.

Para mi s muy buena idea recibir las tramas de Bytes en Bytes y no en string.

¿Es posible hacerlo?


Muchísimas gracias mi muy distinguido amigo. 

.

Hola de nuevo.

He modificado nombre de las variables y lo he adaptado el Windows Form .net 4.8 al .net 8.0.

Me sale este error: Puerto cerrado.

using System.IO.Ports;
 
namespace Termite_SAI_05_.NET_8._0
{
    public partial class Form1 : Form
    {
        SerialPort puertoSerie;
        bool verComandoBFlag = false;
        bool verComandoX72Flag = false;
        readonly string verComandoBReq = "B\r";
        readonly string verComandoX72Req = "X72\r";
 
        private void Form1_Load(object sender, EventArgs e)
        {
 
        }
 
        public Form1()
        {
            InitializeComponent();
            InitSerialPort();
        }
 
        /* Iniciar y configurar el puerto serie */
        private void InitSerialPort()
        {
            try
            {
                puertoSerie = new SerialPort("COM3", 2400,
                    Parity.None, 8, StopBits.One)
                {
                    Handshake = Handshake.None,
                    ReadTimeout = 500,
                    WriteTimeout = 500,
                    DtrEnable = true,
                    RtsEnable = true
                };
 
                // Subscribir el evento Sp_DataReceived cuando lleguen datos
                puertoSerie.DataReceived += Sp_DataReceived;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                puertoSerie.Close(); // Cierra el puerto en caso de error
            }
        }
 
        /* Evento para leer asíncronamente datos del puerto serie */
        void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                Task.Run(async () =>
                {
                    try
                    {
                        await Task.Delay(500); // Pausa para recibir datos
                        string str = puertoSerie.ReadExisting();
                        if (!String.IsNullOrEmpty(str))
                        {
                            if (verComandoBFlag) { ProcessverComandoBReq(str); }
                            if (verComandoX72Flag) { ProcessverComandoX72Req(str); }
                        }
                        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 verComandoX72Req */
        private void ProcessverComandoX72Req(string str)
        {
            verComandoX72Flag = false;
            char[] separadores = { '#', ',' };
            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(() =>
                {
                    UpdateUIControlsVerTabla(salida);
                }));
            }
            else
            {
                UpdateUIControlsVerTabla(salida);
            }
        }
 
        /* Procesar verComandoBReq */
        private void ProcessverComandoBReq(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(() =>
                {
                    UpdateUIControlsVerDatos(salida);
                }));
            }
            else
            {
                UpdateUIControlsVerDatos(salida);
            }
        }
 
        /* Mostrar datos verComandoX72Req */
        private void UpdateUIControlsVerTabla(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 verComandoBReq */
        private void UpdateUIControlsVerDatos(string[] salida)
        {
            label_I.Text
                  = salida[0] + " Vac";
            label_O.Text
                = salida[1] + " Vac";
            label_L.Text
                = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
            label_B.Text
                = salida[3] + " %";
            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 int, es decir, la variable tipo string "salida[7]"
            // se convierte en tipo int "resultadoSalida7".
            int resultadoSalida7 = Int32.Parse(salida[7]);
 
            #region Horas y minutos.
            // Cálculos.
            int horas = resultadoSalida7 / 60;
            int 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
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "B" */
        private void button_Comando_B_Click(object sender, EventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                verComandoBFlag = true;
                puertoSerie.Open();
                puertoSerie.Write(verComandoBReq);
            }
            else
            {
                MessageBox.Show("Puerto cerrado. " +
                "No se puede solicitar datos.");
 
            }
        }
 
        /* Evento de botón: Abrir puerto serie y mandar "X72" */
        private void button1_Click(object sender, EventArgs e)
        {
            if (puertoSerie.IsOpen)
            {
                verComandoX72Flag = true;
                puertoSerie.Open();
                puertoSerie.Write(verComandoX72Req);
            }
            else
            {
                MessageBox.Show("Puerto cerrado. " +
                    "No se puede enviar datos.");
            }
        }
    }
}
 
 

Algo pasa que no me deja abrir el puerto.

Está bien.

Lo se.
Gracias 🙂