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

 

 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Adaptación de códigos
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Adaptación de códigos  (Leído 4,802 veces)
Meta


Desconectado Desconectado

Mensajes: 3.501



Ver Perfil WWW
Adaptación de códigos
« en: 19 Mayo 2022, 21:31 pm »

Buena gente.

Tengo una función de consola C# y quiero adaptarlo a Arduino, lo tengo a medias pero me fallan cosas. Sobre todo la pulsaciones de teclas y botones.

Espero tener ualguna ayuda.

Código C#:
Código
  1. using System;
  2. using System.IO;
  3.  
  4. namespace LCD_Menu_con_submenus_Consola_01
  5. {
  6.    public class NombresReles
  7.    {
  8.        // Variables.
  9.        static int coordenadaX = 0;         // Coordenada X del textBox del nombre del Relé.
  10.        static int index = 0;               // Índice de ATRÁS y GUARDAR.
  11.        static int textBox = 0;             // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
  12.        static string[] nombresDeLosReles;  // Líneas que al final se van a guardar en Archivo.txt.
  13.        static bool cargado = false;        // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.
  14.  
  15.        // Caracteres alfanuméricos en el array.
  16.        static readonly char[] roALFANUMERICO = new char[]
  17.        {
  18.            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  19.            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  20.            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  21.            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  22.            '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  23.            ' '
  24.        };
  25.  
  26.        // Índices de los caracteres de los 8 Relés para el array alfanumérico.
  27.        // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
  28.        static readonly int[][] roINDICE_ARRAY = new int[][]
  29.        {
  30.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  31.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  32.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  33.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  34.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  35.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  36.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  37.            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
  38.        };
  39.  
  40.        static readonly char[] roNUMERICO = new char[] { '1', '2', '3', '4', '5', '6', '7', '8' };
  41.        static int roINDICE_NUMERICO = 0;
  42.  
  43.        public static void NombreReles_Principal()
  44.        {
  45.            ConsoleKey tecla, tecla2;
  46.            int indice = 0;
  47.  
  48.            Inicio();
  49.  
  50.            while (true)
  51.            {
  52.                Console.CursorVisible = true; // Mostrar cursor.
  53.                tecla = Console.ReadKey(true).Key;
  54.  
  55.                // ¿Has pulsado tecla flecha arriba?
  56.                if (tecla == ConsoleKey.RightArrow) // Sí.
  57.                {
  58.                    if (textBox == 0)
  59.                    {
  60.                        Console.SetCursorPosition(4, 1);
  61.                        textBox = 1;
  62.                    }
  63.                    else // textBox == 1
  64.                    {
  65.                        if (coordenadaX < 15)
  66.                        {
  67.                            coordenadaX++;
  68.                            Console.SetCursorPosition(4 + coordenadaX, 1);
  69.                        }
  70.                    }
  71.                }
  72.                // Entonces. ¿Haz pulsado flecha izquierda?
  73.                else if (tecla == ConsoleKey.LeftArrow) // Sí.
  74.                {
  75.                    if (textBox == 1)
  76.                    {
  77.                        if (coordenadaX > 0)
  78.                        {
  79.                            coordenadaX--;
  80.                            Console.SetCursorPosition(4 + coordenadaX, 1);
  81.                        }
  82.                        else
  83.                        {
  84.                            Console.SetCursorPosition(2, 1);
  85.                            textBox = 0;
  86.                        }
  87.                    }
  88.                }
  89.                // Entonces. ¿Haz pulsado flecha abajo?
  90.                else if (tecla == ConsoleKey.DownArrow) // Sí.
  91.                {
  92.                    if (textBox == 0)
  93.                    {
  94.                        roINDICE_NUMERICO--;
  95.                        if (roINDICE_NUMERICO < 0)
  96.                        {
  97.                            roINDICE_NUMERICO = 7;
  98.                        }
  99.                        Console.SetCursorPosition(2, 1);
  100.                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  101.                        MostrarLineaNombre();
  102.                        Console.SetCursorPosition(2, 1);
  103.                    }
  104.                    else // textBox == 1
  105.                    {
  106.                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
  107.                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
  108.                        {
  109.                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
  110.                        }
  111.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  112.                        Console.SetCursorPosition(4 + coordenadaX, 1);
  113.                    }
  114.                }
  115.                // Entonces. ¿Haz pulsado flecha arriba?
  116.                else if (tecla == ConsoleKey.UpArrow) // Sí.
  117.                {
  118.                    if (textBox == 0)
  119.                    {
  120.                        roINDICE_NUMERICO++;
  121.                        if (roINDICE_NUMERICO >= 8)
  122.                        {
  123.                            roINDICE_NUMERICO = 0;
  124.                        }
  125.                        Console.SetCursorPosition(2, 1);
  126.                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  127.                        MostrarLineaNombre();
  128.                        Console.SetCursorPosition(2, 1);
  129.                    }
  130.                    else // textBox == 1
  131.                    {
  132.                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
  133.                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
  134.                        {                                                        // total y al alcanzarla ahí paso al comienzo (0)
  135.                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
  136.                        }
  137.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  138.                        Console.SetCursorPosition(4 + coordenadaX, 1);
  139.                    }
  140.                }
  141.                // Entonces. ¿Haz pulsado la tecla Enter?
  142.                else if (tecla == ConsoleKey.Enter) // Sí.
  143.                {
  144.                    Console.CursorVisible = false;
  145.                    Console.SetCursorPosition(0, 3);
  146.                    Console.Write("> ATRÁS     GUARDAR ");
  147.                    index = 0;
  148.                    while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  149.                    {
  150.                        if ((tecla2 == ConsoleKey.RightArrow) || (tecla2 == ConsoleKey.LeftArrow))
  151.                        {
  152.                            index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
  153.                            Console.SetCursorPosition(0, 3);
  154.                            if (index == 0)
  155.                            {
  156.                                Console.Write("> ATRÁS     GUARDAR ");
  157.                            }
  158.                            else
  159.                            {
  160.                                Console.Write("  ATRÁS   > GUARDAR ");
  161.                            }
  162.                        }
  163.                    }
  164.                    if (index == 1)  // Se pulsó Enter en Guardar.
  165.                    {
  166.                        nombresDeLosReles = new string[8];
  167.                        for (int a = 0; a < 8; a++)
  168.                        {
  169.                            for (int b = 0; b < 16; b++)
  170.                            {
  171.                                nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
  172.                            }
  173.                        }
  174.  
  175.                        // Guardar archivo de texto con los nombres de los relés.
  176.                        File.WriteAllLines("NombresReles.txt", nombresDeLosReles);
  177.  
  178.                        // Puede que los nombres contengan espacios al final, que no se verán pero no
  179.                        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
  180.                        Console.Clear();
  181.                        Console.SetCursorPosition(2, 1);
  182.                        Console.Write("Haz guardado:");
  183.                        Console.SetCursorPosition(2, 3);
  184.                        Console.Write((indice + 1).ToString());
  185.                        Console.SetCursorPosition(4, 3);
  186.                        Console.Write(nombresDeLosReles[indice]);
  187.  
  188.                        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
  189.                        while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
  190.                        {
  191.                            // ¿Haz pulsado flecha arriba?
  192.                            if (tecla2 == ConsoleKey.UpArrow) // Sí. Ejecuta código dentro de ella.
  193.                            {
  194.                                indice--; // Decrementa la variable indice.
  195.                                // ¿indice es menor que 0?
  196.                                if (indice < 0) // Sí.
  197.                                {
  198.                                    indice = 7;
  199.                                }
  200.                            }
  201.                            // Entonces. ¿Haz pulsado flecha abajo?
  202.                            else if (tecla2 == ConsoleKey.DownArrow) // Sí.
  203.                            {
  204.                                indice++; // Incrementa la variable indice.
  205.                                // ¿indice es mayor o igual que 8?
  206.                                if (indice >= 8) // Sí.
  207.                                {
  208.                                    indice = 0;
  209.                                }
  210.                            }
  211.                            Console.SetCursorPosition(2, 3);
  212.                            Console.Write((indice + 1).ToString());
  213.                            Console.SetCursorPosition(4, 3);
  214.                            Console.Write(nombresDeLosReles[indice]);
  215.                        }
  216.                        Inicio();
  217.                    }
  218.                    else if (index == 0)
  219.                    {
  220.                        break;
  221.                    }
  222.                }
  223.            }
  224.        }
  225.  
  226.        static void Inicio()
  227.        {
  228.            Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
  229.            Console.Clear();                                // Limpiar ventana.
  230.            Console.SetCursorPosition(2, 0);                // Posición del cursor.
  231.            Console.Write("Nombre de Relés:    ");
  232.            Console.SetCursorPosition(0, 3);
  233.            Console.Write("  ATRÁS     GUARDAR ");
  234.  
  235.            if (cargado == false)
  236.            {
  237.                // ¿Existe el archivo de texto?
  238.                if (File.Exists("NombresReles.txt"))
  239.                {
  240.                    // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  241.                    nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  242.                    int a, b, c;
  243.                    for (a = 0; a < 8; a++)
  244.                    {
  245.                        for (b = 0; b < 16; b++)
  246.                        {
  247.                            for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
  248.                            {
  249.                                ;
  250.                            }
  251.                            roINDICE_ARRAY[a][b] = c;
  252.                        }
  253.                    }
  254.                }
  255.                cargado = true;
  256.            }
  257.            MostrarLineaNombre();
  258.            Console.SetCursorPosition(2, 1);
  259.            Console.Write(roNUMERICO[roINDICE_NUMERICO]);
  260.            if (textBox == 0)
  261.            {
  262.                Console.SetCursorPosition(2, 1);
  263.            }
  264.            else
  265.            {
  266.                Console.SetCursorPosition(4 + coordenadaX, 1);
  267.            }
  268.        }
  269.  
  270.        static void MostrarLineaNombre()
  271.        {
  272.            Console.SetCursorPosition(4, 1);
  273.            for (int a = 0; a < 16; a++)
  274.            {
  275.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
  276.            }
  277.        }
  278.    }
  279. }

