elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Tutorial básico de Quickjs


  Mostrar Mensajes
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 232
1  Programación / .NET (C#, VB.NET, ASP) / Re: No lee bien los datos de entrada en: 25 Febrero 2021, 12:14 pm
Se tiene que ver así.
Al lados números recibidos desde el puerto.

2  Programación / .NET (C#, VB.NET, ASP) / No lee bien los datos de entrada en: 24 Febrero 2021, 22:21 pm
Buenas:

Mi idea es que lea datos desde el puerto serie que viene de Arduino.  La interfaz está hecho con Consola de C# 2019.

Como se puede ver en la imagen, lo datos no se ven correctamente.

Ver imagen.

Código consola C#:
Código
  1. using System;
  2. using System.IO;
  3. using System.IO.Ports;
  4. using System.Text;
  5. using System.Threading;
  6.  
  7. namespace Lectura_seis_potenciometros_Arduino_consola_01
  8. {
  9.    class Program
  10.    {
  11.        // Utilizaremos un string "Recibidos" como buffer de recepción.
  12.        public static string Recibidos;
  13.        public static bool _continua;
  14.        public static SerialPort Puerto_serie;
  15.  
  16.        static void Main(string[] args)
  17.        {
  18.            string COM = "";
  19.            StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
  20.            Thread readThread = new Thread(Leer);
  21.  
  22.            // Título de la ventana.
  23.            Console.Title = "Lectura 6 potenciómetros desde Arduino";
  24.  
  25.            // Tamaño de la ventana, x, y.
  26.            Console.SetWindowSize(45, 20);
  27.  
  28.            // Color de fondo.
  29.            Console.BackgroundColor = ConsoleColor.Gray;
  30.  
  31.            // Color de las letras.
  32.            Console.ForegroundColor = ConsoleColor.Black;
  33.  
  34.            // Limpiar pantalla y dejarlo todo gris.
  35.            Console.Clear();
  36.  
  37.            // Visible el cursor.
  38.            Console.CursorVisible = true;
  39.  
  40.            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
  41.            Puerto_serie = new SerialPort();
  42.  
  43.            // Obtenga una lista de nombres de puertos serie.
  44.            string[] puertos = SerialPort.GetPortNames();
  45.  
  46.            Console.WriteLine("Se encontraron los siguientes puertos series:");
  47.  
  48.            // Muestre el nombre de cada puerto en la consola.
  49.            foreach (string puerto in puertos)
  50.            {
  51.                Console.WriteLine(puerto);
  52.            }
  53.  
  54.            // Configuración.
  55.            Console.Write(@"
  56. Introduzca un número para seleccionar
  57. puerto COM.
  58. Por ejemplo el 4, sería COM4.
  59.  
  60. Puerto: ");
  61.            COM = Console.ReadLine(); // Escribir el número del puerto.
  62.            Console.Clear(); // Limpiar pantalla.
  63.  
  64.            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
  65.  
  66.            // Configuración del puerto serie.
  67.            Puerto_serie.BaudRate = 115200;
  68.            Puerto_serie.Parity = Parity.None;
  69.            Puerto_serie.StopBits = StopBits.One;
  70.            Puerto_serie.DataBits = 8;
  71.            Puerto_serie.Handshake = Handshake.None;
  72.            Puerto_serie.RtsEnable = true;
  73.  
  74.            // Establecer los tiempos de espera de lectura / escritura.
  75.            //Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
  76.            //Puerto_serie.WriteTimeout = 500; // 500
  77.  
  78.            // Comprueba si puede abrir el puerto serie.
  79.            try
  80.            {
  81.                Puerto_serie.Open(); // Abrir el puerto serie.
  82.            }
  83.  
  84.            // En caso que diera algún error como que no encuentra el puerto seleccionado
  85.            // muestra una excepción.
  86.            catch (IOException)
  87.            {
  88.                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
  89.                Console.CursorVisible = false;
  90.                Console.SetCursorPosition(16, 6);
  91.                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
  92.                o no lo encuentra.");
  93.                Console.ReadKey();   // Pulse cualquier tecla.
  94.                Environment.Exit(1); // Salir de la aplicación.
  95.            }
  96.  
  97.            _continua = true;
  98.            readThread.Start();
  99.  
  100.            // Cursos invisible.
  101.            Console.CursorVisible = false;
  102.  
  103.            // Mostrar dibujo en pantalla.
  104.            Console.SetCursorPosition(3, 3);
  105.            Console.Write("Potenciómetro A0: ");
  106.            Console.SetCursorPosition(3, 5);
  107.            Console.Write("Potenciómetro A1: ");
  108.            Console.SetCursorPosition(3, 7);
  109.            Console.Write("Potenciómetro A2: ");
  110.            Console.SetCursorPosition(3, 9);
  111.            Console.Write("Potenciómetro A3: ");
  112.            Console.SetCursorPosition(3, 11);
  113.            Console.Write("Potenciómetro A4: ");
  114.            Console.SetCursorPosition(3, 13);
  115.            Console.Write("Potenciómetro A5: ");
  116.  
  117.            // Posición para empezar a dibijar las ─.
  118.            Console.SetCursorPosition(0, 15);
  119.  
  120.            // Generar línea.
  121.            for (int i = 0; i <= 44; i++)
  122.            {
  123.                Console.Write("&#9472;"); // ASCII: Alt + 196: &#9472;
  124.            }
  125.  
  126.            Console.SetCursorPosition(17, 17);
  127.            Console.Write("Puerto: COM" + COM);
  128.  
  129.            // Bloquea el subproceso.
  130.            readThread.Join();
  131.  
  132.            // Cierra el puerto serie.
  133.            Puerto_serie.Close();
  134.        }
  135.  
  136.        // Lee mensaje recibido.
  137.        public static void Leer()
  138.        {
  139.            // Si _continue es true se ejecuta todas las instrucciones dentro de while.
  140.            while (_continua) // _continua
  141.            {
  142.                try
  143.                {
  144.                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
  145.                    Recibidos = Puerto_serie.ReadLine();
  146.  
  147.                    // Muestra en pantalla mensaje recibido.
  148.                    Console.WriteLine(Recibidos);
  149.  
  150.                    string[] datosArray = Recibidos.Split(',');
  151.  
  152.                    if (datosArray.Length == 6) // 6 potenciómetros.
  153.                    {
  154.                        Console.SetCursorPosition(20, 3);
  155.                        Console.Write(datosArray[0]); // Entrada analógica A0.
  156.                        Console.SetCursorPosition(20, 5);
  157.                        Console.Write(datosArray[1]); // Entrada analógica A1.
  158.                        Console.SetCursorPosition(20, 7);
  159.                        Console.Write(datosArray[2]); // Entrada analógica A2.
  160.                        Console.SetCursorPosition(20, 9);
  161.                        Console.Write(datosArray[3]); // Entrada analógica A3.
  162.                        Console.SetCursorPosition(20, 11);
  163.                        Console.Write(datosArray[4]); // Entrada analógica A4.
  164.                        Console.SetCursorPosition(20, 13);
  165.                        Console.Write(datosArray[5]); // Entrada analógica A5.
  166.                    }
  167.  
  168.                    // Limpiar buffer.
  169.                    Recibidos = "";
  170.  
  171.                }
  172.                catch (TimeoutException)
  173.                {
  174.                    Console.WriteLine("ERROR");
  175.                }
  176.            }
  177.        }
  178.    }
  179. }

Código Arduino.
Código
  1. int pinA0 = A0;
  2. int pinA1 = A1;
  3. int pinA2 = A2;
  4. int pinA3 = A3;
  5. int pinA4 = A4;
  6. int pinA5 = A5;
  7. int valorPotA0 = 0;
  8. int valorPotA1 = 0;
  9. int valorPotA2 = 0;
  10. int valorPotA3 = 0;
  11. int valorPotA4 = 0;
  12. int valorPotA5 = 0;
  13.  
  14. void setup()
  15. {
  16.  Serial.begin(115200);
  17.  pinMode(pinA0, INPUT);
  18.  pinMode(pinA1, INPUT);
  19.  pinMode(pinA2, INPUT);
  20.  pinMode(pinA3, INPUT);
  21.  pinMode(pinA4, INPUT);
  22.  pinMode(pinA5, INPUT);
  23. }
  24.  
  25. void loop()
  26. {
  27.  valorPotA0 = analogRead(pinA0);
  28.  valorPotA1 = analogRead(pinA1);
  29.  valorPotA2 = analogRead(pinA2);
  30.  valorPotA3 = analogRead(pinA3);
  31.  valorPotA4 = analogRead(pinA4);
  32.  valorPotA5 = analogRead(pinA5);
  33.  
  34.  Serial.print(valorPotA0);
  35.  Serial.print(",");
  36.  Serial.print(valorPotA1);
  37.  Serial.print(",");
  38.  Serial.print(valorPotA2);
  39.  Serial.print(",");
  40.  Serial.print(valorPotA3);
  41.  Serial.print(",");
  42.  Serial.print(valorPotA4);
  43.  Serial.print(",");
  44.  Serial.println(valorPotA5);
  45.  delay(100); // 100 mili segundos o 0.1 segundos..
  46. }

Los datos del potenciómetro debe mostrarse en su etiqueta del 0 al 1023, por ejemplo:

Potenciómetro A0: 785

Y no un desorden como muestra arriba.

¿Alguna idea?

Que tengas buen día.
3  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 20 Diciembre 2020, 09:08 am
Buenas gente por Naviades:

He intentado pero no me gusta mucho.
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7. namespace Escribir_mas_de_255_caracteres_consola_01
  8. {
  9.    class Program
  10.    {
  11.        static void Main(string[] args)
  12.        {
  13.            byte[] array = new byte[500];
  14.            ConsoleKey key;
  15.            int i = 0;
  16.  
  17.            while ((key = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  18.            {
  19.                Console.Write(key.ToString());
  20.                array[i++] = Convert.ToByte(key);
  21.            }
  22.            Console.WriteLine();
  23.            Console.WriteLine(Encoding.Default.GetString(array));
  24.            Console.ReadLine();
  25.  
  26.        }
  27.    }
  28. }
  29.  

Seguro que se puede hacer mejor.

Saludos.
4  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 19 Diciembre 2020, 15:57 pm
Voy a intentar hacer un ejmeplo de almacenar la cantidad de datos en Byte[]. Deja ver si me sale y mostrarlo en pantalla.
5  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 19 Diciembre 2020, 15:20 pm
Esa forma de hacer las cosas suena trapiche e innecesario. Es verdad que si no hay otra cosa es una artimaña perfecta, porque existe la posibilidad de hacerlo.

El rollo es saber como almacenar el texto en la consola en un array que se pasa de los 255 caracteres.
6  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 19 Diciembre 2020, 12:04 pm
El array creado es este po rponer un ejemplo.

Códigos C#
:

Código
  1. Byte[] miArray = Encoding.ASCII.GetBytes("Texto o mensaje a enviar.");

En fin, todavía no se como se hace lo de enviar más de 255 carácteres. ¿Hay ejemplos?

Ahora la cuestión es... porqué perder tiempo con la consola para intentar sortear los límites prácticos de la consola cuando hay controles para hacer interfaces de usuario sin las limitaciones de la consola????????. Un chat acaso no será más cómodo en una ventana (form) con alguna caja de texto multilínea... pero en fin, cada uno pierde el tiempo como quiere.

Por curiosidad, después haré el que tu dices con Windows Form y WPF. ;)
Cuestiones didácticas no hay problemas, ;)

7  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 12 Diciembre 2020, 01:02 am
Por lo que he estado mirando en Internet, y como también quiero recibir y enviar mensajes a dispositivos, se recomienda que sea la lectura y escritura de mensajes con Byte[].

Por ejemplo:
Código
  1. Byte[] unBuffer = Encoding.ASCII.GetBytes("Texto o mensaje a enviar."); // Codificación ASCII y guarda en la variable array tipo byte.
  2. Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.

Por pasos qu eno se como hacerlo.
1. Escribo en la consola un mensaje.
Será esto:
Código
  1. Byte[] variable = Console.ReadLine();

2. Cuando ya se almacena en la variable "variable" un texto, por ejemplo. Hola, mi muy distinguido amigo. Me imagino que así se envía el texto.
Código
  1. Byte[] unBuffer = Encoding.ASCII.GetBytes(variable);
  2. Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length);

Cuando llegue a mi casa, hago pruebas y comento.

Saludos.
8  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 11 Diciembre 2020, 01:08 am
Parece ser que el UTF-8 le gusta más la gente al usarlo.

¿Cómo se maneja el UTF-8?
9  Programación / .NET (C#, VB.NET, ASP) / Re: Enviar más de 255 carácteres en: 11 Diciembre 2020, 00:27 am
Gracias Señor.

He podido al final leer los puertos series físicos y virtuales. Dejo el código nuevo abajo.

1.
¿Cuál es la mejor opción del formato hasta para escribir la ñ, tildes sin que aparezca caracter raro a la hora de enviar texto en forma de chat?

2
. ¿Cómo se hace encode UTF 8 a la hora de enviar  y recibir datos por el puerto serie?

3. A la hora de escribir mensajes, solo puedo escribir un máximo de 255 caracteres. ¿Cómo se puede escribir en la consola, más caracteres sin estar limitado solo a 255?

Código C#:
Código
  1. using System;
  2. using System.IO;
  3. using System.IO.Ports;
  4. using System.Threading;
  5.  
  6. namespace Chat_consola_02
  7. {
  8.    class Program
  9.    {
  10.        static bool _continua;
  11.        static SerialPort Puerto_serie;
  12.  
  13.        static void Main(string[] args)
  14.        {
  15.            string COM = "";
  16.            string nombre;
  17.            string mensaje;
  18.            StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
  19.            Thread readThread = new Thread(Leer);
  20.  
  21.            // Título de la ventana.
  22.            Console.Title = "Enviar datos al puerto serie";
  23.  
  24.            // Tamaño de la ventana, x, y.
  25.            Console.SetWindowSize(70, 25);
  26.  
  27.            // Color de fondo.
  28.            Console.BackgroundColor = ConsoleColor.Gray;
  29.  
  30.            // Color de las letras.
  31.            Console.ForegroundColor = ConsoleColor.Black;
  32.  
  33.            // Limpiar pantalla y dejarlo todo gris.
  34.            Console.Clear();
  35.  
  36.            // Visible el cursor.
  37.            Console.CursorVisible = true;
  38.  
  39.            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
  40.            Puerto_serie = new SerialPort();
  41.  
  42.            // Obtenga una lista de nombres de puertos serie.
  43.            string[] ports = SerialPort.GetPortNames();
  44.  
  45.            Console.WriteLine("Se encontraron los siguientes puertos series:");
  46.  
  47.            // Muestre el nombre de cada puerto en la consola.
  48.            foreach (string port in ports)
  49.            {
  50.                Console.WriteLine(port);
  51.            }
  52.  
  53.            // Configuración.
  54.            Console.Write(@"
  55. Introduzca un número para seleccionar puerto COM.
  56. Por ejemplo el 4, sería COM4.
  57.  
  58. Puerto: ");
  59.            COM = Console.ReadLine(); // Escribir el número del puerto.
  60.            Console.Clear();
  61.  
  62.            Puerto_serie.PortName = "COM" + COM; // Número del puerto serie.
  63.  
  64.            // Configuración del puerto serie.
  65.            Puerto_serie.BaudRate = 115200;
  66.            Puerto_serie.Parity = Parity.None;
  67.            Puerto_serie.StopBits = StopBits.One;
  68.            Puerto_serie.DataBits = 8;
  69.            Puerto_serie.Handshake = Handshake.None;
  70.            Puerto_serie.RtsEnable = true;
  71.  
  72.            // Establecer los tiempos de espera de lectura / escritura.
  73.            Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
  74.            Puerto_serie.WriteTimeout = 500; // 500
  75.  
  76.            // Comprueba si puede abrir el puerto serie.
  77.            try
  78.            {
  79.                Puerto_serie.Open(); // Abrir el puerto serie.
  80.            }
  81.  
  82.            // En caso que diera algún error como que no encuentra el puerto seleccionado
  83.            // muestra una excepción.
  84.            catch (IOException)
  85.            {
  86.                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
  87.                Console.CursorVisible = false;
  88.                Console.SetCursorPosition(16, 6);
  89.                Console.WriteLine(@"El puerto " + Puerto_serie.PortName + @" no existe
  90.                o no lo encuentra.");
  91.                Console.ReadKey();   // Pulse cualquier tecla.
  92.                Environment.Exit(1); // Salir de la aplicación.
  93.            }
  94.  
  95.            _continua = true;
  96.            readThread.Start();
  97.  
  98.            // Mostrar texto Nombre y se
  99.            Console.Write("Nombre: ");
  100.  
  101.            // guarda en la variable nombre.
  102.            nombre = Console.ReadLine();
  103.  
  104.            Console.WriteLine("Escriba salir para salir");
  105.  
  106.            while (_continua)
  107.            {
  108.                // Cualquier caracter recibido se guarda en la variable mensaje.
  109.                mensaje = Console.ReadLine();
  110.  
  111.                // Compara salir con el mensaje salir si lo haz escrito igual.
  112.                // ¿Escribiste la palabra salir?
  113.                if (comparaString.Equals("salir", mensaje))
  114.                {
  115.                    // Sí. Entonces, pone esta variable _continue en false.
  116.                    _continua = false;
  117.                }
  118.                // No. Entonces, envía por el puerto serie tu nick
  119.                // y mensaje que haz escrito.
  120.                else
  121.                {
  122.                    Puerto_serie.WriteLine(
  123.                        String.Format("<{0}>: {1}", nombre, mensaje));
  124.                }
  125.            }
  126.  
  127.            // Bloquea el subproceso.
  128.            readThread.Join();
  129.  
  130.            // Cierra el puerto serie.
  131.            Puerto_serie.Close();
  132.        }
  133.  
  134.        // Lee mensaje recibido.
  135.        public static void Leer()
  136.        {
  137.            // Si _continue es true se ejecuta todas las instrucciones dentro de while.
  138.            while (_continua)
  139.            {
  140.                try
  141.                {
  142.                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
  143.                    string mensaje = Puerto_serie.ReadLine();
  144.  
  145.                    // Muestra en pantalla mensaje recibido.
  146.                    Console.WriteLine(mensaje);
  147.                }
  148.                catch (TimeoutException) { }
  149.            }
  150.        }
  151.    }
  152. }

Saludos.
10  Programación / .NET (C#, VB.NET, ASP) / Re: Máquina de estado en: 10 Diciembre 2020, 01:41 am
Bueno.

Aquí eplica algo.


Por bloques o máquina de estado dice. Tiene ejemplo en C++ y Arduino. En el cual para tenerlo hay que registrarse en su Web.

Saludos.
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 232
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines