¿Cómo enviar instrucciones en serie en C#?

Utilice el sistema. IO .Puerto;

Usar sistema. Threading;

Clase pública PortChat

{

Bool estático _ continuar

Puerto serie estático_puerto serie;

Public static void Main()

{

Nombre de cadena;

Mensaje de cadena;

comparador de cadenas comparador de cadenas = comparador de cadenas. Caso común;

Subproceso readThread = nuevo subproceso (Leer);

//Crea un nuevo objeto SerialPort con la configuración predeterminada.

_ puerto serie = nuevo puerto serie();

//Permite al usuario establecer las propiedades adecuadas.

_Puerto serie. nombre del puerto = establecer nombre del puerto (_ puerto serie.nombre del puerto);

_puerto serie. BaudRate = SetPortBaudRate(_ puerto serie. BaudRate);

_puerto serie. paridad = setport paridad(_ puerto serie. paridad);

_puerto serie. DataBits = SetPortDataBits(_ puerto serie.bits de datos);

_puerto serie. bits de parada = SetPortStopBits(_ puerto serie. Bits de parada);

_puerto serie. handshake = SetPortHandshake(_ serial port.handshake);

//Establecer tiempo de espera de lectura/escritura

_serial port. ReadTimeout = 500

_Puerto serie. WriteTimeout = 500

_SerialPort. open();

_ continue = true

Hilo de lectura. start();

Consola. escribir("nombre:");

nombre = consola. ReadLine();

Consola. WriteLine("Escriba QUIT para salir");

while(_continue)

{

Mensaje = consola. ReadLine();

if (stringComparer. igual a ("salir", mensaje))

{

_continuar = false

}

Otro

{

_Puerto serie. WriteLine(

String. Format (" & lt{ 0 } & gt:{1}", nombre, mensaje)); /p>

Hilo de lectura. join();

_Puerto serie. close();

}

Lectura vacía estática pública()

{

mientras(_continue)

{

Pruebe

{

Mensaje de cadena = _serialPort. ReadLine();

Consola.

WriteLine(mensaje);

}

catch (TimeoutException) { }

}

}

Público Cadena estática SetPortName (cadena defaultPortName)

{

Nombre del puerto de cadena;

Consola. WriteLine("Puertos disponibles:");

foreach(String s en puerto serie. GetPortNames())

{

Consola. WriteLine("{ 0 }", s);

}

Consola. Write("Puerto COM ({0}):", nombre de puerto predeterminado);

Nombre de puerto = consola. ReadLine();

if (nombrePuerto == " ")

{

nombrePuerto = nombrePuerto predeterminado

}

Nombre del puerto de retorno;

}

public static int SetPortBaudRate(int defaultPortBaudRate)

{

Velocidad en baudios de cadena

Consola. Write("BaudRate({0}):", defaultPortBaudRate);

BaudRate = console. ReadLine();

if (baudRate == " ")

{

baudRate = defaultPortBaudRate. ToString();

}

Devuelve int. parse(baudRate);

}

Paridad de puerto de conjunto de paridad estática pública (paridad de puerto predeterminada de paridad)

{

Paridad de cadena;

Consola. WriteLine("Opciones de paridad disponibles:");

foreach(String in enum. GetNames(tipo de paridad))

{

Console. WriteLine("{ 0 }", s);

}

Consola. Write("Paridad({0}):", defaultPortParity.ToString());

Paridad = consola. ReadLine();

if (parity == " ")

{

Paridad = Paridad de puerto predeterminada. ToString();

}

Devuelve la enumeración (paridad). Parse(tipo de (verificación de paridad), verificación de paridad);

}

public static int SetPortDataBits(int defaultPortDataBits)

{

Bits de datos de cadena;

Consola. Write("Bits de datos ({0}):", defaultPortDataBits);

Bits de datos = console. ReadLine();

if (dataBits == " ")

{

dataBits = defaultPortDataBits. ToString();

}

Devuelve int. Análisis (bits de datos);

}

El bit de parada estática pública establece el bit de parada del puerto (el bit de parada por defecto es el bit de parada del puerto)

{

Bit de parada de cadena;

Consola.

WriteLine("Opciones de bits de parada disponibles:");

foreach(String in enum. GetNames(Tipo de(bit de parada)))

{

Consola . WriteLine("{ 0 }", s);

}

Consola. Write("Stop Bits({0}):", defaultPortStopBits.ToString());

Stop Bits = consola. ReadLine();

if (stopBits == " ")

{

stopBits = defaultPortStopBits. ToString();

}

Enumeración de retorno (bit de parada). Parse(typeof(bit de parada), bit de parada);

}

Apretón de enlace estático público SetPortHandshake (apretón de enlace del puerto predeterminado)

{

Apretón de manos de cadena;

Consola. WriteLine("Opciones de protocolo de enlace disponibles:");

foreach(String in enum. GetNames(tipo de protocolo de enlace))

{

Consola. WriteLine("{ 0 }", s);

}

Consola. Write("Stop Bits({0}):", defaultPortHandshake.ToString());

Handshake = consola. ReadLine();

if(handshake == " ")

{

Handshake = defaultPortHandshake. ToString();

}

Devuelve la enumeración (apretón de manos). Analizar(tipode(apretón de manos),apretón de manos);

}

}