Código C de Arduino:
Código
  1. // Variables.
  2. int coordenadaX = 0;          // Coordenada X del textBox del nombre del Relé.
  3. int index = 0;                // Índice de ATRÁS y GUARDAR.
  4. int textBox = 0;              // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
  5. String nombresDeLosReles[8]; // Líneas que al final se van a guardar en Archivo.txt.
  6. bool cargado = false;         // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.
  7.  
  8. // Caracteres alfanuméricos en el array.
  9. char roALFANUMERICO[] =
  10. {
  11.  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  12.  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  13.  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  14.  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  15.  '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  16.  ' '
  17. };
  18.  
  19. // Índices de los caracteres de los 8 Relés para el array alfanumérico.
  20. // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
  21. int roINDICE_ARRAY[][16] =
  22. {
  23.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  24.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  25.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  26.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  27.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  28.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  29.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  30.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
  31. };
  32.  
  33. char roNUMERICO[] = { '1', '2', '3', '4', '5', '6', '7', '8' };
  34. int roINDICE_NUMERICO = 0;
  35.  
  36. void NombreReles_Principal()
  37. {
  38.  ConsoleKey tecla, tecla2;
  39.  int indice = 0;
  40.  
  41.  Inicio();
  42.  
  43.  while (true)
  44.  {
  45.    lcd.cursor(); // Mostrar cursor.
  46.    lcd.blink();  // Cursosr parpadeando.
  47.    tecla = Console.ReadKey(true).Key;
  48.  
  49.    // ¿Has pulsado tecla flecha arriba?
  50.    if (tecla == digitalRead(A1)) // Sí.
  51.    {
  52.      if (textBox == 0)
  53.      {
  54.        lcd.setCursor(4, 1);
  55.        textBox = 1;
  56.      }
  57.      else // textBox == 1
  58.      {
  59.        if (coordenadaX < 15)
  60.        {
  61.          coordenadaX++;
  62.          lcd.setCursor(4 + coordenadaX, 1);
  63.        }
  64.      }
  65.    }
  66.    // Entonces. ¿Haz pulsado flecha izquierda?
  67.    else if (tecla == digitalRead(A3)) // Sí.
  68.    {
  69.      if (textBox == 1)
  70.      {
  71.        if (coordenadaX > 0)
  72.        {
  73.          coordenadaX--;
  74.          lcd.setCursor(4 + coordenadaX, 1);
  75.        }
  76.        else
  77.        {
  78.          lcd.setCursor(2, 1);
  79.          textBox = 0;
  80.        }
  81.      }
  82.    }
  83.    // Entonces. ¿Haz pulsado flecha abajo?
  84.    else if (tecla == digitalRead(A2)) // Sí.
  85.    {
  86.      if (textBox == 0)
  87.      {
  88.        roINDICE_NUMERICO--;
  89.        if (roINDICE_NUMERICO < 0)
  90.        {
  91.          roINDICE_NUMERICO = 7;
  92.        }
  93.        lcd.setCursor(2, 1);
  94.        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  95.        MostrarLineaNombre();
  96.        lcd.setCursor(2, 1);
  97.      }
  98.      else // textBox == 1
  99.      {
  100.        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
  101.        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
  102.        {
  103.          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
  104.        }
  105.        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  106.        lcd.setCursor(4 + coordenadaX, 1);
  107.      }
  108.    }
  109.    // Entonces. ¿Haz pulsado flecha arriba?
  110.    else if (tecla == digitalRead(A1)) // Sí.
  111.    {
  112.      if (textBox == 0)
  113.      {
  114.        roINDICE_NUMERICO++;
  115.        if (roINDICE_NUMERICO >= 8)
  116.        {
  117.          roINDICE_NUMERICO = 0;
  118.        }
  119.        lcd.setCursor(2, 1);
  120.        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  121.        MostrarLineaNombre();
  122.        lcd.setCursor(2, 1);
  123.      }
  124.      else // textBox == 1
  125.      {
  126.        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
  127.        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
  128.        { // total y al alcanzarla ahí paso al comienzo (0)
  129.          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
  130.        }
  131.        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
  132.        lcd.setCursor(4 + coordenadaX, 1);
  133.      }
  134.    }
  135.    // Entonces. ¿Haz pulsado la tecla Enter?
  136.    else if (tecla == digitalRead(A5)) // Sí.
  137.    {
  138.      lcd.cursor();   // Ocultar cursor.
  139.      lcd.noBlink();  // Sin parpadeos el cursor.
  140.      lcd.setCursor(0, 3);
  141.      lcd.print("> ATRÁS     GUARDAR ");
  142.      index = 0;
  143.      while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
  144.      {
  145.        if ((tecla2 == digitalRead(A4)) || (tecla2 == digitalRead(A3)))
  146.        {
  147.          index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
  148.          lcd.setCursor(0, 3);
  149.          if (index == 0)
  150.          {
  151.            lcd.print("> ATRÁS     GUARDAR ");
  152.          }
  153.          else
  154.          {
  155.            lcd.print("  ATRÁS   > GUARDAR ");
  156.          }
  157.        }
  158.      }
  159.      if (index == 1)  // Se pulsó Enter en Guardar.
  160.      {
  161.        nombresDeLosReles = new String[8];
  162.        for (int a = 0; a < 8; a++)
  163.        {
  164.          for (int b = 0; b < 16; b++)
  165.          {
  166.            nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
  167.          }
  168.        }
  169.  
  170.        // Guardar archivo de texto con los nombres de los relés.
  171.        //File.WriteAllLines("NombresReles.txt", nombresDeLosReles);
  172.  
  173.        // En esta parte, justo arriba se hace con el lenguaje de C#, aquí hay que usar la
  174.        // EEPROM interna de Arduino que haré más adelante.
  175.  
  176.        // Puede que los nombres contengan espacios al final, que no se verán pero no
  177.        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
  178.        lcd.clear();
  179.        lcd.setCursor(2, 1);
  180.        lcd.print("Haz guardado:");
  181.        lcd.setCursor(2, 3);
  182.        lcd.print((indice + 1).ToString());
  183.        lcd.setCursor(4, 3);
  184.        lcd.print(nombresDeLosReles[indice]);
  185.  
  186.        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
  187.        while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
  188.        {
  189.          // ¿Haz pulsado flecha arriba?
  190.          if (tecla2 == digitalRead(A1)) // Sí. Ejecuta código dentro de ella.
  191.          {
  192.            indice--; // Decrementa la variable indice.
  193.            // ¿indice es menor que 0?
  194.            if (indice < 0) // Sí.
  195.            {
  196.              indice = 7;
  197.            }
  198.          }
  199.          // Entonces. ¿Haz pulsado flecha abajo?
  200.          else if (tecla2 == digitalRead(A2)) // Sí.
  201.          {
  202.            indice++; // Incrementa la variable indice.
  203.            // ¿indice es mayor o igual que 8?
  204.            if (indice >= 8) // Sí.
  205.            {
  206.              indice = 0;
  207.            }
  208.          }
  209.          lcd.setCursor(2, 3);
  210.          lcd.print((indice + 1).ToString());
  211.          lcd.setCursor(4, 3);
  212.          lcd.print(nombresDeLosReles[indice]);
  213.        }
  214.        Inicio();
  215.      }
  216.      else if (index == 0)
  217.      {
  218.        break;
  219.      }
  220.    }
  221.  }
  222. }
  223.  
  224. void Inicio()
  225. {
  226.  //Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
  227.  lcd.clear();                                // Limpiar ventana.
  228.  lcd.setCursor(2, 0);                // Posición del cursor.
  229.  lcd.print("Nombre de Relés:    ");
  230.  lcd.setCursor(0, 3);
  231.  lcd.print("  ATRÁS     GUARDAR ");
  232.  
  233.  //#########################################################################################
  234.  // Este código es de C#, ya lo pasaré a Arduino con su EEPROM interna o una tarjeta SD
  235.  // que también se puede leer archivo de texto tipo *.txt.
  236.  
  237.  /*
  238.     if (cargado == false)
  239.     {
  240.       // ¿Existe el archivo de texto?
  241.       if (File.Exists("NombresReles.txt"))
  242.       {
  243.         // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  244.         nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  245.         int a, b, c;
  246.         for (a = 0; a < 8; a++)
  247.         {
  248.           for (b = 0; b < 16; b++)
  249.           {
  250.             for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
  251.             {
  252.               ;
  253.             }
  254.             roINDICE_ARRAY[a][b] = c;
  255.           }
  256.         }
  257.       }
  258.       cargado = true;
  259.     }
  260.   */
  261.  //#########################################################################################
  262.  
  263.  MostrarLineaNombre();
  264.  lcd.setCursor(2, 1);
  265.  lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  266.  if (textBox == 0)
  267.  {
  268.    lcd.setCursor(2, 1);
  269.  }
  270.  else
  271.  {
  272.    lcd.setCursor(4 + coordenadaX, 1);
  273.  }
  274. }
  275.  
  276. void MostrarLineaNombre()
  277. {
  278.  lcd.setCursor(4, 1);
  279.  for (int a = 0; a < 16; a++)
  280.  {
  281.    lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
  282.  }
  283. }

Falla en el almacenamiento o detección de botones de Arduino que no se como se hace como en C#.

Gracias.


« Última modificación: 20 Mayo 2022, 07:02 am por Meta » En línea

Meta


Desconectado Desconectado

Mensajes: 3.501



Ver Perfil WWW
Re: Adaptación de códigos
« Respuesta #1 en: 28 Mayo 2022, 09:25 am »

Buenas:

He adaptado el código a Arduino y compila.



Tratando con el lenguaje Arduino. Ejecuta bien. Tiene comportamientos no deseado. Si pulsas el Botón Enter, todo bien. Luego al seleccionar un menú e incluso antes, la flecha indicadora parpadea, como que hay un bucle y se refresca una y otra vez.

Si entras al submenú llamado > NOMBRE RELES, directamente se pone en > ATRÁS y sale del submenú y vuelve al menú principal.

Quiero averiguar o corregir este motivo.

Códigos en Arduino.

LCD_Menu_y_Submenu.ino:

Código
  1. // Include el código de la librería.
  2. #include <LiquidCrystal.h>
  3.  
  4. // Inicializa la librería con sus pines indicados.
  5. // RS, RW, Enable, D4, D5, D6, D7.
  6. //LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
  7. LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
  8.  
  9. // Declarar a partir de aquí el lcd.
  10. #include "MenuPrincipal.h"
  11.  
  12.  
  13. // Pin 10 para saber que es luz de fondo.
  14. //const byte LuzFondo = 10;
  15.  
  16. // Variables.
  17. // Declarado pulsadores.
  18. const byte ARRIBA PROGMEM = A1;
  19. const byte ABAJO PROGMEM = A2;
  20. const byte IZQUIERDA PROGMEM = A3;
  21. const byte DERECHA PROGMEM = A4;
  22. const byte ENTER PROGMEM = A5;
  23.  
  24. byte estadoBotonArriba = 0;
  25. byte estadoBotonAbajo = 0;
  26. byte estadoBotonIzquierda = 0;
  27. byte estadoBotonDerecha = 0;
  28. byte estadoBotonEnter = 0;
  29.  
  30. void setup()
  31. {
  32.  Serial.begin(115200); // 115200
  33.  
  34.  // La pantalla es de 20 caracteres y 4 filas.
  35.  lcd.begin(20, 4);
  36.  
  37.  // Indicar luz de fondo como salida.
  38.  // pinMode(LuzFondo, OUTPUT);
  39.  
  40.  // Configuración de pines como salidas digitales.
  41.  pinMode(13, OUTPUT);
  42.  
  43.  // Configuración de pines como entradas digitales.
  44.  pinMode(ARRIBA, INPUT); // Arriba. A1.
  45.  pinMode(ABAJO, INPUT); // Abajo. A2.
  46.  pinMode(IZQUIERDA, INPUT); // Izquierda. A3.
  47.  pinMode(DERECHA, INPUT); // Derecha. A4.
  48.  pinMode(ENTER, INPUT); // Ok / Enter. A5.
  49.  
  50.  lcd.clear();                          // Borra la pantalla y su posición superior izquierda.
  51.  lcd.setCursor(0, 1);                  // Línea 2 del LCD.
  52.  lcd.print(F(" Pantalla principal ")); // Muestra título en la LCD.
  53. }
  54.  
  55. void loop()
  56. {
  57.  estadoBotonEnter = digitalRead(ENTER);
  58.  if (estadoBotonEnter == HIGH)
  59.  {
  60.    lcd.noCursor(); // Oculat cursor.
  61.    lcd.noBlink();  // Cursor no parpadeando.
  62.    Menu_Principal();
  63.    Serial.println(estadoBotonEnter);
  64.  }
  65.  delay(50); // Para mayor estabilidad entre lecturas.
  66. }

MenuPrincipal.h:
Código
  1. #include "NombreReles.h"
  2.  
  3. void Menu_Principal()
  4. {
  5.  // Contador de teclas y navegador.
  6.  byte opcion = 0;
  7.  bool salir = false;
  8.  const byte seleccionMenu PROGMEM = 8;
  9.  
  10.  // Oculat cursor.
  11.  lcd.noCursor();
  12.  
  13.  // Cursor no parpadeando.
  14.  lcd.noBlink();
  15.  
  16.  // Limpiar pantalla.
  17.  lcd.clear();
  18.  
  19.  
  20.  do
  21.  {
  22.    //******************************************************************
  23.    // Dibujo el menú principal.
  24.    const String MENSAJES[] PROGMEM =
  25.    {
  26.      "** MENU PRINCIPAL **", // Posición 0.
  27.      "  ESTADO PRINCIPAL  ", // 1
  28.      "  NOMBRE RELES      ", // 2
  29.      "  NOMBRE SENSORES   ", // 3
  30.      "  ENTRADA ANALOGICA ", // 4
  31.      "  CONFIGURACION     ", // 5
  32.      "  ACERCA DE...      ", // 6
  33.      "  AYUDA             ", // 7
  34.      "  EXTRA             ", // 8
  35.      "  INICIO            ", // 9
  36.      "                    ", // 10
  37.      ">"                     // 11
  38.    };
  39.  
  40.    switch (opcion)
  41.    {
  42.      case 0:
  43.        lcd.setCursor(0, 0);     // Línea 1 del LCD.
  44.        lcd.print(MENSAJES[0]);  // ** MENÚ PRINCIPAL **
  45.        lcd.setCursor(0, 1);
  46.        lcd.print(MENSAJES[1]);  // > ESTADO PRINCIPAL
  47.        lcd.setCursor(0, 1);
  48.        lcd.print(MENSAJES[11]); // >
  49.        lcd.setCursor(0, 2);
  50.        lcd.print(MENSAJES[2]);  //   NOMBRE RELÉS
  51.        lcd.setCursor(0, 3);
  52.        lcd.print(MENSAJES[3]);  //   NOMBRE SENSORES
  53.        break;
  54.  
  55.      case 1:
  56.        lcd.setCursor(0, 0);
  57.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  58.        lcd.setCursor(0, 1);
  59.        lcd.print(MENSAJES[1]);         //   ESTADO PRINCIPAL
  60.        lcd.setCursor(0, 2);
  61.        lcd.print(MENSAJES[2]);         // > NOMBRE RELÉS
  62.        lcd.setCursor(0, 2);
  63.        lcd.print(MENSAJES[11]);        // >
  64.        lcd.setCursor(0, 3);
  65.        lcd.print(MENSAJES[3]);         //   NOMBRE SENSORES
  66.        break;
  67.  
  68.      case 2:
  69.        lcd.setCursor(0, 0);
  70.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  71.        lcd.setCursor(0, 1);
  72.        lcd.print(MENSAJES[1]);         //   ESTADO PRINCIPAL
  73.        lcd.setCursor(0, 2);
  74.        lcd.print(MENSAJES[2]);         //   NOMBRE RELÉS
  75.        lcd.setCursor(0, 3);
  76.        lcd.print(MENSAJES[3]);         // > NOMBRE SENSORES
  77.        lcd.setCursor(0, 3);
  78.        lcd.print(MENSAJES[11]);        // >
  79.        break;
  80.  
  81.      case 3:
  82.        lcd.setCursor(0, 0);
  83.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  84.        lcd.setCursor(0, 1);
  85.        lcd.print(MENSAJES[4]);         // > ENTRADA ANALÓGICA
  86.        lcd.setCursor(0, 1);
  87.        lcd.print(MENSAJES[11]);        // >
  88.        lcd.setCursor(0, 2);
  89.        lcd.print(MENSAJES[5]);         //   CONFIGURACIÓN
  90.        lcd.setCursor(0, 3);
  91.        lcd.print(MENSAJES[6]);         //   ACERCA DE...
  92.        break;
  93.  
  94.      case 4:
  95.        lcd.setCursor(0, 0);
  96.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  97.        lcd.setCursor(0, 1);
  98.        lcd.print(MENSAJES[4]);         //   ENTRADA ANALÓGICA
  99.        lcd.setCursor(0, 2);
  100.        lcd.print(MENSAJES[5]);         // > CONFIGURACIÓN
  101.        lcd.setCursor(0, 2);
  102.        lcd.print(MENSAJES[11]);        // >
  103.        lcd.setCursor(0, 3);
  104.        lcd.print(MENSAJES[6]);         //   ACERCA DE...
  105.        break;
  106.  
  107.      case 5:
  108.        lcd.setCursor(0, 0);
  109.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  110.        lcd.setCursor(0, 1);
  111.        lcd.print(MENSAJES[4]);         //   ENTRADA ANALÓGICA
  112.        lcd.setCursor(0, 2);
  113.        lcd.print(MENSAJES[5]);         //   CONFIGURACIÓN
  114.        lcd.setCursor(0, 3);
  115.        lcd.print(MENSAJES[6]);         // > ACERCA DE...
  116.        lcd.setCursor(0, 3);
  117.        lcd.print(MENSAJES[11]);        // >
  118.        break;
  119.  
  120.      case 6:
  121.        lcd.setCursor(0, 0);
  122.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  123.        lcd.setCursor(0, 1);
  124.        lcd.print(MENSAJES[7]);         // > AYUDA
  125.        lcd.setCursor(0, 1);
  126.        lcd.print(MENSAJES[11]);        // >
  127.        lcd.setCursor(0, 2);
  128.        lcd.print(MENSAJES[8]);         //   EXTRA
  129.        lcd.setCursor(0, 3);
  130.        lcd.print(MENSAJES[9]);         //   INICIO
  131.        break;
  132.  
  133.      case 7:
  134.        lcd.setCursor(0, 0);
  135.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  136.        lcd.setCursor(0, 1);
  137.        lcd.print(MENSAJES[7]);         //   AYUDA
  138.        lcd.setCursor(0, 2);
  139.        lcd.print(MENSAJES[8]);         // > EXTRA
  140.        lcd.setCursor(0, 2);
  141.        lcd.print(MENSAJES[11]);        // >
  142.        lcd.setCursor(0, 3);
  143.        lcd.print(MENSAJES[9]);         //   INICIO
  144.        break;
  145.  
  146.      case 8:
  147.        lcd.setCursor(0, 0);
  148.        lcd.print(MENSAJES[0]);         // ** MENÚ PRINCIPAL **
  149.        lcd.setCursor(0, 1);
  150.        lcd.print(MENSAJES[7]);         //   AYUDA
  151.        lcd.setCursor(0, 2);
  152.        lcd.print(MENSAJES[8]);         //   EXTRA
  153.        lcd.setCursor(0, 3);
  154.        lcd.print(MENSAJES[9]);         // > INICIO
  155.        lcd.setCursor(0, 3);
  156.        lcd.print(MENSAJES[11]);        // >
  157.        break;
  158.  
  159.      default:
  160.        Serial.print(F("Fuera de rango"));
  161.        break;
  162.    }
  163.    // Fin de pintar el menú principal.
  164.    //******************************************************************
  165.  
  166.    // Leer pulsador ingresada por el usuario.
  167.  
  168.    // Validar el tipo de pulsador.
  169.    if (digitalRead(A5) == HIGH)
  170.    {
  171.      switch (opcion)
  172.      {
  173.        case 0:
  174.          //
  175.          break;
  176.        case 1:
  177.          NombreReles_Principal();
  178.          break;
  179.        case 2:
  180.          //OpcionC();
  181.          break;
  182.        case 3:
  183.          //
  184.          break;
  185.        case 4:
  186.          //
  187.          break;
  188.        case 5:
  189.          //
  190.          break;
  191.        case 6:
  192.          //
  193.          break;
  194.        case 7:
  195.          //
  196.          break;
  197.        case 8:
  198.          return;
  199.          salir = true;
  200.          break;
  201.        default:
  202.          lcd.print(F("Fuera de rango.     "));
  203.          break;
  204.      }
  205.    }
  206.    delay(50);
  207.  
  208.    // Entonces si pulsas pulsador Abajo.
  209.    if (digitalRead(A2) == HIGH)
  210.    {
  211.      opcion++;
  212.    }
  213.    delay(50);
  214.  
  215.    // Entonces si pulsas pulsador Arriba.
  216.    if (digitalRead(A1) == HIGH)
  217.    {
  218.      opcion--;
  219.    }
  220.    delay(50);
  221.  
  222.    // Si está en la última opción, salta a la primera.
  223.    if (opcion > seleccionMenu)
  224.    {
  225.      opcion = 0;
  226.    }
  227.  
  228.    // Si está en la primera posición, salta a la última.
  229.    if (opcion < 0)
  230.    {
  231.      opcion = seleccionMenu;
  232.    }
  233.  
  234.    // Uso la tecla escape como salida.
  235.  } while (salir == false);
  236. }

