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


Tema destacado: Sigue las noticias más importantes de seguridad informática en el Twitter! de elhacker.NET


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 [10] 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 ... 261
91  Programación / .NET (C#, VB.NET, ASP) / Re: Recibir dos tramas por RS232 diferentes. en: 28 Noviembre 2023, 23:43 pm
Hola de nuevo.

He modificado nombre de las variables y lo he adaptado el Windows Form .net 4.8 al .net 8.0.

Me sale este error: Puerto cerrado.

Código
  1. using System.IO.Ports;
  2.  
  3. namespace Termite_SAI_05_.NET_8._0
  4. {
  5.    public partial class Form1 : Form
  6.    {
  7.        SerialPort puertoSerie;
  8.        bool verComandoBFlag = false;
  9.        bool verComandoX72Flag = false;
  10.        readonly string verComandoBReq = "B\r";
  11.        readonly string verComandoX72Req = "X72\r";
  12.  
  13.        private void Form1_Load(object sender, EventArgs e)
  14.        {
  15.  
  16.        }
  17.  
  18.        public Form1()
  19.        {
  20.            InitializeComponent();
  21.            InitSerialPort();
  22.        }
  23.  
  24.        /* Iniciar y configurar el puerto serie */
  25.        private void InitSerialPort()
  26.        {
  27.            try
  28.            {
  29.                puertoSerie = new SerialPort("COM3", 2400,
  30.                    Parity.None, 8, StopBits.One)
  31.                {
  32.                    Handshake = Handshake.None,
  33.                    ReadTimeout = 500,
  34.                    WriteTimeout = 500,
  35.                    DtrEnable = true,
  36.                    RtsEnable = true
  37.                };
  38.  
  39.                // Subscribir el evento Sp_DataReceived cuando lleguen datos
  40.                puertoSerie.DataReceived += Sp_DataReceived;
  41.            }
  42.            catch (Exception ex)
  43.            {
  44.                MessageBox.Show(ex.Message);
  45.                puertoSerie.Close(); // Cierra el puerto en caso de error
  46.            }
  47.        }
  48.  
  49.        /* Evento para leer asíncronamente datos del puerto serie */
  50.        void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
  51.        {
  52.            if (puertoSerie.IsOpen)
  53.            {
  54.                Task.Run(async () =>
  55.                {
  56.                    try
  57.                    {
  58.                        await Task.Delay(500); // Pausa para recibir datos
  59.                        string str = puertoSerie.ReadExisting();
  60.                        if (!String.IsNullOrEmpty(str))
  61.                        {
  62.                            if (verComandoBFlag) { ProcessverComandoBReq(str); }
  63.                            if (verComandoX72Flag) { ProcessverComandoX72Req(str); }
  64.                        }
  65.                        else
  66.                        {
  67.                            Console.Write("Datos leídos corruptos.");
  68.                        }
  69.                    }
  70.                    catch (IndexOutOfRangeException ex)
  71.                    {
  72.                        Console.Write("Índice fuera de los límites de la matriz.");
  73.                        MessageBox.Show(ex.Message);
  74.                    }
  75.                    catch (FormatException ex)
  76.                    {
  77.                        Console.Write("La cadena de entrada no tiene el formato correcto.");
  78.                        MessageBox.Show(ex.Message, "Error");
  79.                    }
  80.                });
  81.            }
  82.        }
  83.  
  84.        /* Procesar verComandoX72Req */
  85.        private void ProcessverComandoX72Req(string str)
  86.        {
  87.            verComandoX72Flag = false;
  88.            char[] separadores = { '#', ',' };
  89.            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
  90.  
  91.            // Al manipular controles de Windows Forms desde un hilo diferente al
  92.            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia
  93.            if (InvokeRequired)
  94.            {
  95.                Invoke(new Action(() =>
  96.                {
  97.                    UpdateUIControlsVerTabla(salida);
  98.                }));
  99.            }
  100.            else
  101.            {
  102.                UpdateUIControlsVerTabla(salida);
  103.            }
  104.        }
  105.  
  106.        /* Procesar verComandoBReq */
  107.        private void ProcessverComandoBReq(string str)
  108.        {
  109.            verComandoBFlag = false;
  110.            char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r'};
  111.            string[] salida = str.Split(separadores, StringSplitOptions.RemoveEmptyEntries);
  112.  
  113.            // Al manipular controles de Windows Forms desde un hilo diferente al
  114.            // hilo de la interfaz de usuario, es necesario usar Invoke para evitar problemas de concurrencia
  115.            if (InvokeRequired)
  116.            {
  117.                Invoke(new Action(() =>
  118.                {
  119.                    UpdateUIControlsVerDatos(salida);
  120.                }));
  121.            }
  122.            else
  123.            {
  124.                UpdateUIControlsVerDatos(salida);
  125.            }
  126.        }
  127.  
  128.        /* Mostrar datos verComandoX72Req */
  129.        private void UpdateUIControlsVerTabla(string[] salida)
  130.        {
  131.            label_Resultado_valores_nonimales_de_alimentacion.Text
  132.               = salida[0] + " VA / " + salida[1] + " W";
  133.            label_Resultado_voltaje_nominal.Text
  134.                = salida[2] + " Vac";
  135.            label_Resultado_corriente_nominal.Text
  136.                = salida[5] + " A";
  137.            label_Resultado_valores_nominales_de_frecuencia.Text
  138.                = salida[3] + " ~ " + salida[4] + " Hz";
  139.        }
  140.  
  141.        /* Mostrar datos verComandoBReq */
  142.        private void UpdateUIControlsVerDatos(string[] salida)
  143.        {
  144.            label_I.Text
  145.                  = salida[0] + " Vac";
  146.            label_O.Text
  147.                = salida[1] + " Vac";
  148.            label_L.Text
  149.                = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
  150.            label_B.Text
  151.                = salida[3] + " %";
  152.            label_V.Text
  153.                = salida[4] + " Vdc";
  154.            label_F.Text
  155.                = salida[5].PadRight(5, '0') + " Hz"; // Añade ceros a la derecha.
  156.            label_H.Text
  157.                = salida[6].PadRight(5, '0') + " Hz";
  158.  
  159.            // Convertir variable tipo string a tipo int, es decir, la variable tipo string "salida[7]"
  160.            // se convierte en tipo int "resultadoSalida7".
  161.            int resultadoSalida7 = Int32.Parse(salida[7]);
  162.  
  163.            #region Horas y minutos.
  164.            // Cálculos.
  165.            int horas = resultadoSalida7 / 60;
  166.            int minutos = resultadoSalida7 % 60;
  167.  
  168.            // ¿0 horas y 1 minuto?
  169.            if ((horas == 0) && (minutos == 1))
  170.            {
  171.                label_R.Text = $"{minutos} minuto.";
  172.            }
  173.  
  174.            // ¿0 horas y 0 minuto?
  175.            if ((horas == 0) && (minutos == 0))
  176.            {
  177.                label_R.Text = $"{minutos} minutos";
  178.            }
  179.  
  180.            // ¿0 horas y más de 1 minuto?
  181.            if ((horas == 0) && (minutos > 1))
  182.            {
  183.                label_R.Text = $"{minutos} minutos.";
  184.            }
  185.  
  186.            // ¿1 hora y 0 minutos?
  187.            if ((horas == 1) && (minutos == 0))
  188.            {
  189.                label_R.Text = $"{horas} hora.";
  190.            }
  191.  
  192.            // ¿Más de una hora y 0 minutos?
  193.            if ((horas > 1) && (minutos == 0))
  194.            {
  195.                label_R.Text = $"{horas} horas.";
  196.            }
  197.  
  198.            // ¿1 hora y 1 minuto?
  199.            if ((horas == 1) && (minutos == 1))
  200.            {
  201.                label_R.Text = $"{horas} hora y {minutos} minuto";
  202.            }
  203.  
  204.            // ¿1 hora y más de 1 minuto?
  205.            if ((horas == 1) && (minutos > 1))
  206.            {
  207.                label_R.Text = $"{horas} hora y {minutos} minutos.";
  208.            }
  209.  
  210.            // ¿Más de 1 hora y 1 minuto?
  211.            if ((horas > 1) && (minutos == 1))
  212.            {
  213.                label_R.Text = $"{horas} horas y {minutos} minuto.";
  214.            }
  215.  
  216.            // ¿Más de 1 horas y más de 1 minuto?
  217.            if ((horas > 1) && (minutos > 1))
  218.            {
  219.                label_R.Text = $"{horas} horas y {minutos} minutos.";
  220.            }
  221.            #endregion
  222.        }
  223.  
  224.        /* Evento de botón: Abrir puerto serie y mandar "B" */
  225.        private void button_Comando_B_Click(object sender, EventArgs e)
  226.        {
  227.            if (puertoSerie.IsOpen)
  228.            {
  229.                verComandoBFlag = true;
  230.                puertoSerie.Open();
  231.                puertoSerie.Write(verComandoBReq);
  232.            }
  233.            else
  234.            {
  235.                MessageBox.Show("Puerto cerrado. " +
  236.                "No se puede solicitar datos.");
  237.  
  238.            }
  239.        }
  240.  
  241.        /* Evento de botón: Abrir puerto serie y mandar "X72" */
  242.        private void button1_Click(object sender, EventArgs e)
  243.        {
  244.            if (puertoSerie.IsOpen)
  245.            {
  246.                verComandoX72Flag = true;
  247.                puertoSerie.Open();
  248.                puertoSerie.Write(verComandoX72Req);
  249.            }
  250.            else
  251.            {
  252.                MessageBox.Show("Puerto cerrado. " +
  253.                    "No se puede enviar datos.");
  254.            }
  255.        }
  256.    }
  257. }
  258.  
  259.  

Algo pasa que no me deja abrir el puerto.
92  Programación / .NET (C#, VB.NET, ASP) / Re: Minutos y minuto en: 28 Noviembre 2023, 21:19 pm
Está bien.
93  Programación / .NET (C#, VB.NET, ASP) / Re: Minutos y minuto en: 28 Noviembre 2023, 16:20 pm
Lo se.
Gracias 🙂
94  Programación / .NET (C#, VB.NET, ASP) / Re: Recibir dos tramas por RS232 diferentes. en: 28 Noviembre 2023, 14:02 pm
Cuando llegue a mi casa lo pruebo.

Hay algo que se me escapó y no te conté.

Todas las tramas de string o Bytes siempre empieza con # y acaba en \r.

#I230.3O230.0L007B100V25.7F50.2H50.2R0080S„€ˆ„\r

Lo comento por si acaso y los delimitadores se incluye el \r también.
95  Informática / Electrónica / Re: Relé USB HID en: 28 Noviembre 2023, 00:39 am
Hola gente:

Estoy usando un SAI/UPS que usa USB por HID y puerto serie del protocolo RS232. Si no sabes los comandos y tramas de bytes de respuesta si la hay, es usar Sniffer RS232. Lo mismo para el USB que los hay. Lo que no se como se trabaja en USB con el HID todavía, no me he puesto.

Si que estoy pescando e intentando leer varias tramas de string o Bytes para mostrar los datos en pantalla a parte de controlar el dispositivo.

Ejemplo:

ver zoom.

En este caso no me hace falta por ahora un sniffer, ya que el fabricante me dio el protocolo de comunicación de RS232 en pdf que puedes ver aquí.

Me imagino que te habrá venido un software, mira ver si en la Web tiene un SDK, con ello puedes hacer lo que quieras, porque a mi, no me vino SDK nada de nada.

Suerte con tu proyecto y vas avisando por aquí poco a poco.

Buen trabajo.
96  Programación / .NET (C#, VB.NET, ASP) / Re: Horas, hora, minutos y minuto. en: 28 Noviembre 2023, 00:09 am
Eres un crack.  ;-) ;-) ;-) ;-)
97  Programación / .NET (C#, VB.NET, ASP) / Re: Recibir dos tramas por RS232 diferentes. en: 28 Noviembre 2023, 00:06 am
Hola:

He hecho una interfaz con Windows Form como indica en la captura.

Se trata a la hora de recibir tramas de string o bytes por el puerto serie.

Si envío el comando X72\r, me llega la tramas de Bytes y lo muestra en los labels marcado en rojo.

Si envío otro comando en este caso llamado X72\r muestra los valores en otras etiquetas indicado en el recuardro en verde.

Ver zoom.

El problema como puedes ver en la captura, te muestra cada comando tramas diferentes en el cual quiero guardarlo en su variable para luego poder poner los valores en sus respectivos labels.

Los comandos los puedes ver, sus respuestas y errores si los hay.

Ver comandos PDF.

Código que he hecho hasta ahora solo funciona para el recuerdre verde.
Código:
using System;
using System.IO.Ports;
using System.Threading;
using System.Windows.Forms;

namespace Termite_SAI_04
{
    public partial class Form1 : Form
    {
        private delegate void DelegadoAcceso(String accion);
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                serialPort1 = new SerialPort("COM3", 2400, Parity.None, 8, StopBits.One);
                serialPort1.Handshake = Handshake.None;
                serialPort1.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
                serialPort1.ReadTimeout = 500;
                serialPort1.WriteTimeout = 500;
                serialPort1.DtrEnable = true;
                serialPort1.RtsEnable = true;
                serialPort1.Open();
                ComandoB();
                timer1.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (this.Enabled == true)
            {
                Thread.Sleep(500);
                string entrada = serialPort1.ReadExisting();
                this.BeginInvoke(new DelegadoAcceso(si_DataReceived), new object[] { entrada });
                //serialPort1.Write("B\r"); // Envía comando.
            }
        }

        private void si_DataReceived(string accion)
        {
            try
            {
                char[] separadores = { '#', 'I', 'O', 'L', 'B', 'V', 'F', 'H', 'R', 'S', '\r' };

                string[] salida = accion.Split(separadores, StringSplitOptions.RemoveEmptyEntries);

                label_I.Text = salida[0] + " Vac";
                label_O.Text = salida[1] + " Vac";
                label_L.Text = salida[2].TrimStart('0') + " %"; // Quita los ceros de la izquierda.
                label_B.Text = salida[3] + " %";
                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 int, es decir, la variable tipo string "salida[7]"
                // se convierte en tipo int "resultadoSalida7".
                int resultadoSalida7 = Int32.Parse(salida[7]);

                #region Mostrar horas y minutos.
                // Cálculos.
                int horas = resultadoSalida7 / 60;
                int 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
            }

            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");
            }
        }

        private void button_Ver_datos_Click_1(object sender, EventArgs e)
        {
            ComandoB();
        }

        private void button_Ver_Tabla_Click_1(object sender, EventArgs e)
        {
            ComandoX72();
        }

        // Comandos.
        void ComandoB()
        {
            serialPort1.Write("B\r");
        }

        void ComandoX72()
        {
            serialPort1.Write("X72\r");
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            ComandoB();
        }

        // Al cerrar el formulario.
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            timer1.Stop();          // Detiene el temporizador.
            Thread.Sleep(700);      // 0.5 segudos. 500 milisegundos.
            serialPort1.Close();    // Cierra el puerto serie.
        }
    }
}

¿Alguna idea?

Saludos.
98  Programación / .NET (C#, VB.NET, ASP) / Re: Horas, hora, minutos y minuto. en: 27 Noviembre 2023, 19:44 pm
Buenas de nuevo.

Ahora si lo quiero el funcionamiento tal cual como debe ser.


No digo que sea el mejor código pero funciona de maravilla.

Código
  1. using System;
  2.  
  3. namespace Minutos_Horas_Consola_04
  4. {
  5.    internal class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            #region Configuración ventana.
  10.            // Título de la ventana.
  11.            Console.Title = "De solo a Minutos a Horas y Minutos";
  12.  
  13.            // Tamaño de la ventana, x, y, o ancho y alto.
  14.            const byte ANCHO_X = 70, ALTO_Y = 25;
  15.            Console.SetWindowSize(ANCHO_X, ALTO_Y);
  16.  
  17.            // Color de fondo.
  18.            Console.BackgroundColor = ConsoleColor.Green;
  19.  
  20.            // Color de las letras.
  21.            Console.ForegroundColor = ConsoleColor.Black;
  22.  
  23.            // Limpiar pantalla y dejarlo todo en color de fondo.
  24.            Console.Clear();
  25.  
  26.            // Visible el cursor.
  27.            Console.CursorVisible = true;
  28.            #endregion
  29.  
  30.            while (true)
  31.            {
  32.                int totalMinutos;
  33.                Console.Write("Ingresa el valor de minutos: ");
  34.                totalMinutos = int.Parse(Console.ReadLine());
  35.  
  36.                // Cálculos.
  37.                int horas = totalMinutos / 60;
  38.                int minutos = totalMinutos % 60;
  39.  
  40.                // ¿0 horas y 1 minuto?
  41.                if ((horas == 0) && (minutos == 1))
  42.                {
  43.                    Console.WriteLine($"> {minutos} minuto.");
  44.                }
  45.  
  46.                // ¿0 horas y 0 minuto?
  47.                if ((horas == 0) && (minutos == 0))
  48.                {
  49.                    Console.WriteLine($"> {minutos} minutos.");
  50.                }
  51.  
  52.                // ¿0 horas y más de 1 minuto?
  53.                if ((horas == 0) && (minutos > 1))
  54.                {
  55.                    Console.WriteLine($"> {minutos} minutos.");
  56.                }
  57.  
  58.                // ¿1 hora y 0 minutos?
  59.                if ((horas == 1) && (minutos == 0))
  60.                {
  61.                    Console.WriteLine($"> {horas} hora.");
  62.                }
  63.  
  64.                // ¿Más de una hora y 0 minutos?
  65.                if ((horas > 1) && (minutos == 0))
  66.                {
  67.                    Console.WriteLine($"> {horas} horas.");
  68.                }
  69.  
  70.                // ¿1 hora y 1 minuto?
  71.                if ((horas == 1) && (minutos == 1))
  72.                {
  73.                    Console.WriteLine($"> {horas} hora y {minutos} minuto.");
  74.                }
  75.  
  76.                // ¿1 hora y más de 1 minuto?
  77.                if ((horas == 1) && (minutos > 1))
  78.                {
  79.                    Console.WriteLine($"> {horas} hora y {minutos} minutos.");
  80.                }
  81.  
  82.                // ¿Más de 1 hora y 1 minuto?
  83.                if ((horas > 1) && (minutos == 1))
  84.                {
  85.                    Console.WriteLine($"> {horas} horas y {minutos} minuto.");
  86.                }
  87.  
  88.                // ¿Más de 1 horas y más de 1 minuto?
  89.                if ((horas > 1) && (minutos > 1))
  90.                {
  91.                    Console.WriteLine($"> {horas} horas y {minutos} minutos.");
  92.                }
  93.            }
  94.        }
  95.    }
  96. }
  97.  

Son solo nueve combinaciones.

Saludos.
99  Programación / Scripting / Enviar y recibir comandos con PowerShell en: 27 Noviembre 2023, 00:12 am
Hola:

Quiero enviar dos comandos. Este es B<cr>. La letra B mayúscula y el retorno de carro. También quiero enviar otro comando por el puerto serie que es este, X72<cr>.

Una vez enviado el comando, su respuesta es trama de Bytes como este:

Comando B<cr>
Respuesta: #I225.7O226.2L006B100V25.7F50.2H50.2R0080S€„€ˆ„<cr>

Tal como muestra aquí.


Simplemente eso. No estoy familiarizado en PowerShell y por algo se empieza.

Saludos.
100  Programación / .NET (C#, VB.NET, ASP) / Re: Horas, hora, minutos y minuto. en: 26 Noviembre 2023, 20:30 pm
Muy buen código rápido.  ;-) ;-) ;-) ;-)

Hay una cosa que se te escapa.

En vez de poner:
> 0 horas y 1 minuto

Debe solo aparecer esto:
> 1 minuto.

Ya que el 0 horas no pinta nada. Otra cosa que sea al revés como esto:
> 1 Hora y 0 minutos. Así me da igual. O simplemente se pone a > 1 Hora.

Todo parece perfecto menos la parte 0 horas.

Por cierto, la forma nueva de mostrar en consola es esta.
Código
  1. Console.WriteLine($"> {h} {hs} y {m} {ms}");

Tu código es elegante.  ;D

Páginas: 1 2 3 4 5 6 7 8 9 [10] 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 ... 261
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines