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

 

 


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


  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 26 27 28 29 30 ... 237
141  Programación / .NET (C#, VB.NET, ASP) / Corregir este programa en: 17 Junio 2020, 16:43 pm
Buenas gente del foro:

Teniendo este programa, no se comporta como quiero. Se trata de usar solo las teclas flechas y la tecla Enter. Con ello se puede crear un nombre, escribir un nombre que quiera. Cuando ya termine, pulso Enter y se posiciona en la parte indicada en la imagen de abajo.

Aquí abajo, escribí todo a AAAAAAAAAAAAA.

Al pulsar Enter, tiene que ser capaz de señalar con las teclas flechas izquiera y derecha para poder elegir ATRÁS o GUARDAR.


Una vez que haya elegido con el símbolo en > ATRÁS, si pulsa Enter muestra un mensaje:
Código
  1. Console.Write("HAS PULSADO ATRÁS   ");

El programa en esta parte se acaba ahí.

Si con las flechas del teclado selecciona en > GUARDAR, luego pulsa la tecla Enter. A parte que el nombre como en este caso AAAAAAAAAAA, se almacena en la variable...
Código
  1. static string guardarNombre = "";

Muestra el mensaje: HAS GUARDADO y el nombre AAAAAAAAAAAAAAAA en pantalla.

Código completo en C#:
Código
  1. using System;
  2.  
  3. namespace LCD_nombre_archivo_consola_06
  4. {
  5.    class Program
  6.    {
  7.        static string guardarNombre = "";
  8.        static int coordenadaX = 0;
  9.        static ConsoleKey key;
  10.  
  11.        static readonly char[] roALFANUMERICO = new char[] {
  12.            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  13.            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  14.            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  15.            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  16.            '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};
  17.  
  18.        static readonly int[] roINDICE_ARRAY = new int[] {
  19.            80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };
  20.  
  21.        private static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
  22.  
  23.        static int index = 0;
  24.        static void Main(string[] args)
  25.        {
  26.            // Título de la pantalla.
  27.            Console.Title = "Cambiar nombre";
  28.  
  29.            Inicio();
  30.        }
  31.  
  32.        #region Inico.
  33.        private static void Inicio()
  34.        {
  35.            // Tamaño de la ventana.
  36.            Console.SetWindowSize(20, 5);
  37.  
  38.            // Fondo verde.
  39.            Console.BackgroundColor = ConsoleColor.Blue;
  40.  
  41.            // Letras negras.
  42.            Console.ForegroundColor = ConsoleColor.White;
  43.  
  44.            // Limpiar pantalla.
  45.            Console.Clear();
  46.  
  47.            Console.SetCursorPosition(0, 0);
  48.            Console.Write("Nombre del relé 1:  ");
  49.            Console.SetCursorPosition(0, 1);
  50.            //Console.Write("AAAAAAAAAAAAAAAA");
  51.  
  52.            // Recorre todo el índice del array y el de los datos alfanumérico.
  53.            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  54.            {
  55.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  56.            }
  57.  
  58.            Console.SetCursorPosition(2, 3);
  59.            Console.Write(roTEXTO[0]); // ATRÁS.
  60.            Console.SetCursorPosition(12, 3);
  61.            Console.Write(roTEXTO[1]); // GUARDAR.
  62.  
  63.            while (true)
  64.            {
  65.                Console.SetCursorPosition(coordenadaX, 1);
  66.                key = Console.ReadKey(true).Key;
  67.                switch (key)
  68.                {
  69.                    case ConsoleKey.RightArrow:
  70.                        if (coordenadaX < 15)
  71.                            coordenadaX++;
  72.                        break;
  73.  
  74.                    case ConsoleKey.LeftArrow:
  75.                        if (coordenadaX > 0)
  76.                            coordenadaX--;
  77.                        break;
  78.  
  79.                    case ConsoleKey.UpArrow:
  80.                        roINDICE_ARRAY[coordenadaX]++;
  81.                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  82.                        {
  83.                            roINDICE_ARRAY[coordenadaX] = 0;
  84.                        }
  85.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  86.                        break;
  87.  
  88.                    case ConsoleKey.DownArrow:
  89.                        roINDICE_ARRAY[coordenadaX]--;
  90.                        if (roINDICE_ARRAY[coordenadaX] < 0)
  91.                        {
  92.                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  93.                        }
  94.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  95.                        break;
  96.  
  97.                    case ConsoleKey.Enter:
  98.                        Console.SetCursorPosition(1, 3);
  99.                        Console.Write(">");
  100.  
  101.                        while (true)
  102.                        {
  103.                            key = Console.ReadKey(true).Key;
  104.  
  105.                            switch (key)
  106.                            {
  107.                                case ConsoleKey.RightArrow:
  108.                                case ConsoleKey.LeftArrow:
  109.                                    index = 1 - index;
  110.                                    break;
  111.  
  112.                                case ConsoleKey.UpArrow:
  113.                                case ConsoleKey.DownArrow:
  114.                                    Console.SetCursorPosition(coordenadaX, 1);
  115.                                    break;
  116.  
  117.                                case ConsoleKey.Enter:
  118.  
  119.                                    break;
  120.                            }
  121.  
  122.                            for (int a = 0; a < 2; a++)
  123.                            {
  124.                                Console.SetCursorPosition(1 + (10 * a), 3);
  125.                                if (a == index)
  126.                                    Console.Write(">");
  127.                                else
  128.                                    Console.Write(" ");
  129.                            }
  130.  
  131.                            if (index == 0)  // se pulsó Atrás
  132.                            {
  133.                                Atras();
  134.                                //break;  // vuelve a la edición de letras
  135.                            }
  136.  
  137.                            if (index == 1)  // se pulsó Guardar
  138.                            {
  139.                                Guardar();
  140.                            }
  141.                        }
  142.                }
  143.            }
  144.        }
  145.        #endregion
  146.  
  147.        private static void Atras()
  148.        {
  149.            Console.Clear();
  150.            Console.SetCursorPosition(0, 1);
  151.            Console.Write("HAS PULSADO ATRÁS   ");
  152.            Console.ReadKey(); // Pulse cualquier tecla para salir.
  153.        }
  154.  
  155.        private static void Guardar()
  156.        {
  157.            Console.Clear();
  158.            Console.SetCursorPosition(0, 1);
  159.            Console.Write("HAS GUARDADO       ");
  160.            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  161.            {
  162.                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  163.            }
  164.            Console.SetCursorPosition(0, 2);
  165.            Console.Write(guardarNombre);
  166.        }
  167.    }
  168. }

¿Alguna idea?

Un saludo.
142  Programación / Scripting / Probando este código en: 17 Junio 2020, 15:55 pm
Buenas:

Tengo este código de Python 2.x. No me funciona en Visual Studio Community 2019 (Gratuito).

Código
  1. import os, sys, tkFileDialog,Tkinter
  2.  
  3. root = Tkinter.Tk()
  4. root.withdraw()
  5.  
  6. formats = [ ('Roms Super Nintendo SMC','.smc'),('Roms Super Nintendo SFC','.sfc'),('Fichier Bin','.bin'),('Roms Super Nintendo','.smc .sfc .bin') ]
  7.  
  8. input = tkFileDialog.askopenfile(parent=root,mode='rb',filetypes=formats,title='Select file to swap bin HI to LO like A16->A15, A17->A16...A21->A20 and A15->21')
  9. if not input:
  10.        print "Error: Cannot open file"
  11.        sys.exit()
  12.  
  13. output = tkFileDialog.asksaveasfile(parent=root,mode='wb',filetypes=formats,title='Create output file name')
  14. if not output:
  15.        print "Error: cannot create output file"
  16.        sys.exit()
  17.  
  18.  
  19. # reading input file to a byte array
  20. data = bytearray(input.read())
  21.  
  22. # calculating rom size in 2 exponants
  23. expsize = 0
  24. bytesize = len(data)
  25. while bytesize > 1:
  26.        expsize += 1
  27.        bytesize = bytesize // 2
  28.  
  29. # init a proper size empty bytearray
  30. buffer = bytearray()
  31. for i in range(2**expsize): buffer.append(0)
  32.  
  33. # let's do the swap
  34. count = 0
  35. for i in range(len(data)):
  36.        addr = (i & 0x7fff) + ((i & 0x008000) << (expsize - 16)) + ((i & 0x010000) >> 1) + ((i & 0x020000) >> 1) + ((i & 0x040000) >> 1) + ((i & 0x080000) >> 1) + ((i & 0x100000) >> 1) + ((i & 0x200000) >> 1)
  37.        if addr != i: count += 1
  38.        buffer[addr] = data[i]
  39. print "Swapped %s (%s) addresses" % (count, hex(count))
  40.  
  41. # writing output file
  42. output.write(buffer)
  43.  
  44. # close file handles
  45. input.close()
  46. output.close()

Me sale estos errores.
Traceback (most recent call last):
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 193, in _run_module_as_main
    "__main__", mod_spec)
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 85, in _run_code
    exec(code, run_globals)
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy\__main__.py", line 45, in <module>
    cli.main()
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy/..\debugpy\server\cli.py", line 429, in main
    run()
  File "c:\program files (x86)\microsoft visual studio\2019\community\common7\ide\extensions\microsoft\python\core\debugpy/..\debugpy\server\cli.py", line 266, in run_file
    runpy.run_path(options.target, run_name=compat.force_str("__main__"))
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 261, in run_path
    code, fname = _get_code_from_file(run_name, path_name)
  File "C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python37_64\lib\runpy.py", line 236, in _get_code_from_file
    code = compile(f.read(), fname, 'exec')
  File "C:\Users\Meta\Documents\Visual Studio 2019\Python_consola_01\Python_consola_01\Python_consola_01.py", line 10
    print "Error: Cannot open file"
                                  ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Error: Cannot open file")?
Press any key to continue . . .

¿Les dicen algo?

Saludos.
143  Programación / Programación C/C++ / Re: Capturar tecla en: 16 Junio 2020, 22:26 pm
ReadConsole.

Todo sobre consola de texto en Windows: https://docs.microsoft.com/en-us/windows/console/

Muchas gracias.
144  Programación / Programación C/C++ / Capturar tecla en: 16 Junio 2020, 13:49 pm
Buenas:

En C++ CLR para almacenar en una variable cualquier tecla pulsada de hace así indicado abajo.
Código:

// Almacena la tecla pulsada en la variable.
ConsoleKey teclaInicial;

¿Cómo se hace en C++ Win32?

Saludos.
145  Programación / .NET (C#, VB.NET, ASP) / Re: ¿Cómo ocultar el cursor? en: 16 Junio 2020, 02:29 am
No me funcioina.

Descubrí que en este caso si. Lo dejo aquí abajo por si alguien lo necesita.

Código
  1. // Ocultar cursor.
  2. CONSOLE_CURSOR_INFO cci;
  3. GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
  4. cci.bVisible = 0;
  5. SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);

Saludos. Muchas gracias de todas formas.
146  Programación / .NET (C#, VB.NET, ASP) / ¿Cómo ocultar el cursor? en: 16 Junio 2020, 00:53 am
Buenas:

Trabajando con Win32 de C++ bajo Visual Studio Community 2019.

Cuando escriba Hola mundo. El cursor parpadea.

¿Hay alguna manera de quitarlo?

En C++ del CLR si se puede.

Código
  1. Console::CursorVisible = false;

En C++ Win32 no se como se hace.

Saludos.
147  Programación / .NET (C#, VB.NET, ASP) / Guardar en memoria el * en: 13 Junio 2020, 15:40 pm
Hola:

Aquí un programa hecho en consola, solo se usa las flechas del teclado y Enter.

Este programa se basa en radioButton, que en este caso funciona si selecciona una opción y pulsas Enter, se pone un asterisco. Hasta ahí bien.

Al pulsar Salir, luego Entrar, no se queda guardado el * en el último radioButton seleccionado.

¿Cómo se hace?

El código que tengo por ahora lo dejo aquí.

Código:
using System;

namespace radioButton_consola_02_cs
{
    class Program
    {
        #region Variables.
        private static readonly string[] TEXTO = new string[]
        {
            "( ) Opción A        ",
            "( ) Opción B        ",
            "( ) Opción C        ",
            "    SALIR"
        };
        #endregion

        static void Main(string[] args)
        {
            // Tamaño de la ventana.
            Console.SetWindowSize(20, 5);

            // Fondo verde.
            Console.BackgroundColor = ConsoleColor.Blue;

            // Letras negras.
            Console.ForegroundColor = ConsoleColor.White;

            // Oculto el cursor.
            Console.CursorVisible = false;

            // Almacena la tecla pulsada en la variable.
            ConsoleKey teclaInicial;

            do
            {
                // Limpiar pantalla.
                Console.Clear();

                // Posición del cursor del título del MENÚ PRINCIPAL.
                Console.SetCursorPosition(0, 0);

                // Título.
                Console.Write("   MENÚ PRINCIPAL   ");

                // Pocisión de la hora.
                Console.SetCursorPosition(4, 2);

                // Formato numérico dd/MM/yyyy.
                Console.Write(DateTime.Now.ToString("ddd dd MMM"));

                // Almacena en la variable una tecla pulsada.
                teclaInicial = Console.ReadKey(true).Key;

                // ¿Haz pulsado la tecla Enter?
                if (teclaInicial == ConsoleKey.Enter)
                {
                    // Sí. Se ejecuta esta función.
                    MenuPrincipal();
                }
            } while (teclaInicial != ConsoleKey.Escape);

            #region Menú Principal.
            void MenuPrincipal()
            {
                bool salir = false;

                // En itemSelecionado:
                // -1 = Sin seleccionar con * ninguna opción.
                // 0 = Seleccionar con * la Opción A.
                // 1 = Seleccionar con * la Opción B.
                // 2 = Seleccionar con * la opción C.
                int itemSeleccionado = 0;
                int itemSeñalado = 0;

                // Capturar tecla para luego validar.
                ConsoleKey tecla;

                do
                {
                    //******************************************************************
                    // Dibujo el menú principal.

                    // Rellenar fondo verde.
                    //Console.BackgroundColor = ConsoleColor.Green;

                    // Letras negras.
                    //Console.ForegroundColor = ConsoleColor.Black;

                    // Limpiar pantalla.
                    Console.Clear();

                    for (int k = 0; k < TEXTO.Length; k++)
                    {
                        Console.SetCursorPosition(0, k);
                        Console.Write(itemSeñalado == k ? "> " : "  ");
                        Console.Write(TEXTO[k]);
                        Console.SetCursorPosition(3, k);
                        Console.Write(itemSeleccionado == k ? "*" : " ");
                    }

                    // Fin de pintar el menú principal.
                    //******************************************************************

                    // Leer tecla ingresada por el usuario.
                    tecla = Console.ReadKey(true).Key;

                    switch (tecla)
                    {
                        case ConsoleKey.Enter:
                            itemSeleccionado = itemSeñalado;
                            salir = (itemSeleccionado == TEXTO.Length - 1);
                            break;

                        case ConsoleKey.DownArrow:
                            if (++itemSeñalado >= TEXTO.Length)
                            {
                                itemSeñalado = 0;
                            }
                            break;

                        case ConsoleKey.UpArrow:
                            if (--itemSeñalado < 0)
                            {
                                itemSeñalado = TEXTO.Length - 1;
                            }
                            break;
                    }
                    // Uso la tecla escape como salida.
                } while (!salir);
            }
            #endregion
        }
    }
}

Saludos.
148  Programación / .NET (C#, VB.NET, ASP) / Corregir un fallo en: 11 Junio 2020, 12:33 pm
Buenas:



Usando el teclado solo las flechas y el Enter, en este programa puedo escribir nombre y se muestra en pantalla. Al escribir un nombre, pulso Enter y correctamente me lleva a la zona de > "Atrás". Si con la flecha derecha o izquierda me tiene que llevar a la parte de > Guardar.

El problema está que tiene que indicar con el caracter > en Guardar, y se ejecuta directamente, cosa que no debe ser. En la zona Atrás y Guardar solo se ejecuta si pulso Enter.

Dejo el código aquí como ejemplo.
Código
  1. using System;
  2.  
  3. namespace LCD_nombre_archivo_consola_03
  4. {
  5.    class Program
  6.    {
  7.        static string guardarNombre = "";
  8.        static int coordenadaX = 0;
  9.        static ConsoleKey key;
  10.  
  11.        static readonly char[] roALFANUMERICO = new char[] {
  12.            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  13.            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  14.            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  15.            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  16.            '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};
  17.        static readonly int[] roINDICE_ARRAY = new int[] {
  18.            80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };
  19.        static readonly string[] TEXTO = new string[] { "ATRÁS", "GUARDAR" };
  20.        static int index = 0;
  21.        static void Main(string[] args)
  22.        {
  23.            // Título de la pantalla.
  24.            Console.Title = "Cambiar nombre";
  25.  
  26.            Inicio();
  27.        }
  28.  
  29.        #region Inico.
  30.        private static void Inicio()
  31.        {
  32.            // Tamaño de la ventana.
  33.            Console.SetWindowSize(20, 5);
  34.  
  35.            // Fondo verde.
  36.            Console.BackgroundColor = ConsoleColor.Blue;
  37.  
  38.            // Letras negras.
  39.            Console.ForegroundColor = ConsoleColor.White;
  40.  
  41.            Console.Clear();
  42.  
  43.            Console.SetCursorPosition(0, 0);
  44.            Console.Write("Nombre del relé 1:  ");
  45.            Console.SetCursorPosition(0, 1);
  46.            //Console.Write("AAAAAAAAAAAAAAAA");
  47.  
  48.            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  49.            {
  50.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  51.            }
  52.  
  53.            Console.SetCursorPosition(2, 3);
  54.            Console.Write(TEXTO[0]); // ATRÁS.
  55.            Console.SetCursorPosition(12, 3);
  56.            Console.Write(TEXTO[1]); // GUARDAR.
  57.  
  58.            while (true)
  59.            {
  60.                Console.SetCursorPosition(coordenadaX, 1);
  61.                key = Console.ReadKey(true).Key;
  62.                switch (key)
  63.                {
  64.                    case ConsoleKey.RightArrow:
  65.                        if (coordenadaX < 15)
  66.                            coordenadaX++;
  67.                        break;
  68.  
  69.                    case ConsoleKey.LeftArrow:
  70.                        if (coordenadaX > 0)
  71.                            coordenadaX--;
  72.                        break;
  73.  
  74.                    case ConsoleKey.UpArrow:
  75.                        roINDICE_ARRAY[coordenadaX]++;
  76.                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  77.                        {
  78.                            roINDICE_ARRAY[coordenadaX] = 0;
  79.                        }
  80.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  81.                        break;
  82.  
  83.                    case ConsoleKey.DownArrow:
  84.                        roINDICE_ARRAY[coordenadaX]--;
  85.                        if (roINDICE_ARRAY[coordenadaX] < 0)
  86.                        {
  87.                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  88.                        }
  89.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  90.                        break;
  91.  
  92.                    case ConsoleKey.Enter:
  93.                        Console.SetCursorPosition(1, 3);
  94.                        Console.Write(">");
  95.  
  96.                        while (true)
  97.                        {
  98.                            key = Console.ReadKey(true).Key;
  99.  
  100.                            switch (key)
  101.                            {
  102.                                case ConsoleKey.RightArrow:
  103.                                case ConsoleKey.LeftArrow:
  104.                                    index = 1 - index;
  105.                                    break;
  106.  
  107.                                case ConsoleKey.UpArrow:
  108.                                case ConsoleKey.DownArrow:
  109.                                    Console.SetCursorPosition(coordenadaX, 1);
  110.                                    break;
  111.  
  112.                                case ConsoleKey.Enter:
  113.  
  114.                                    break;
  115.                            }
  116.  
  117.                            for (int a = 0; a < 2; a++)
  118.                            {
  119.                                Console.SetCursorPosition(1 + (10 * a), 3);
  120.                                if (a == index)
  121.                                    Console.Write(">");
  122.                                else
  123.                                    Console.Write(" ");
  124.                            }
  125.  
  126.                            if (index == 0)  // se pulsó Atrás
  127.                            {
  128.                                Atras();
  129.                                //break;  // vuelve a la edición de letras
  130.                            }
  131.                            else if (index == 1)  // se pulsó Guardar
  132.                            {
  133.                                Guardar();
  134.                            }
  135.                        }
  136.                }
  137.            }
  138.        }
  139.        #endregion
  140.  
  141.        private static void Atras()
  142.        {
  143.            Console.Clear();
  144.            Console.SetCursorPosition(0, 1);
  145.            Console.Write("HAS PULSADO ATRÁS   ");
  146.            Console.ReadKey(); // Pulse cualquier tecla para salir.
  147.        }
  148.  
  149.        private static void Guardar()
  150.        {
  151.            Console.Clear();
  152.            Console.SetCursorPosition(0, 1);
  153.            Console.Write("HAS GUARDADO       ");
  154.            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  155.                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  156.            Console.SetCursorPosition(0, 2);
  157.            Console.Write(guardarNombre);
  158.        }
  159.    }
  160. }

Un cordial saludos.
149  Programación / .NET (C#, VB.NET, ASP) / Re: Cambio de estilo en: 5 Abril 2020, 05:51 am
Serial es pa rael puerto serie.

Que se parezca programar C de Arduino cuando estás con C#.
150  Programación / .NET (C#, VB.NET, ASP) / Cambio de estilo en: 4 Abril 2020, 20:28 pm
Hola:

En un archivo de Arduino C, se escribe algo así.
Código
  1. void setup()
  2. {
  3.  // put your setup code here, to run once:
  4.  
  5. }
  6.  
  7. void loop()
  8. {
  9.  // put your main code here, to run repeatedly:
  10.  
  11. }

Quiero simularlo en C# los setup y loop. Que daría en C# así:
Código
  1. using System;
  2.  
  3. namespace Prueba
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            setup();
  10.            while (true)
  11.            {
  12.                loop();
  13.            }
  14.        }
  15.  
  16.        private static void setup()
  17.        {
  18.          // put your setup code here, to run once:
  19.        }
  20.  
  21.        private static void loop()
  22.        {
  23.          // put your main code here, to run repeatedly:
  24.        }
  25.    }
  26. }

Mostrar texto en consola de C# es así:
Código
  1. Console.Write"¡Hola Mundo!";

En Arduino mostarlo en un LCD es así:
Código
  1. lcd.printf("¡Hola Mundo!");

Se crea en C# simulando el C de Arduino así:
Código
  1. public static class lcd{
  2.  
  3.    public static void printf(string mensaje){
  4.  
  5.        Console.Write(mensaje);
  6.  
  7.   }
  8.  
  9. }

¿Cómo hago en C# una buena plantilla para que se vea solo lo de abajo?
Código
  1.    void setup()
  2.    {
  3.      // put your setup code here, to run once:
  4.  
  5.    }
  6.  
  7.    void loop()
  8.    {
  9.      // put your main code here, to run repeatedly:
  10.  
  11.    }

En pleno C#.

Saludos.
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 26 27 28 29 30 ... 237
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines