Hola:

A la salida del programa en C# me muestra estos valores.

52.21

51.63

Como puedes ver arriba, ninguno termina en 0.

Si fuese 52.2 y 51.6

En el programa quiero que se añada un 0 a la derecha y se me queda con dos decimales, por ejemplo, quedaría así:

52.20

51.60

Solo si muestra solo un decimal, si muestra 52.21, tiene que ser 52.21, no 52.210 que sería tres decimales.

Hola:

Teniendo esta entrada de bytes por el puerto serie:
#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„À

O otra trama de byte diferente como este:
#2000,1400,230,45.0,55.0,8.6

Si se fijan, cada trama de bytes empieza por #.

Haciendo pruebas dando las gracias a los compañeros de este foro, quiero saber si a la entrada de datos es capaz de detectar cada trama de byte recibida se muestre correctamente en sus label como indica abajo.


Ver zoom.

Su código es este:

using System;
using System.Windows.Forms;
 
namespace Termite_SAI_03
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button_Ver_datos_Click(object sender, EventArgs e)
        {
            string entrada = "#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„À";
 
            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S' };
 
            string[] salida = entrada.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
 
            label_I.Text = salida[0] + " V";
            label_O.Text = salida[1] + " V";
            label_L.Text = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
            label_B.Text = salida[3] + " %";
            label_V.Text = salida[4] + " V";
            label_F.Text = salida[5] + " Hz";
            label_H.Text = salida[6] + " 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]);
 
            // ¿Es igual a 1 minuto?
            if ((resultadoSalida7 % 60) == 1)
            {
                label_R.Text = resultadoSalida7 / 60 + " hora y " + resultadoSalida7 % 60 + " minuto.";
            }
 
            // ¿Es mayor a 60 segundos o 1 minuto?
            if ((resultadoSalida7 % 60) > 1)
            {
                label_R.Text = resultadoSalida7 / 60 + " hora y " + resultadoSalida7 % 60 + " minutos.";
            }
 
            // ¿Es igual a 60 segundos o 1 minuto?
            if ((resultadoSalida7 % 60) == 0)
            {
                label_R.Text = resultadoSalida7 / 60 + " hora y " + resultadoSalida7 % 60 + " minutos.";
            }
        }
 
        private void button_Ver_Tabla_Click(object sender, EventArgs e)
        {
            string entrada2 = "#2000,1400,230,45.0,55.0,8.6";
 
            char[] separadores2 = { '#', ',' };
 
            string[] salida2 = entrada2.Split(separadores2, StringSplitOptions.RemoveEmptyEntries);
 
            label_Resultado_valores_nonimales_de_alimentacion.Text = salida2[0] + " VA / " + salida2[1] + " W";
            label_Resultado_voltaje_nominal.Text = salida2[2] + " V";
            label_Resultado_corriente_nominal.Text = salida2[5] + " A";
            label_Resultado_valores_nominales_de_frecuencia.Text = salida2[3] + " ~ " + salida2[4] + " Hz";
        }
    }
}
 

Por ahora no te tocado nada del puerto serie, solo muestro con botones de prueba a la hora de recibir datos y mostrar su información en Windows Form.

Saludos.

Hola:

Quiero enviar datos al puerto serie con un archivo bat o cmd.



El código es este.

    @Echo OFF
    title Arduino CMD y puerto serie
 
    CHCP 1252 >Nul
    MODE.com COM5 BAUD=115200 PARITY=n DATA=8 STOP=1
    :Menu
        CLS
        echo.
        echo.
        echo.                   1.- Luz  ON
        echo.
        echo.                   2.- Luz  OFF
        echo.
        echo.                   3.- Salir
        echo.
        echo.
        echo.
 
        CHOICE.exe /C "123" /M "                   Escoge una opción "
        echo.
        echo.
        echo.
 
        If %ErrorLevel% EQU 1 (
            copy puerto_Luz_ON.txt  COM5:
            echo Puerto COM5: Luz ON
            timeout 1 >nul
            goto Menu
        )
 
        If %ErrorLevel% EQU 2 (
            copy puerto_Luz_OFF.txt COM5:
            echo Puerto COM5: Luz OFF
            timeout 1 >nul
            goto Menu
        )
 
        Pause
 
        Exit /B

Parece ser que envía al puerto serie algo.

Me falta hacer otro cmd que reciba los datos.

¿Cómo se hace?

Gracias.

Hola:

Teniendo Windows Form con el lenguaje C#. Quiero leer los bytes puros y duros de las tramas de bytes que me llega desde un puerto serie. Con esto quiero decir, que no quiero usar encoder.

Me imagino que las tramas de Bytes recibidos se almacenará tipo array por cada byte recibido. Byte[].

Si recibo esta trama de bytes como en este ejemplo:
#I225.2O225.7L007B100V25.8F50.2H50.2R0080S�„€ˆ„À

Al recibir dicha trama de bytes de arriba, quiero almacenarlo en byte[] o lo que es lo mismo, meter cada byte recibidos desde el puerto serie, en un array tipo byte. Hay gente que lo meten en un string, también usan encoder. Prefiero recibir los bytes exactos desde el puerto serie. Usamos PCI o placas que tiene puerto serie como en este ejemplo.

Se que para enviar tramas de bytes puros se envía así:

serialPort1.Write("#I225.2O225.7L007B100V25.8F50.2H50.2R0080S�„€ˆ„À");

El problema es recibir dicha trama y mostrarla en un label.

¿Cuál es la mejor manera de recibir dichas tramas, almacenarlas en una variable tipo array y luego mostrarla en un label?

Saludos.

Hola:

Cuando introduzco en modo consola por ejemplo, si pongo 80 minutos me da este resultado. Si te fijas bien, minutos en plural. Si se pone 1 minuto, tiene que dar singular, sin la s al final.
1 hora y 20 minutos.

Si introduzco 61 minutos me muestra esto:
1 hora y 1 minuto.

Si introduzco 60 minutos, no me dice absolutamente nada en pantalla, se queda en blanco. Ahí el problema.

Código hecho hasta ahora de C#:

using System;
 
namespace Minutos_Horas_Consola_03
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int totalMinutos;
            Console.Write("Ingresa el valor de minutos: ");
            totalMinutos = int.Parse(Console.ReadLine());
 
            if ((totalMinutos % 60) == 1) 
            {
                Console.WriteLine(totalMinutos / 60 + " hora y " + totalMinutos % 60 + " minuto.");
            }
            if ((totalMinutos % 60) > 1)
            {
                Console.WriteLine(totalMinutos / 60 + " hora y " + totalMinutos % 60 + " minutos.");
            }
 
 
 
            Console.WriteLine();
            Console.Write("Presiona una tecla para terminar . . . ");
            Console.ReadKey();
        }
    }
}

PD: Se usa Visual Studio Community 2022 y .Net 4.8.

¿Cómo están compañeros del foro?

Se trata de que uso un terminal llamado Termite gratuito que lee el puerto serie, envío una letra B mayúscula y seguido envía también el \r.



La configuración es esta:


Como dije arriba, con Termite he enviado el comando B. Su respuesta es esta:

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

A partir de la página 4 indica el comando a enviar que es el B y luego explica todo lo que recibe después.

Ver documento PDF.

En el programa Termite al enviar el comando B, recibe toda una trama de Bytes en el cual quiero ponerlo por separado en  Windows Form 4.7.2 .net o superior con Visual Studio Community 2022 gratuito.

En la versión que tengo, no se usa la C, T ni la Q. De todas formas al recibir las tramas de Bytes lo vas a ver.

Leer la S de forma independiente lo veo complicado, lo dejaré más adelante hasta cuando consiga lo más sencillos.

Quiero saber la forma más directa que al recibir la trama de Bytes, al menos me centro en vez de esto con la S:
#I226.6O226.6L006B100V25.7F50.2H50.2R0120S€„€ˆ„À

Me centro sin la S con esto indicado abajo:
#I226.6O226.6L006B100V25.7F50.2H50.2R0120

Me imagino que todo esto se almacenará en una variable tipo string, luego habrá que separarlo por cada textBox que se muestre.

Ejemplo con Windows Form.


¿Algún ejemplo de cómo separar la trama de Bytes y mostrarlo de forma independiente en el Windows Form en código C#?

Muchas gracias por leer hasta aquí.

Hola:

Estaba pensando en hacer un programa con Windows Form, que lea archivos hex. Se puede abrir con este programa mismo llamado HxD.

Por ejemplo, puedes ver en un archivo de una imagen esto pero solo pongo un trozo que es largo.


Quiero hacer un programa en C#, al menos tener una idea de que al abrir y leer el archivo hex, busque en una dirección en concreta. Por ejemplo, la indicada abajo. En la dirección 7006, en el cual en hex tiene el valor 56 y en ASCII al lado es una letra mayúscula V.


Si pulsas un botón en el formulario, en un textBox muestra dicho valor 56 y el otro textBox la letra V.

Hasta ahí bien.

Hay que hacer una especie de diccionario llenos de if, en el que si detecta el 56, en un tercer textBox muestre un mensaje, Español. Si detecta el 57, que muestre Italia, si es el 58 que muestre Portugal. Si en esos if hay otro valor que no esté incluido, que muestre en el tercer textBox, DESCONOCIDO.

Hablando parece fácil.

¿Es muy complicado de hacer?

Tampoco quiero pegarme media vida averiguar como se hace.

Recuerdo que estamos hablando de un solo Byte, no de varios. Que si se puede, también me vale.

Saludos.

Hola gente:

Compré el PC en el 2021 con Windows 10 de 64 bits. La verdad, que navegar, o hacer algo en Windows 10 hasta me tarda más de un minuto en abrir una pestaña. Me di cuenta que por cada actualizaci´pn que hiciera en Windows Update ya se ponía bien. Hasta un punto, porque todo ya está actualizado y me vuelve el problema de las telantizaciones descomunales.

Usando antivirus y ni esas. Quito el antivirus por si acaso y sigue igual.

Me han contado algunas personas que a veces se te queda lento adrede por algún motivo.

¿Hay alguna solución a esto que no sea formatear?

Saludos.

Hola:

Hice un código por parte que vino en un libro de C para Arduino. Este código dice que se puede mejorar que es este. Para ser de un libro, la gente no le gusta un pelo.

Lo que hace el programa es recibir comandos por puerto serie. También recibe datos.

#include <LiquidCrystal.h>
 
// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;
 
const byte Led = 13;              // Declaramos la variable pin del Led.
char caracter;
String comando;
 
void setup()
{
  pinMode(Led, OUTPUT);           // Inicializa el pin del LED como salida:
  Serial.begin(115200);           // Puerto serie 115200 baudios.
  lcd.begin(16, 2);               // Formato de pantalla.
  lcd.clear();                    // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}
 
void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }
 
  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */
 
  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }
 
 
  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }
 
    if (comando.equals("Salir") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("Ha salido de C#.");  // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print("Ha salido de C#."); // Mostrar en el LCD.
  }
 
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}
 

He hecho aquí abajo algunos consejos que me dieron por ahí y por allá.

#include <LiquidCrystal.h>
 
// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;
 
const byte Led = 13;  // Declaramos la variable pin del Led.
char caracter;
String comando;
 
void setup() 
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);  // Puerto serie 115200 baudios.
  lcd.begin(16, 2);      // Formato de pantalla.
  lcd.clear();           // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
  Serial.setTimeout(5);  //Tiempo maximo de espera en ms para el dato en el puerto.
}
 
void loop() 
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0) 
  {
    comando = Serial.readString();  // Lees el stream directamente, la lectura termina segun el timeOut establecido.
    comando.trim();                 // Limpia tabulaciones, espacios en blanco, \r, \n, etc.
  }
 
  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */
 
  // Si los carácteres es recibido y verdadero.
  if (comando.startsWith(F("Luz_ON")) == true) 
  {
    digitalWrite(Led, HIGH);                 // Enciende el Led 13.
    Serial.print(F("ON - Led encendido."));  // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print(F("Luz ON.         "));        // Mostrar en el LCD.
  }
 
 
  if (comando.startsWith(F("Luz_OFF")) == true) 
  {
    digitalWrite(Led, LOW);                  // Apaga el Led 13.
    Serial.print(F("OFF - Led apagado. "));  // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print(F("Luz OFF.        "));        // Mostrar en el LCD.
  }
 
  if (comando.startsWith(F("Salir")) == true) 
  {
    digitalWrite(Led, LOW);                  // Apaga el Led 13.
    Serial.print(F("Ha salido de C++.  "));    // Envía este mensaje a C++.
    lcd.setCursor(0, 1);
    lcd.print(F("Ha salido de C++"));        // Mostrar en el LCD.
  }
 
  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}

Todavía me dice que es muy horrible. A pesar de que funciona bien, pues no es la mejor manera.

Entonces hago esta pregunta.

¿Cuál es la mejor manera?

Ninguno me dice como hacerlo o ponen ejemplos para coger ideas.

El programa de abajo es una interfaz que comunica desde el PC por puerto serie/USB con Arduino bajo Visual Studio Community 2022. Está hecho con C++ nativo.

Puedes enviar comandos pulsando la tecla 1, 2 y 3.

#include <iostream>
#include <fstream>
#include <conio.h>      // Controla el _getch.
#include <Windows.h>    // Para mostrar texto en el título de la ventana.
#include <stdio.h>      // Cambio color de fondo y letras.
#include "SerialClass.h"
 
using namespace std;
//using std::cout;
//using std::cin;
 
// Función posición del cursor.
void gotoxy(int ancho_x, int alto_y)
{
    HANDLE hcon;
    hcon = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD dwPos{};
    dwPos.X = ancho_x;
    dwPos.Y = alto_y;
    SetConsoleCursorPosition(hcon, dwPos);
}
 
int main()
{
 
#pragma region "Configuración ventana."
    // Mostrar caracteres correctamente en pantalla y título de la ventana.
    SetConsoleOutputCP(65001);
    wchar_t titulo[128];
    MultiByteToWideChar(CP_UTF8, 0, "Led Arduino C++ nativo", -1, titulo, 128);
    SetConsoleTitleW(titulo);
 
    // Tamaño de la pantalla. Se cambia en los dos últimos dígitos.
    SMALL_RECT r = { 0, 0, 80, 20 }; // X = 80, Y = 20.
    SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &r);
 
    // Cambio color de 6 (naranja / amarillo claro), color letras 0 (negro).
    system("color 60");
 
    // Ocultar cursor.
    CONSOLE_CURSOR_INFO cci;
    GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
    cci.bVisible = 0; // 0 oculta. 1 muestra cursor.
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
#pragma endregion
 
 
 
    // Comandos para Arduino.
    char Luz_ON[] = "Luz_ON";       // Envía "Luz_ON" al puerto serie.
    char Luz_OFF[] = "Luz_OFF";
    char salir[] = "Salir";
    char limpiar7[] = "       ";    // Siete espacios en blanco para limpiar un área seleccionado.
    char lectura[50] = "\0";        // Guardan datos de entrada del puerto.
    char tecla;                     // Guarda un 1, 2 o un 3 tipo entero que introduces desde la consola.
 
    // Puerto serie.
    Serial* Puerto = new Serial("COM4");
 
    gotoxy(0, 0);                   // Posición de la pantalla.
    cout << endl;                   // Retorno.
    cout << "Introduzca la opción deseada: " << endl;
    cout << "Pulse 1 para encender el Led y 2 para apagar." << endl << endl;
 
    while (Puerto->IsConnected())
    {
        tecla = _getch();           // Aquí introduces un número, el 1, 2 o el 3.
 
        switch (tecla)              // Espera recibir un 1, 2 o el 3.
        {
        case '1':
            // Encener luz.
            gotoxy(10, 5);
            cout << limpiar7;
            gotoxy(0, 5);
            cout << "Enviando: " << Luz_ON << endl;         // Muestra en pantalla textos.
            Puerto->WriteData(Luz_ON, sizeof(Luz_ON) - 1);  // Envía al puerto el texto "Luz_ON".
            gotoxy(0, 9);
            cout << "                               ";      // Borrado del mensaje si haz pulsado distinto del 1 o la tecla 2.
            break;
 
        case '2':
            // Apagar luz.
            gotoxy(10, 5);
            cout << limpiar7;
            gotoxy(0, 5);
            cout << "Enviando: " << Luz_OFF << endl;
            Puerto->WriteData(Luz_OFF, sizeof(Luz_OFF) - 1);
            gotoxy(0, 9);
            cout << "                               ";
            break;
 
        case '3':
            // Salir.
            gotoxy(10, 5);
            cout << limpiar7;
            gotoxy(0, 5);
            cout << "Enviando: " << salir << endl;
            Puerto->WriteData(salir, sizeof(salir) - 1);
            gotoxy(0, 9);
            cout << "                               ";
            break;
 
        default: // Si haz pulsado otro número distinto del 1 y 2, muestra
            gotoxy(0, 9);
            cout << "Pulse las teclas el 1, el 2 y el 3 para salir.";  // este mensaje.
        }
 
        Sleep(500);
        int numeros = Puerto->ReadData(lectura, 49);            // Recibe datos del puerto serie.
        if (numeros > 0)
        {
            lectura[numeros + 1] = '\0';                        // Limpia de basura la variable.
            gotoxy(0, 7);
            cout << "Recibido: " << lectura << endl;            // Muestra en pantalla dato recibido.
            cout << "-----------------------------" << endl;
        }
    }
    return 0;
}

¿Algún consejo?

Saludos camaradas.

Hola:

Teniendo este programa hecho que es un char mini por puerto serie. Puedo enviar mensajes pero no se si en el otro PC lo ha recibido.

De alguna forma, quiero saber antes que nada una buena idea para poder implementarlo en este programa.

Por ejemplo, si envío un hola mundo, en el chat mio tiene que mostrarme o indicarme con algo aunque sea una V, que ese mensaje ha sido realmente enviado al otro chat. Si no lo tiene activo o no lo ha recibido, que lo indique también.

Dejo el programa normal completo aquí. Solo a partir de aquí hay que incorporar esta nueva idea, que en realidad es sacado de los Whatsapp, pero bueno.

Código C#:

using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Threading;
 
namespace Chat_Consola_.net_7_01
{
    class Program
    {
        static bool _continua;
        static SerialPort? Puerto_serie;
 
        static void Main(string[] args)
        {
            const int MAXIMA_LONGITUD = 40000;
            string COM = "";
            string nombre;
            string mensaje;
            string titulo = "Mini chat C# .net 7.0";
 
            StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
            Thread readThread = new(Leer);
 
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = titulo;
 
            // 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.Green;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Black;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            #region Configuración puerto serie.
            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            Puerto_serie = new SerialPort();
 
            // Codificar a UTF-8 para que se vean bien las tildes, ñ y otros caracteres.
            Puerto_serie.Encoding = Encoding.UTF8;
 
            // Obtenga una lista de nombres de puertos serie.
            string[] puertos = SerialPort.GetPortNames();
 
            Console.WriteLine("Se encontraron los siguientes puertos series:");
 
            // Muestre el nombre de cada puerto en la consola.
            foreach (string puerto in puertos)
            {
                Console.WriteLine(puerto);
            }
 
            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.
 
Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear(); // Limpiar pantalla.
 
            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
 
            // Configuración del puerto serie.
            Puerto_serie.BaudRate = 115200;
            Puerto_serie.Parity = Parity.None;
            Puerto_serie.StopBits = StopBits.One;
            Puerto_serie.DataBits = 8;
            Puerto_serie.Handshake = Handshake.None;
            Puerto_serie.RtsEnable = true;
 
            // Establecer los tiempos de espera de lectura / escritura.
            Puerto_serie.ReadTimeout = 500; // 500 Milisegundos.
            Puerto_serie.WriteTimeout = 500; // 500
 
            // Comprueba si puede abrir el puerto serie.
            try
            {
                Puerto_serie.Open(); // Abrir el puerto serie.
            }
 
            // En caso que diera algún error como que no encuentra el puerto seleccionado
            // muestra una excepción.
            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
                o no lo encuentra.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }
 
            // Se ha denegado el acceso al puerto.
            catch (UnauthorizedAccessException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"Se ha denegado el acceso al puerto " + Puerto_serie.PortName +
                                "" +
                                "\nPuede estar el puerto escogido en uso.\n" +
                                "Elija un puerto diferente o desactiva el que está en uso.");
                Console.ReadKey();   // Pulse cualquier tecla.
                Environment.Exit(1); // Salir de la aplicación.
            }
            #endregion
 
            _continua = true;
            readThread.Start();
 
            // Mostrar texto Nombre y se
            Console.Write("Nombre: ");
 
            // guarda en la variable nombre.
            nombre = Console.ReadLine();
 
            // Se muestra el nombre o nick y el puerto seleccionado al final del título de la ventana.
            Console.Title = titulo + "- Nick: " + nombre + " - COM: " + COM;
 
            Console.WriteLine("Escriba /salir para salir.");
 
            while (_continua)
            {
                // Cualquier caracter recibido se guarda en la variable mensaje.
                //mensaje = Console.ReadLine();
 
                #region Enviar más de 255 caracteres.
                // #########################################################################
                Stream entradaDeDatos = Console.OpenStandardInput();
                byte[] buffer = new byte[MAXIMA_LONGITUD];
                int numerosBytesLeidos = entradaDeDatos.Read(buffer, 0, MAXIMA_LONGITUD);
                char[] chars = Console.InputEncoding.GetChars(buffer, 0, numerosBytesLeidos);
                mensaje = new string(chars);
                // #########################################################################
                #endregion
 
                // Compara /salir con el mensaje /salir si lo haz escrito igual.
                // ¿Escribiste la palabra /salir?
                if (comparaString.Equals("/salir\r\n", mensaje))
                {
                    // Sí. Entonces, pone esta variable _continue en false.
                    _continua = false;
                }
                // No. Entonces, envía por el puerto serie tu nick
                // y mensaje que haz escrito.
                else
                {
                    Puerto_serie.WriteLine(String.Format("<{0}>: {1}", nombre, mensaje));
                }
            }
 
            // Bloquea el subproceso.
            readThread.Join();
 
            // Cierra el puerto serie.
            Puerto_serie.Close();
        }
 
        // Lee mensaje recibido.
        public static void Leer()
        {
            // Si _continua es true se ejecuta todas las instrucciones dentro de while.
            while (_continua)
            {
                try
                {
                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
                    string mensaje = Puerto_serie.ReadLine();
 
                    // Muestra en pantalla mensaje recibido.
                    Console.WriteLine(mensaje);
                }
                catch (TimeoutException) { }
                catch (IOException)
                {// 'Se devolvió esta operación porque se agotó el tiempo de espera. : ' }
                }
            }
        }
    }
}

Está hecho con el .Net 7.

Saludos camaradas.