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

 

 


Tema destacado:


  Mostrar Temas
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 58
1  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.
2  Programación / .NET (C#, VB.NET, ASP) / Enviar más de 255 carácteres en: 10 Diciembre 2020, 01:01 am
Buenos días camaradas:

Hice un micni chat que funciona bien entre dos PC o ordenadores de sobremesa por el puerto serie.

Cuando quiero escribir un mensaje de más de 255 letras o caracteres, no me deja. Solo me quedo con 255 y ya está.

¿Existe alguna manera de escribir mensaje en la consola más de 255 caracteres o los que quiera?

Dejo el código de ejemplo en C#.
Código
  1. using System;
  2. using System.IO;
  3. using System.IO.Ports;
  4. using System.Threading;
  5.  
  6. namespace Introducir_datos_puerto_serie_consola_02
  7. {
  8.    class Program
  9.    {
  10.        static bool _continua;
  11.        // Cree un nuevo objeto SerialPort con la configuración predeterminada.
  12.        static readonly SerialPort Puerto_serie = new SerialPort("COM2");
  13.  
  14.        static void Main(string[] args)
  15.        {
  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.Blue;
  29.  
  30.            // Color de las letras.
  31.            Console.ForegroundColor = ConsoleColor.Yellow;
  32.  
  33.            // Limpiar pantalla y dejarlo todo gris.
  34.            Console.Clear();
  35.  
  36.            // Visible el cursor.
  37.            Console.CursorVisible = true;
  38.  
  39.            Puerto_serie.BaudRate = 115200;
  40.            Puerto_serie.Parity = Parity.None;
  41.            Puerto_serie.StopBits = StopBits.One;
  42.            Puerto_serie.DataBits = 8;
  43.            Puerto_serie.Handshake = Handshake.None;
  44.            Puerto_serie.RtsEnable = true;
  45.  
  46.            // Establecer los tiempos de espera de lectura / escritura.
  47.            Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
  48.            Puerto_serie.WriteTimeout = 500; // 500
  49.  
  50.            // Abrir puerto serie.
  51.            Puerto_serie.Open();
  52.            _continua = true;
  53.            readThread.Start();
  54.  
  55.            // Mostrar texto Nombre y se
  56.            Console.Write("Nombre: ");
  57.  
  58.            // guarda en la variable nombre.
  59.            nombre = Console.ReadLine();
  60.  
  61.            Console.WriteLine("Escriba salir para salir");
  62.  
  63.            while (_continua)
  64.            {
  65.                // Cualquier caracter recibido se guarda en la variable mensaje.
  66.                mensaje = Console.ReadLine();
  67.  
  68.                // Compara salir con el mensaje salir si lo haz escrito igual.
  69.                // ¿Escribiste la palabra salir?
  70.                if (comparaString.Equals("salir", mensaje))
  71.                {
  72.                    // Sí. Entonces, pone esta variable _continue en false.
  73.                    _continua = false;
  74.                }
  75.                // No. Entonces, envía por el puerto serie tu nick
  76.                // y mensaje que haz escrito.
  77.                else
  78.                {
  79.                    Puerto_serie.WriteLine(
  80.                        String.Format("<{0}>: {1}", nombre, mensaje));
  81.                }
  82.            }
  83.  
  84.            // Bloquea el subproceso.
  85.            readThread.Join();
  86.  
  87.            // Cierra el puerto serie.
  88.            Puerto_serie.Close();
  89.  
  90.        }
  91.  
  92.        // Lee mensaje recibido.
  93.        public static void Leer()
  94.        {
  95.            // Si _continue es true se ejecuta todas las instrucciones dentro de while.
  96.            while (_continua)
  97.            {
  98.                try
  99.                {
  100.                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
  101.                    string mensaje = Puerto_serie.ReadLine();
  102.  
  103.                    // Muestra en pantalla mensaje recibido.
  104.                    Console.WriteLine(mensaje);
  105.                }
  106.                catch (TimeoutException) { }
  107.            }
  108.        }
  109.    }
  110. }

Otra cosa que me he sado cuenta. Si escribo o envío un mensaje que use la ñ, por ejemplo:
Hola Señor.
Me aparece esto.
Hola Se?or.
Siempre se me mete el ? por medio. Detecta mal los caracteres al recibir datos. Al introducirlos no.



Gracias.
3  Programación / .NET (C#, VB.NET, ASP) / Máquina de estado en: 7 Diciembre 2020, 12:03 pm
Buenas:

Quiero hacer un tutorial, pero de entrada no se hacerlo. El tutorial es este.

https://docs.microsoft.com/es-es/dotnet/framework/windows-workflow-foundation/how-to-create-a-state-machine-workflow

Estoy con Windows Form. Me confirman si tamvién vale o no para hacerlo en modo consola.

No encuentro o no me sale en Visual Studio Community 2019, versión, 16.8.2 el stateMAchine.


Si se sabe algún videotutorial sobre ejemplos de máquinas de estados, mejor que mejor.

Aquí no me sale nada.

¿Alguna idea?

Saludos.
4  Programación / Scripting / Chat con Linux en: 3 Diciembre 2020, 22:25 pm
Buenas:

Hice un pequeño mini chat en consola con C# bajo Windows 10 de siempre. Quiero hacer lo mismo con Script bajo la Raspberry Pi. Como no tengo idea de Script de Linux y tampoco quiero usar MonoDevelop de Linux con C#, pues alguien me podría ayudar adaptar el código de C# a puro Script de Linux si no le importa.

Código C#:
Código
  1. using System;
  2. using System.IO.Ports;
  3. using System.Threading;
  4.  
  5. namespace Introducir_datos_puerto_serie_consola_02
  6. {
  7.    class Program
  8.    {
  9.        static bool _continua;
  10.        // Cree un nuevo objeto SerialPort con la configuración predeterminada.
  11.        static SerialPort Puerto_serie = new SerialPort("COM2");
  12.  
  13.        static void Main(string[] args)
  14.        {
  15.            string nombre;
  16.            string mensaje;
  17.            StringComparer comparaString = StringComparer.OrdinalIgnoreCase;
  18.            Thread readThread = new Thread(Leer);
  19.  
  20.            // Título de la ventana.
  21.            Console.Title = "Enviar datos al puerto serie";
  22.  
  23.            // Tamaño de la ventana, x, y.
  24.            Console.SetWindowSize(70, 25);
  25.  
  26.            // Color de fondo.
  27.            Console.BackgroundColor = ConsoleColor.Blue;
  28.  
  29.            // Color de las letras.
  30.            Console.ForegroundColor = ConsoleColor.Yellow;
  31.  
  32.            // Limpiar pantalla y dejarlo todo gris.
  33.            Console.Clear();
  34.  
  35.            // Visible el cursor.
  36.            Console.CursorVisible = true;
  37.  
  38.            Puerto_serie.BaudRate = 115200;
  39.            Puerto_serie.Parity = Parity.None;
  40.            Puerto_serie.StopBits = StopBits.One;
  41.            Puerto_serie.DataBits = 8;
  42.            Puerto_serie.Handshake = Handshake.None;
  43.            Puerto_serie.RtsEnable = true;
  44.  
  45.            // Establecer los tiempos de espera de lectura / escritura.
  46.            Puerto_serie.ReadTimeout = 500; // 500 // Milisegundos.
  47.            Puerto_serie.WriteTimeout = 500; // 500
  48.  
  49.            // Abrir puerto serie.
  50.            Puerto_serie.Open();
  51.            _continua = true;
  52.            readThread.Start();
  53.  
  54.            // Mostrar texto Nombre y se
  55.            Console.Write("Nombre: ");
  56.  
  57.            // guarda en la variable nombre.
  58.            nombre = Console.ReadLine();
  59.  
  60.            Console.WriteLine("Escriba salir para salir");
  61.  
  62.            while (_continua)
  63.            {
  64.                // Cualquier caracter recibido se guarda en la variable mensaje.
  65.                mensaje = Console.ReadLine();
  66.  
  67.                // Compara salir con el mensaje salir si lo haz escrito igual.
  68.                // ¿Escribiste la palabra salir?
  69.                if (comparaString.Equals("salir", mensaje))
  70.                {
  71.                    // Sí. Entonces, pone esta variable _continue en false.
  72.                    _continua = false;
  73.                }
  74.                // No. Entonces, envía por el puerto serie tu nick
  75.                // y mensaje que haz escrito.
  76.                else
  77.                {
  78.                    Puerto_serie.WriteLine(
  79.                        String.Format("<{0}>: {1}", nombre, mensaje));
  80.                }
  81.            }
  82.  
  83.            // Bloquea el subproceso.
  84.            readThread.Join();
  85.  
  86.            // Cierra el puerto serie.
  87.            Puerto_serie.Close();
  88.  
  89.        }
  90.  
  91.        // Lee mensaje recibido.
  92.        public static void Leer()
  93.        {
  94.            // Si _continue es true se ejecuta todas las instrucciones dentro de while.
  95.            while (_continua)
  96.            {
  97.                try
  98.                {
  99.                    // Almacena en la variable mensaje cualquier caracter o mensaje recibido.
  100.                    string mensaje = Puerto_serie.ReadLine();
  101.  
  102.                    // Muestra en pantalla mensaje recibido.
  103.                    Console.WriteLine(mensaje);
  104.                }
  105.                catch (TimeoutException) { }
  106.            }
  107.        }
  108.    }
  109. }

Seguro que es un cambiazo muy grande para la programación del Script.

Saludos.
5  Media / Multimedia / Descargar o ver vídeo restringido en: 6 Octubre 2020, 01:01 am
Hola:

Quiero ver este vídeo.



Pone este mensaje:
Contenido exclusivo para miembros
Hazte miembro de este canal para acceder a contenido exclusivo, como este vídeo, y a otras ventajas únicas.


Parece ser que esta técnica es para que paguemos para poder verlo.

¿Existe alguna manera de ver este vídeo sin pagar al youtuber?

Si ya empezamos así por cada vídeo que suban, hasta para ver hay que pagar, impresionante.
6  Programación / .NET (C#, VB.NET, ASP) / Movimiento armónico simple [SOLUCIONADO] en: 1 Agosto 2020, 01:25 am
Hola:

Hace siglos que quice hacerlo pero no me salió. añado en el Windows Form un pictureBox, ahí dentro creo dos rayas, una vertical y otra horizontal con el círculo en medio, tal como indica la imagen de abajo.



Los puntos que muestran se tiene que mover tal como lo hace en el vídeo de abajo.

Ver vídeo.


Código hasta ahora.
Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Forms;
  10.  
  11. namespace Movimiento_armonico_simple_01_cs
  12. {
  13.    public partial class Form1 : Form
  14.    {
  15.        private int pt1a = 0, pt2y = 300, pt2s = -1, pt3x = 80, pt3s = 1;
  16.  
  17.        private void Form1_Load(object sender, EventArgs e)
  18.        {
  19.            timer1.Start();
  20.        }
  21.  
  22.        private void pictureBox1_Paint(object sender, PaintEventArgs e)
  23.        {
  24.            Graphics g = e.Graphics;
  25.            int ptx, pty;
  26.            g.Clear(Color.White);
  27.            g.DrawEllipse(Pens.Black, new Rectangle(40, 40, 300, 300));
  28.            g.DrawLine(Pens.Black, 20, 40, 20, 340);
  29.            g.DrawLine(Pens.Black, 40, 360, 340, 360);
  30.  
  31.            ptx = (int)(Math.Cos((double)pt1a * Math.PI / 180.0) * 150.0);
  32.            pty = (int)(Math.Sin((double)pt1a * Math.PI / 180.0) * 150.0);
  33.            g.FillEllipse(Brushes.Black, new Rectangle(190 + ptx - 5, 190 - pty - 5, 11, 11));
  34.  
  35.            g.FillEllipse(Brushes.Black, new Rectangle(15, pt2y - 5, 11, 11));
  36.  
  37.            g.FillEllipse(Brushes.Black, new Rectangle(pt3x - 5, 355, 11, 11));
  38.        }
  39.  
  40.        private void timer1_Tick(object sender, EventArgs e)
  41.        {
  42.            pt1a += 2;
  43.            if (pt1a >= 360)
  44.                pt1a -= 360;
  45.  
  46.            pt2y += 4 * pt2s;
  47.            if (pt2y <= 40 || pt2y >= 340)
  48.                pt2s = -pt2s;
  49.  
  50.            pt3x += 4 * pt3s;
  51.            if (pt3x <= 40 || pt3x >= 340)
  52.                pt3s = -pt3s;
  53.  
  54.            pictureBox1.Invalidate();
  55.        }
  56.  
  57.        public Form1()
  58.        {
  59.            InitializeComponent();
  60.        }
  61.    }
  62. }

¿Alguna idea?

Saludos.
7  Programación / .NET (C#, VB.NET, ASP) / Calculo niveles en: 31 Julio 2020, 23:50 pm
Hola:

Tengo esta barra que pone de 0 % al 100 %.

0%     19 %                                                                  95 %        100%
|--------|-----------------------------------------------------------|--------------|

Mejor imagen de abjo.



Dentro de Windows Form incluyo la barra progressBar y el trackBar para regular una variable.

Internamente del programa, hay dos variables, una que pone 19 y otra variabe que pone 95. Esas con constantes.

Internamente una variable es capaz de moverse del 19 al 95. En otra variable indica que es un 0 al 100 %.

Por ejemplo, si con el trackBar lo pongo al valor 95, en un label tiene que indicar que estoy al 100.

Internamente funciona del 19 al 95 y cara del usuario lo ve como si fuera del 0 al 100 %.

Código que he hecho hasta ahora y no me funciona.
Código:
using System;
using System.Windows.Forms;

namespace Regular_nivel_batería_01
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void trackBar1_Scroll(object sender, EventArgs e)
        {
            progressBar1.Value = (trackBar1.Value - 19) * 100 / (95 - 19);
            //progressBar1.Value = trackBar1.Value;
            label_Porcentaje.Text = trackBar1.Value.ToString() + " %";
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Valores del trackBar.
            trackBar1.Maximum = 100;
            trackBar1.Minimum = 0;
            trackBar1.SmallChange = 5;
            trackBar1.Value = 19;

            // Valores barra de progreso.
            progressBar1.Maximum = 95;
            progressBar1.Minimum = 19;
            progressBar1.Step = 5;
            progressBar1.Value = trackBar1.Value;
        }
    }
}

¿Es posible hacerlo?

Saludos.
8  Programación / .NET (C#, VB.NET, ASP) / Preguntar antes de salir en: 29 Julio 2020, 17:12 pm
Buenas:

Tengo un programa hecho a medias. Está hecho con la consola C#.

Al pulsar la X de la ventana, quiero que haga estas cosas.
Pregunta si realmente quiero salir, si salgo, pone esto.

Código
  1.                            Si pulso X con el ratón
  2.                            {
  3.                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
  4.                                Puerto_serie.Close(); // Cierra el puerto serie.
  5.                                Environment.Exit(0); // Cerrar aplicación.
  6.                            }

Arriaba está mal planteado.

Primero pregunta si quiero salir, con un Sí y un No, si pulso No, el programa sigue su curso, si pongo Si, cierra el programa y me envía estos datos al puerto serie antes de que cierre del todo.

Código
  1.                                Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
  2.                                Puerto_serie.Close(); // Cierra el puerto serie.
  3.                                Environment.Exit(0); // Cerrar aplicación.

Código ejemplo casi completo.
Código
  1. using System;
  2. using System.IO.Ports;
  3.  
  4. namespace Introducir_datos_puerto_serie_consola_01
  5. {
  6.    class Program
  7.    {
  8.        static void Main(string[] args)
  9.        {
  10.            // Título de la ventana.
  11.            Console.Title = "Enviar datos al puerto serie";
  12.  
  13.            // Tamaño de la ventana, x, y.
  14.            Console.SetWindowSize(70, 25);
  15.  
  16.            // Color de fondo.
  17.            Console.BackgroundColor = ConsoleColor.Blue;
  18.  
  19.            // Color de las letras.
  20.            Console.ForegroundColor = ConsoleColor.Yellow;
  21.  
  22.            // Limpiar pantalla y dejarlo todo gris.
  23.            Console.Clear();
  24.  
  25.            // Visible el cursor.
  26.            Console.CursorVisible = true;
  27.  
  28.            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
  29.            SerialPort Puerto_serie = new SerialPort("COM3");
  30.  
  31.            Puerto_serie.BaudRate = 115200;
  32.            Puerto_serie.Parity = Parity.None;
  33.            Puerto_serie.StopBits = StopBits.One;
  34.            Puerto_serie.DataBits = 8;
  35.            Puerto_serie.Handshake = Handshake.None;
  36.            Puerto_serie.RtsEnable = true;
  37.  
  38.            // Establecer los tiempos de espera de lectura / escritura.
  39.            Puerto_serie.ReadTimeout = 500; // Milisegundos.
  40.            Puerto_serie.WriteTimeout = 500;
  41.  
  42.            // Detecta cualquier dato recibido.
  43.            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
  44.  
  45.            Puerto_serie.Open(); // Abrir puerto.
  46.  
  47.            //Console.CursorSize = 1;
  48.  
  49.            do
  50.            {
  51.                Console.Write("Introduzca un texto: ");
  52.                string texto;
  53.                texto = Console.ReadLine();
  54.                Console.WriteLine("El texto introducido es: " + texto);
  55.  
  56.                //texto = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
  57.                Puerto_serie.Write(texto); // Envía los datos del string todo su contenido.
  58.                Console.WriteLine("Comando {0} enviado.", texto); // Muestra en pantalla comandos enviado.
  59.                Console.WriteLine();
  60.  
  61.                // ################ Pregunta aquí si quieres salir.   ################
  62.                            //Si pulso X con el ratón
  63.                            //{
  64.                            //    Puerto_serie.Write("Puerto y aplicación cerrado."); // Enviar mensaje.
  65.                            //    Puerto_serie.Close(); // Cierra el puerto serie.
  66.                            //    Environment.Exit(0); // Cerrar aplicación.
  67.                            //}
  68.                // #####################################################################
  69.  
  70.            } while (true);
  71.  
  72.  
  73.        }
  74.  
  75.        // Detecta cualquier dato entrante.
  76.        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
  77.        {
  78.            SerialPort sp = (SerialPort)sender;
  79.            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
  80.            Console.WriteLine("Datos recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
  81.        }
  82.    }
  83. }
  84.  

Gracias camaradas.

Saludos.
9  Programación / Programación C/C++ / Adaptar estas variables a C++ en: 29 Julio 2020, 05:18 am
Hola:

Quiero pasar estas variables de C# a C++ con Visual studio 2019.

A pesar de mirarlo aquí, me da problemas.
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_cadenas_de_texto

Código
  1.    // Variables.
  2.    static string guardarNombre = ""; // Guardar nombre escrito.
  3.    static int coordenadaX = 0; // Coordenada X del setCursorPisition.
  4.    //static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
  5.    static int index = 0; // Índice.
  6.  
  7.    // Caracteres de este array.
  8.    static char[] roALFANUMERICO = new char[]
  9.    {
  10.        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  11.        'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  12.        'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  13.        'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  14.        '¿', '?', '(', ')', '[', ']', '{', '}', '=', '$', '&', '"', ' '
  15.    };
  16.  
  17.    // Dirección del carácter del array. El 80 presenta al espacio ' ' del array roALFANUMERICO.
  18.    static int[] roINDICE_ARRAY = new int[]
  19.    {
  20.        80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80
  21.    };
  22.  
  23.    // Palabras del array para imprimir en pantalla.
  24.    static string[] roTEXTO = new string[]{ "ATRÁS", "GUARDAR" };

Vamos, que me lo acepte C++ nativo o win32.

Saludos.
10  Informática / Electrónica / Calcular ancho de banda en: 28 Julio 2020, 14:05 pm
Hola:

Sabemos que el ancho de banda de un sistema de transmisión es la diferencia entre la frecuencia más baja y la frecuencia más alta que puede utilizar ese sistema de transmisión.

Si un sistema de transmisión posee un ancho de banda de 10Mhz significa que la diferencia entre la frecuencia más baja y la más alta de este sistema es de 10Mhz.

Pregunta: Si tengo un sistema de transmisión donde la frecuencia más baja es de 10 Khz y la frecuencia más alta es de 100Mhz, ¿cuál será el ancho de banda de este sistema de transmisión?

100 MHz = 100000 KHz.

Nota: Ambas frecuencias deben estar en el mismo orden de magnitud para realizar la diferencia.

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