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
Cita de: Eternal Idol en 16 Junio 2020, 13:57 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