Usar read en entrada de datos
Meta:
Una consulta.
A partir de la S en el delimitador indicado abajo.
Código
string entrada = "#I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„\r";
Concretamente esto de abajo.
Código
S€„€ˆ„\r
Más aún el:
Código
€„€ˆ„
En realidad es un binario mezclado con caracteres tipo string del principio. Por muy encoder que use el ponerlo en un Windows Form siempre me suelta 63 en decimal.
Código
foreach (uint b in Encoding.Default.GetBytes(salida[8]))
{
//richTextBox1.Text += b.ToString();
richTextBox1.Text += Environment.NewLine; // Nueva línea.
richTextBox1.Text += $"Array: {numeros[j] = b}";
++j;
}
Ya que al capturar datos en el puerto serie lo almaceno tipo String.
Parece ser que es mejor optar por almacenar los datos o tramas de bytes que llegan desde el puerto serie en tipo byte[] y usar read.
Uso el protocolo este para el puerto serie.
Código
puertoSerie = new SerialPort()
{
// Configuración del puerto serie.
PortName = "COM3", // Nombre del puerto serie.
BaudRate = 2400, // Velocidad en baudios.
Parity = Parity.None, // Esquema para comprobar la paridad de cada byte recibido.
StopBits = StopBits.One, // Número de bits de parada por byte.
DataBits = 8, // Número de bits de datos por byte.
Handshake = Handshake.None, // Protocolo de establecimiento.
DtrEnable = true, // Línea de terminal de datos.
RtsEnable = true, // Línea de solicitud.
// Establecer los tiempos de espera de lectura / escritura.
ReadTimeout = 500, // Tiempo de espera de escritura en ms.
WriteTimeout = 500, // Tiempo de espera de escritura en ms.
// Más configuraciones.
DiscardNull = false, // Descartar bytes nulos recibidos.
ParityReplace = 63,
ReadBufferSize = 4096,
WriteBufferSize = 2018,
ReceivedBytesThreshold = 1
};
A la hora de recibir datos, mejor obtener ***** bytes sin formato, tal como vienen y almacenarlo.
¿Cuál es la mejor forma para almacenar datos en un array de bytes?
Ya que luego la parte de la S, quiero mostrarlo en decimal para luego verlo en binario.
Saludos.
Meta:
Buenas:
Todavía sigo chamusqueándome las neuronas.
Teniendo estos resultados que viene tipo string, lo convierto en hexadecimal y en binario con Windows Form.
Citar
#I223.4O223.6L007B100V26.0F50.2H50.2R0080S??????
23493232332E344F3232332E364C303037423130305632362E304635302E324835302E325230303830533F3F3F3F3F3F0D
1000111001001110010110010110011101110110100100111111001011001011001110111011011010011001100001100001101111000010110001110000110000101011011001011011010111011000010001101101011100001011101100101001000110101110000101110110010101001011000011000011100011000010100111111111111111111111111111111111111111101
¿Cómo se puede capturar los datos exactamente sin editar tal como se recibieron tal como si se muestra abajo?
Precisamente son estos:
35 73 50 50 51 46 52 79 50 50 52 46 50 76 48 48 55 66 49 48 48 86 50 54 46 48 7
0 53 48 46 49 72 53 48 46 49 82 48 48 56 48 83 144 132 128 136 132 192 13
Ver imagen con un terminal que si lo hace.
Ver zoom.
Lo marcado en rojo arriba es justo lo que quiero meter en un array para luego mostrarlo uno a uno en Windows form con su label correspondiente.
Espero que así se entienda mejor.
Código hecho en Windows Form en C# es este:
Código
private void Actualizar(object sender, EventArgs e)
{
// Asignar el valor de la trama al richTextBox.
richTextBox1.Text += recibidos;
// Nueva línea.
richTextBox1.Text += Environment.NewLine;
// Pasar a hexadecimal.
//foreach (byte b in recibidos)
foreach (byte b in recibidos.Select(v => (byte)v))
{
// x = minúscula, X = mayúscula.
richTextBox1.Text += b.ToString("X2");
}
// Nueva línea.
richTextBox1.Text += Environment.NewLine;
richTextBox1.Text += Environment.NewLine;
// Pasar a binario.
foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
{
richTextBox1.Text += leer.ToString();
}
// Nueva línea.
richTextBox1.Text += Environment.NewLine;
richTextBox1.Text += Environment.NewLine;
// Selecciona la posición final para leer los mensajes entrantes.
richTextBox1.SelectionStart = richTextBox1.Text.Length;
// Mantiene el scroll en la entrada de cada mensaje.
richTextBox1.ScrollToCaret();
// Limpiar.
recibidos = "";
}
¿Alguna idea?
Saludos.
Meta:
Al final se hace así:
Código
foreach (byte elemento in recibidos)
{
richTextBox1.Text += Convert.ToDecimal(elemento);
}
Cuyo resultado no es el esperado.
Me da esto:
35735049574657795050484655764849496649484886505446487053484650725348465082484851568363636363636313
El 83 es la S y el 13 es este \r, entre medio hay seis veces el 63, que no debería mostrar porque la conversión está mal, no es el real, el real es el que indiqué antes.
35 73 50 50 51 46 52 79 50 50 52 46 50 76 48 48 55 66 49 48 48 86 50 54 46 48 7
0 53 48 46 49 72 53 48 46 49 82 48 48 56 48 83 144 132 128 136 132 192 13
Se ve que a la hora de recibir datos uso esta variable tipo string.
Código
string recibidos;
Por lo que se ve, no es el adecuado cuando quieres los byte tal cual vienen sin modificar o usar encoder.
Parece ser que la mejor manera es usar una array o matriz como esta:
byte[] = cadenaByte;
EdePC:
Cuidado con las codificaciones, los datos reales serán bytes, si a alguno de esos bytes los conviertes a char o string dependerá de la codificación en turno como se hará la conversión y como se hará la visualización, ahí tienes esos dos problemas.
Supuestamente los caracteres problemáticos son 5: €„€ˆ„ pero incluso en la salida que consideras correcta salen 6: 144 132 128 136 132 192 y si las miras bien verás que no encaja con los caracteres que se repiten, así que tampoco es la correcta.
Citar
Parece ser que es mejor optar por almacenar los datos o tramas de bytes que llegan desde el puerto serie en tipo byte[] y usar read.
No sé como estás guardando los datos así que supondré que estás usando puertoSerie.ReadChar(), puertoSerie.ReadLine(), o similar, estos trabajan y convierten basándose en la codificación y por lo tanto habrán cambios si no lo tienes controlado. Si usas puertoSerie.ReadByte() si conseguirás los bytes reales pero para visualizarlos debes usar una codificación adecuada igual o similar a la empleada para representar esos bytes.
Por ejemplo si tienes el decimal 128 y lo quieres mostrar usando codificación ANSI obtendrás: €, pero si usas ASCII obtienes ? (63) porque no existe en la tabla ASCII
Si haces la lectura con ReadByte() y luego cada byte lo pasas a Int no deberías tener problemas salvo la cantidad de bytes que dependerá de la codificación
Meta:
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.
Código
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.
Código
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.
Navegación
[#] Página Siguiente