[b]NombreReles.h:[/b]
Código
  1. // Variables.
  2. byte coordenadaX = 0;          // Coordenada X del textBox del nombre del Relé.
  3. byte index = 0;                // Índice de ATRAS y GUARDAR.
  4. byte textBox = 0;              // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
  5. String nombresDeLosReles[8];  // Líneas que al final se van a guardar en Archivo.txt.
  6. bool cargado = false;         // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.
  7.  
  8. // Caracteres alfanuméricos en el array.
  9. const char ALFANUMERICO[] PROGMEM =
  10. {
  11.  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
  12.  'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
  13.  'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y', 'z',
  14.  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';', '¿',
  15.  '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"', ' '
  16. };
  17.  
  18. // Índices de los caracteres de los 8 Relés para el array alfanumérico.
  19. // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
  20. byte indiceArray[][16] =
  21. {
  22.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  23.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  24.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  25.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  26.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  27.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  28.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  29.  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
  30. };
  31.  
  32. const char NUMERICO[] PROGMEM = { '1', '2', '3', '4', '5', '6', '7', '8' };
  33. byte indiceNumerico = 0;
  34.  
  35. void MostrarLineaNombre()
  36. {
  37.  lcd.setCursor(4, 1);
  38.  for (byte a = 0; a < 16; a++)
  39.  {
  40.    lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][a]]);
  41.  }
  42. }
  43.  
  44. void Inicio()
  45. {
  46.  lcd.clear();                        // Limpiar ventana.
  47.  lcd.setCursor(2, 0);                // Posición del cursor.
  48.  lcd.print(F("Nombre de Reles:    "));
  49.  lcd.setCursor(0, 3);
  50.  lcd.print(F("  ATRAS     GUARDAR "));
  51.  
  52.  //#########################################################################################
  53.  // Este código es de C#, ya lo pasaré a Arduino con su EEPROM interna o una tarjeta SD
  54.  // que también se puede leer archivo de texto tipo *.txt.
  55.  
  56.  /*
  57.     if (cargado == false)
  58.     {
  59.       // ¿Existe el archivo de texto?
  60.       if (File.Exists("NombresReles.txt"))
  61.       {
  62.         // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  63.         nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  64.         int a, b, c;
  65.         for (a = 0; a < 8; a++)
  66.         {
  67.           for (b = 0; b < 16; b++)
  68.           {
  69.             for (c = 0; nombresDeLosReles[a][b] != ALFANUMERICO[c]; c++)
  70.             {
  71.               ;
  72.             }
  73.             indiceArray[a][b] = c;
  74.           }
  75.         }
  76.       }
  77.       cargado = true;
  78.     }
  79.   */
  80.  
  81.  if (cargado == false)
  82.  {
  83.      // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
  84. //      nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
  85.      byte a, b, c;
  86.      for (a = 0; a < 8; a++)
  87.      {
  88.        for (b = 0; b < 16; b++)
  89.        {
  90.          for (c = 0; nombresDeLosReles[a][b] != ALFANUMERICO[c]; c++)
  91.          {
  92.            ;
  93.          }
  94.          indiceArray[a][b] = c;
  95.        }
  96.      }
  97.    cargado = true;
  98.  }
  99.  //#########################################################################################
  100.  
  101.  MostrarLineaNombre();
  102.  lcd.setCursor(2, 1);
  103.  lcd.print(NUMERICO[indiceNumerico]);
  104.  if (textBox == 0)
  105.  {
  106.    lcd.setCursor(2, 1);
  107.  }
  108.  else
  109.  {
  110.    lcd.setCursor(4 + coordenadaX, 1);
  111.  }
  112. }
  113.  
  114. void NombreReles_Principal()
  115. {
  116.  //  ConsoleKey tecla, tecla2;
  117.  byte indice = 0;
  118.  
  119.  Inicio();
  120.  
  121.  while (true)
  122.  {
  123.    lcd.cursor(); // Mostrar cursor.
  124.    lcd.blink();  // Cursosr parpadeando.
  125.    //tecla = Console.ReadKey(true).Key;
  126.  
  127.    // ¿Has pulsado tecla flecha arriba?
  128.    if (HIGH == digitalRead(A1)) // Sí.
  129.    {
  130.      if (textBox == 0)
  131.      {
  132.        lcd.setCursor(4, 1);
  133.        textBox = 1;
  134.      }
  135.      else // textBox == 1
  136.      {
  137.        if (coordenadaX < 15)
  138.        {
  139.          coordenadaX++;
  140.          lcd.setCursor(4 + coordenadaX, 1);
  141.        }
  142.      }
  143.    }
  144.    // Entonces. ¿Haz pulsado flecha izquierda?
  145.    else if (HIGH == digitalRead(A3)) // Sí.
  146.    {
  147.      if (textBox == 1)
  148.      {
  149.        if (coordenadaX > 0)
  150.        {
  151.          coordenadaX--;
  152.          lcd.setCursor(4 + coordenadaX, 1);
  153.        }
  154.        else
  155.        {
  156.          lcd.setCursor(2, 1);
  157.          textBox = 0;
  158.        }
  159.      }
  160.    }
  161.    // Entonces. ¿Haz pulsado flecha abajo?
  162.    else if (HIGH == digitalRead(A2)) // Sí.
  163.    {
  164.      if (textBox == 0)
  165.      {
  166.        indiceNumerico--;
  167.        if (indiceNumerico < 0)
  168.        {
  169.          indiceNumerico = 7;
  170.        }
  171.        lcd.setCursor(2, 1);
  172.        lcd.print(NUMERICO[indiceNumerico]);
  173.        MostrarLineaNombre();
  174.        lcd.setCursor(2, 1);
  175.      }
  176.      else // textBox == 1
  177.      {
  178.        indiceArray[indiceNumerico][coordenadaX]--;
  179.        if (indiceArray[indiceNumerico][coordenadaX] < 0)
  180.        {
  181.          indiceArray[indiceNumerico][coordenadaX] = 85;
  182.        }
  183.        lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][coordenadaX]]);
  184.        lcd.setCursor(4 + coordenadaX, 1);
  185.      }
  186.    }
  187.    // Entonces. ¿Haz pulsado flecha arriba?
  188.    else if (HIGH == digitalRead(A1)) // Sí.
  189.    {
  190.      if (textBox == 0)
  191.      {
  192.        indiceNumerico++;
  193.        if (indiceNumerico >= 8)
  194.        {
  195.          indiceNumerico = 0;
  196.        }
  197.        lcd.setCursor(2, 1);
  198.        lcd.print(NUMERICO[indiceNumerico]);
  199.        MostrarLineaNombre();
  200.        lcd.setCursor(2, 1);
  201.      }
  202.      else // textBox == 1
  203.      {
  204.        indiceArray[indiceNumerico][coordenadaX]++;
  205.        if (indiceArray[indiceNumerico][coordenadaX] > 85)  // Aquí es > 85 (o >= 86) porque 86 es la cantidad
  206.        { // total y al alcanzarla ahí paso al comienzo (0).
  207.          indiceArray[indiceNumerico][coordenadaX] = 0;
  208.        }
  209.        lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][coordenadaX]]);
  210.        lcd.setCursor(4 + coordenadaX, 1);
  211.      }
  212.    }
  213.    // Entonces. ¿Haz pulsado la tecla Enter?
  214.    else if (HIGH == digitalRead(A5)) // Sí.
  215.    {
  216.      lcd.cursor();   // Ocultar cursor.
  217.      lcd.noBlink();  // Sin parpadeos el cursor.
  218.      lcd.setCursor(0, 3);
  219.      lcd.print("> ATRAS     GUARDAR ");
  220.      index = 0;
  221.      while (digitalRead(A5))
  222.      {
  223.        if ((HIGH == digitalRead(A4)) || (HIGH == digitalRead(A3)))
  224.        {
  225.          index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
  226.          lcd.setCursor(0, 3);
  227.          if (index == 0)
  228.          {
  229.            lcd.print(F("> ATRAS     GUARDAR "));
  230.          }
  231.          else
  232.          {
  233.            lcd.print(F("  ATRAS   > GUARDAR "));
  234.          }
  235.        }
  236.      }
  237.      if (index == 1)  // Se pulsó Enter en Guardar.
  238.      {
  239.        nombresDeLosReles[8];
  240.        for (byte a = 0; a < 8; a++)
  241.        {
  242.          for (byte b = 0; b < 16; b++)
  243.          {
  244.            //            nombresDeLosReles[a] += ALFANUMERICO[indiceArray[a][b]];
  245.          }
  246.        }
  247.  
  248.        // Guardar archivo de texto con los nombres de los relés.
  249.        //File.WriteAllLines("NombresReles.txt", nombresDeLosReles);
  250.  
  251.        // En esta parte, justo arriba se hace con el lenguaje de C#, aquí hay que usar la
  252.        // EEPROM interna de Arduino que haré más adelante.
  253.  
  254.        // Puede que los nombres contengan espacios al final, que no se verán pero no
  255.        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
  256.        lcd.clear();
  257.        lcd.setCursor(2, 1);
  258.        lcd.print(F("Haz guardado:"));
  259.        lcd.setCursor(2, 3);
  260.        lcd.print((indice + 1));
  261.        lcd.setCursor(4, 3);
  262.        //lcd.print(nombresDeLosReles[indice]);
  263.  
  264.        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
  265.        while (HIGH == digitalRead(A5))
  266.        {
  267.          // ¿Haz pulsado flecha arriba?
  268.          if (HIGH == digitalRead(A1)) // Sí. Ejecuta código dentro de ella.
  269.          {
  270.            indice--; // Decrementa la variable indice.
  271.            // ¿indice es menor que 0?
  272.            if (indice < 0) // Sí.
  273.            {
  274.              indice = 7;
  275.            }
  276.          }
  277.          // Entonces. ¿Haz pulsado flecha abajo?
  278.          else if (HIGH == digitalRead(A2)) // Sí.
  279.          {
  280.            indice++; // Incrementa la variable indice.
  281.            // ¿indice es mayor o igual que 8?
  282.            if (indice >= 8) // Sí.
  283.            {
  284.              indice = 0;
  285.            }
  286.          }
  287.          lcd.setCursor(2, 3);
  288.          lcd.print((indice + 1));
  289.          lcd.setCursor(4, 3);
  290.          lcd.print(nombresDeLosReles[indice]);
  291.        }
  292.        Inicio();
  293.      }
  294.      else if (index == 0)
  295.      {
  296.        break;
  297.      }
  298.    }
  299.  }
  300. }

¿Alguna idea?

Saludos.


« Última modificación: 28 Mayo 2022, 15:45 pm por Meta » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines