Adaptar código a Arduino

[REHome]

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#:

using System;
using System.IO;

namespace LCD_Menu_con_submenus_Consola_01
{
    public class NombresReles
    {
        // Variables.
        static int coordenadaX = 0;         // Coordenada X del textBox del nombre del Relé.
        static int index = 0;               // Índice de ATRÁS y GUARDAR.
        static int textBox = 0;             // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
        static string[] nombresDeLosReles;  // Líneas que al final se van a guardar en Archivo.txt.
        static bool cargado = false;        // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.

        // Caracteres alfanuméricos en el array.
        static readonly char[] roALFANUMERICO = new char[]
        {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
            '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
            ' '
        };

        // Índices de los caracteres de los 8 Relés para el array alfanumérico.
        // Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
        static readonly int[][] roINDICE_ARRAY = new int[][]
        {
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
            new int[] { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
        };

        static readonly char[] roNUMERICO = new char[] { '1', '2', '3', '4', '5', '6', '7', '8' };
        static int roINDICE_NUMERICO = 0;

        public static void NombreReles_Principal()
        {
            ConsoleKey tecla, tecla2;
            int indice = 0;

            Inicio();

            while (true)
            {
                Console.CursorVisible = true; // Mostrar cursor.
                tecla = Console.ReadKey(true).Key;

                // ¿Has pulsado tecla flecha arriba?
                if (tecla == ConsoleKey.RightArrow) // Sí.
                {
                    if (textBox == 0)
                    {
                        Console.SetCursorPosition(4, 1);
                        textBox = 1;
                    }
                    else // textBox == 1
                    {
                        if (coordenadaX < 15)
                        {
                            coordenadaX++;
                            Console.SetCursorPosition(4 + coordenadaX, 1);
                        }
                    }
                }
                // Entonces. ¿Haz pulsado flecha izquierda?
                else if (tecla == ConsoleKey.LeftArrow) // Sí.
                {
                    if (textBox == 1)
                    {
                        if (coordenadaX > 0)
                        {
                            coordenadaX--;
                            Console.SetCursorPosition(4 + coordenadaX, 1);
                        }
                        else
                        {
                            Console.SetCursorPosition(2, 1);
                            textBox = 0;
                        }
                    }
                }
                // Entonces. ¿Haz pulsado flecha abajo?
                else if (tecla == ConsoleKey.DownArrow) // Sí.
                {
                    if (textBox == 0)
                    {
                        roINDICE_NUMERICO--;
                        if (roINDICE_NUMERICO < 0)
                        {
                            roINDICE_NUMERICO = 7;
                        }
                        Console.SetCursorPosition(2, 1);
                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
                        MostrarLineaNombre();
                        Console.SetCursorPosition(2, 1);
                    }
                    else // textBox == 1
                    {
                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
                        {
                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
                        Console.SetCursorPosition(4 + coordenadaX, 1);
                    }
                }
                // Entonces. ¿Haz pulsado flecha arriba?
                else if (tecla == ConsoleKey.UpArrow) // Sí.
                {
                    if (textBox == 0)
                    {
                        roINDICE_NUMERICO++;
                        if (roINDICE_NUMERICO >= 8)
                        {
                            roINDICE_NUMERICO = 0;
                        }
                        Console.SetCursorPosition(2, 1);
                        Console.Write(roNUMERICO[roINDICE_NUMERICO]);
                        MostrarLineaNombre();
                        Console.SetCursorPosition(2, 1);
                    }
                    else // textBox == 1
                    {
                        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
                        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
                        {                                                        // total y al alcanzarla ahí paso al comienzo (0)
                            roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
                        Console.SetCursorPosition(4 + coordenadaX, 1);
                    }
                }
                // Entonces. ¿Haz pulsado la tecla Enter?
                else if (tecla == ConsoleKey.Enter) // Sí.
                {
                    Console.CursorVisible = false;
                    Console.SetCursorPosition(0, 3);
                    Console.Write("> ATRÁS     GUARDAR ");
                    index = 0;
                    while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
                    {
                        if ((tecla2 == ConsoleKey.RightArrow) || (tecla2 == ConsoleKey.LeftArrow))
                        {
                            index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
                            Console.SetCursorPosition(0, 3);
                            if (index == 0)
                            {
                                Console.Write("> ATRÁS     GUARDAR ");
                            }
                            else
                            {
                                Console.Write("  ATRÁS   > GUARDAR ");
                            }
                        }
                    }
                    if (index == 1)  // Se pulsó Enter en Guardar. 
                    {
                        nombresDeLosReles = new string[8];
                        for (int a = 0; a < 8; a++)
                        {
                            for (int b = 0; b < 16; b++)
                            {
                                nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
                            }
                        }

                        // Guardar archivo de texto con los nombres de los relés.
                        File.WriteAllLines("NombresReles.txt", nombresDeLosReles);

                        // Puede que los nombres contengan espacios al final, que no se verán pero no
                        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
                        Console.Clear();
                        Console.SetCursorPosition(2, 1);
                        Console.Write("Haz guardado:");
                        Console.SetCursorPosition(2, 3);
                        Console.Write((indice + 1).ToString());
                        Console.SetCursorPosition(4, 3);
                        Console.Write(nombresDeLosReles[indice]);

                        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
                        while ((tecla2 = Console.ReadKey(true).Key) != ConsoleKey.Enter)
                        {
                            // ¿Haz pulsado flecha arriba?
                            if (tecla2 == ConsoleKey.UpArrow) // Sí. Ejecuta código dentro de ella.
                            {
                                indice--; // Decrementa la variable indice.
                                // ¿indice es menor que 0?
                                if (indice < 0) // Sí.
                                {
                                    indice = 7;
                                }
                            }
                            // Entonces. ¿Haz pulsado flecha abajo?
                            else if (tecla2 == ConsoleKey.DownArrow) // Sí.
                            {
                                indice++; // Incrementa la variable indice.
                                // ¿indice es mayor o igual que 8?
                                if (indice >= 8) // Sí.
                                {
                                    indice = 0;
                                }
                            }
                            Console.SetCursorPosition(2, 3);
                            Console.Write((indice + 1).ToString());
                            Console.SetCursorPosition(4, 3);
                            Console.Write(nombresDeLosReles[indice]);
                        }
                        Inicio();
                    }
                    else if (index == 0)
                    {
                        break;
                    }
                }
            }
        }

        static void Inicio()
        {
            Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
            Console.Clear();                                // Limpiar ventana.
            Console.SetCursorPosition(2, 0);                // Posición del cursor.
            Console.Write("Nombre de Relés:    ");
            Console.SetCursorPosition(0, 3);
            Console.Write("  ATRÁS     GUARDAR ");

            if (cargado == false)
            {
                // ¿Existe el archivo de texto?
                if (File.Exists("NombresReles.txt"))
                {
                    // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
                    nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
                    int a, b, c;
                    for (a = 0; a < 8; a++)
                    {
                        for (b = 0; b < 16; b++)
                        {
                            for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
                            {
                                ;
                            }
                            roINDICE_ARRAY[a][b] = c;
                        }
                    }
                }
                cargado = true;
            }
            MostrarLineaNombre();
            Console.SetCursorPosition(2, 1);
            Console.Write(roNUMERICO[roINDICE_NUMERICO]);
            if (textBox == 0)
            {
                Console.SetCursorPosition(2, 1);
            }
            else
            {
                Console.SetCursorPosition(4 + coordenadaX, 1);
            }
        }

        static void MostrarLineaNombre()
        {
            Console.SetCursorPosition(4, 1);
            for (int a = 0; a < 16; a++)
            {
                Console.Write(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
            }
        }
    }
}

Código C de Arduino:

// Variables.
int coordenadaX = 0;          // Coordenada X del textBox del nombre del Relé.
int index = 0;                // Índice de ATRÁS y GUARDAR.
int textBox = 0;              // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
String nombresDeLosReles[8];  // Líneas que al final se van a guardar en Archivo.txt.
bool cargado = false;         // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.

// Caracteres alfanuméricos en el array.
char roALFANUMERICO[] =
{
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  ' '
};

// Índices de los caracteres de los 8 Relés para el array alfanumérico.
// Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
int roINDICE_ARRAY[][16] =
{
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
};

char roNUMERICO[] = { '1', '2', '3', '4', '5', '6', '7', '8' };
int roINDICE_NUMERICO = 0;

void NombreReles_Principal()
{
  ConsoleKey tecla, tecla2;
  int indice = 0;

  Inicio();

  while (true)
  {
    lcd.cursor(); // Mostrar cursor.
    lcd.blink();  // Cursosr parpadeando.
    tecla = Console.ReadKey(true).Key;

    // ¿Has pulsado tecla flecha arriba?
    if (tecla == digitalRead(A1)) // Sí.
    {
      if (textBox == 0)
      {
        lcd.setCursor(4, 1);
        textBox = 1;
      }
      else // textBox == 1
      {
        if (coordenadaX < 15)
        {
          coordenadaX++;
          lcd.setCursor(4 + coordenadaX, 1);
        }
      }
    }
    // Entonces. ¿Haz pulsado flecha izquierda?
    else if (tecla == digitalRead(A3)) // Sí.
    {
      if (textBox == 1)
      {
        if (coordenadaX > 0)
        {
          coordenadaX--;
          lcd.setCursor(4 + coordenadaX, 1);
        }
        else
        {
          lcd.setCursor(2, 1);
          textBox = 0;
        }
      }
    }
    // Entonces. ¿Haz pulsado flecha abajo?
    else if (tecla == digitalRead(A2)) // Sí.
    {
      if (textBox == 0)
      {
        roINDICE_NUMERICO--;
        if (roINDICE_NUMERICO < 0)
        {
          roINDICE_NUMERICO = 7;
        }
        lcd.setCursor(2, 1);
        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
        MostrarLineaNombre();
        lcd.setCursor(2, 1);
      }
      else // textBox == 1
      {
        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]--;
        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] < 0)
        {
          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 85;
        }
        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
        lcd.setCursor(4 + coordenadaX, 1);
      }
    }
    // Entonces. ¿Haz pulsado flecha arriba?
    else if (tecla == digitalRead(A1)) // Sí.
    {
      if (textBox == 0)
      {
        roINDICE_NUMERICO++;
        if (roINDICE_NUMERICO >= 8)
        {
          roINDICE_NUMERICO = 0;
        }
        lcd.setCursor(2, 1);
        lcd.print(roNUMERICO[roINDICE_NUMERICO]);
        MostrarLineaNombre();
        lcd.setCursor(2, 1);
      }
      else // textBox == 1
      {
        roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]++;
        if (roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] > 85) // Acá es > 85 (o >= 86) porque 86 es la cantidad
        { // total y al alcanzarla ahí paso al comienzo (0)
          roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX] = 0;
        }
        lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][coordenadaX]].ToString());
        lcd.setCursor(4 + coordenadaX, 1);
      }
    }
    // Entonces. ¿Haz pulsado la tecla Enter?
    else if (tecla == digitalRead(A5)) // Sí.
    {
      lcd.cursor();   // Ocultar cursor.
      lcd.noBlink();  // Sin parpadeos el cursor.
      lcd.setCursor(0, 3);
      lcd.print("> ATRÁS     GUARDAR ");
      index = 0;
      while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
      {
        if ((tecla2 == digitalRead(A4)) || (tecla2 == digitalRead(A3)))
        {
          index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
          lcd.setCursor(0, 3);
          if (index == 0)
          {
            lcd.print("> ATRÁS     GUARDAR ");
          }
          else
          {
            lcd.print("  ATRÁS   > GUARDAR ");
          }
        }
      }
      if (index == 1)  // Se pulsó Enter en Guardar.
      {
        nombresDeLosReles = new String[8];
        for (int a = 0; a < 8; a++)
        {
          for (int b = 0; b < 16; b++)
          {
            nombresDeLosReles[a] += roALFANUMERICO[roINDICE_ARRAY[a][b]].ToString();
          }
        }

        // Guardar archivo de texto con los nombres de los relés.
        //File.WriteAllLines("NombresReles.txt", nombresDeLosReles);

        // En esta parte, justo arriba se hace con el lenguaje de C#, aquí hay que usar la
        // EEPROM interna de Arduino que haré más adelante.

        // Puede que los nombres contengan espacios al final, que no se verán pero no
        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
        lcd.clear();
        lcd.setCursor(2, 1);
        lcd.print("Haz guardado:");
        lcd.setCursor(2, 3);
        lcd.print((indice + 1).ToString());
        lcd.setCursor(4, 3);
        lcd.print(nombresDeLosReles[indice]);

        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
        while ((tecla2 = Console.ReadKey(true).Key) != digitalRead(A5))
        {
          // ¿Haz pulsado flecha arriba?
          if (tecla2 == digitalRead(A1)) // Sí. Ejecuta código dentro de ella.
          {
            indice--; // Decrementa la variable indice.
            // ¿indice es menor que 0?
            if (indice < 0) // Sí.
            {
              indice = 7;
            }
          }
          // Entonces. ¿Haz pulsado flecha abajo?
          else if (tecla2 == digitalRead(A2)) // Sí.
          {
            indice++; // Incrementa la variable indice.
            // ¿indice es mayor o igual que 8?
            if (indice >= 8) // Sí.
            {
              indice = 0;
            }
          }
          lcd.setCursor(2, 3);
          lcd.print((indice + 1).ToString());
          lcd.setCursor(4, 3);
          lcd.print(nombresDeLosReles[indice]);
        }
        Inicio();
      }
      else if (index == 0)
      {
        break;
      }
    }
  }
}

void Inicio()
{
  //Console.SetWindowSize(20, 5);                   // Establece el ancho y alto de la ventana.
  lcd.clear();                                // Limpiar ventana.
  lcd.setCursor(2, 0);                // Posición del cursor.
  lcd.print("Nombre de Relés:    ");
  lcd.setCursor(0, 3);
  lcd.print("  ATRÁS     GUARDAR ");

  //#########################################################################################
  // Este código es de C#, ya lo pasaré a Arduino con su EEPROM interna o una tarjeta SD
  // que también se puede leer archivo de texto tipo *.txt.

  /*
    if (cargado == false)
    {
      // ¿Existe el archivo de texto?
      if (File.Exists("NombresReles.txt"))
      {
        // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
        nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
        int a, b, c;
        for (a = 0; a < 8; a++)
        {
          for (b = 0; b < 16; b++)
          {
            for (c = 0; nombresDeLosReles[a][b] != roALFANUMERICO[c]; c++)
            {
              ;
            }
            roINDICE_ARRAY[a][b] = c;
          }
        }
      }
      cargado = true;
    }
  */
  //#########################################################################################

  MostrarLineaNombre();
  lcd.setCursor(2, 1);
  lcd.print(roNUMERICO[roINDICE_NUMERICO]);
  if (textBox == 0)
  {
    lcd.setCursor(2, 1);
  }
  else
  {
    lcd.setCursor(4 + coordenadaX, 1);
  }
}

void MostrarLineaNombre()
{
  lcd.setCursor(4, 1);
  for (int a = 0; a < 16; a++)
  {
    lcd.print(roALFANUMERICO[roINDICE_ARRAY[roINDICE_NUMERICO][a]]);
  }
}

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

Gracias.

[tsk]

Siento que te esas sobre complicando las cosas.

Si recuerdas la explicación que te dí en tu otro post con respecto a la separación de cada componentes del sistema.

Observa el ejemplo de los sensores. El mismo concepto puedes usar para manejar los pulsadores y el menú de una forma mas sencilla. Piensa también en máquinas de estado usando el mismo concepto o algo similar.

Del código que posteaste aquí

https://www.forosdeelectronica.com/t...6/post-1401932

Puedo ver que te estas complicando las cosas de forma innecesaria, además de ocasionar retrasos innecesarios o que se quede bloqueado en un sólo lugar en caso de que otras acciones deban ser ejecutadas al mismo tiempo. Además de que la forma en que lo tienes hecho es lo que te está causando problemas con las pulsaciones.


Por ejemplo, aunque no tengo el código porque mi Laptop falló, puedes ver el resultado de usar el mismo concepto que te mostré en ese post aplicado tanto en el manejo de los botones, sensores de temperatura, línea de comando, así como en el manejo del menú con tan solo 3 botones.



Fue algo que hice rápido en Febrero, porque mi hermano necesitaba controlar dos ventiladores. Y ¿que es lo que hace?

- La configuración es almacenada en la EEPROM al igual que su suma de verificación, así por si por alguna razón la configuración o la suma de verificación se corrompen, se procede a cargar unos valores por defecto.
- Una línea de comandos:
AT - Para saber si está en línea
AT+TEMP - Para obtener la lectura de la temperatura actual.
AT+CFG - Con ? retorna la configuración actual.
Con =X,Y, modifica la configuración del parámetro X=0,1,2,3,4 con el valor Y X de 0 a 3 cambia los valores de la temperatura, X=5 cambia el periodo de actualización en segundos.

AT+CFGSV - Guarda la configuración actual en la EEPROM
AT+CFGLD - Carga la configuración guardad en la EEPROM
AT+STA - Nos muestra el estado del sistema.

- Un Display OLED que nos muestra la temperatura actual y un menú en el cual modificar los parámetros del sistema.
- Controla la velocidad de dos ventiladores de PC de acuerdo a los rangos de temperatura definidos en la configuración del sistema.
- Si, por ejemplo, T0 lo coloco a 21 grados T1 no va a poder tomar un valor igual o menor a 21 grados, si T1 lo coloco a 25 grados, T0 no podrá tomar un valor igual o mayor a 25 grados y T2 no podrá tomar un valor menor o igual a 25 grados, y así sucesivamente.

De haberlo hecho por fuerza bruta hubiera terminado con un código casi ilegible, complicado y difícil de mantener, mientras que aplicando el concepto que te mostré, con lo de los sensores, el diseño y el código resultante termina siendo más fácil.

También puedes practicar usando C con GCC en lugar de con C#, así lo que pruebes lo vas a poder pasar casi integro a Arduino.

[REHome]

Lo tendré en cuenta. Por ahora solo hice ahorrar RAM.

// Variables.
byte coordenadaX = 0;          // Coordenada X del textBox del nombre del Relé.
byte index = 0;                // Índice de ATRAS y GUARDAR.
byte textBox = 0;              // 0 para el número de Relé (de 1 al 8) y 1 para el texto del Relé (16 char).
String nombresDeLosReles[8];  // Líneas que al final se van a guardar en Archivo.txt.
bool cargado = false;         // Vale false si todavía no se cargaron los nombres del Archivo, si no true, para no repetir.

// Caracteres alfanuméricos en el array.
const char ALFANUMERICO[] PROGMEM =
{
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', ',', '-', '_', ':', ';',
  '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\\', '/', '\"',
  ' '
};

// Índices de los caracteres de los 8 Relés para el array alfanumérico.
// Hay un total de 86 caracteres. Se cuenta desde el 0 al 85.
byte indiceArray[][16] =
{
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 },
  { 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85 }
};

const char NUMERICO[] PROGMEM = { '1', '2', '3', '4', '5', '6', '7', '8' };
byte indiceNumerico = 0;

void MostrarLineaNombre()
{
  lcd.setCursor(4, 1);
  for (byte a = 0; a < 16; a++)
  {
    lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][a]]);
  }
}

void Inicio()
{
  lcd.clear();                        // Limpiar ventana.
  lcd.setCursor(2, 0);                // Posición del cursor.
  lcd.print(F("Nombre de Reles:    "));
  lcd.setCursor(0, 3);
  lcd.print(F("  ATRAS     GUARDAR "));

  //#########################################################################################
  // Este código es de C#, ya lo pasaré a Arduino con su EEPROM interna o una tarjeta SD
  // que también se puede leer archivo de texto tipo *.txt.

  /*
    if (cargado == false)
    {
      // ¿Existe el archivo de texto?
      if (File.Exists("NombresReles.txt"))
      {
        // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
        nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
        int a, b, c;
        for (a = 0; a < 8; a++)
        {
          for (b = 0; b < 16; b++)
          {
            for (c = 0; nombresDeLosReles[a][b] != ALFANUMERICO[c]; c++)
            {
              ;
            }
            indiceArray[a][b] = c;
          }
        }
      }
      cargado = true;
    }
  */

  if (cargado == false)
  {
      // Supone un archivo con 8 lineas de 16 char completas aunque sea con espacios.
//      nombresDeLosReles = File.ReadAllLines("NombresReles.txt");
      byte a, b, c;
      for (a = 0; a < 8; a++)
      {
        for (b = 0; b < 16; b++)
        {
          for (c = 0; nombresDeLosReles[a][b] != ALFANUMERICO[c]; c++)
          {
            ;
          }
          indiceArray[a][b] = c;
        }
      }
    cargado = true;
  }
  //#########################################################################################

  MostrarLineaNombre();
  lcd.setCursor(2, 1);
  lcd.print(NUMERICO[indiceNumerico]);
  if (textBox == 0)
  {
    lcd.setCursor(2, 1);
  }
  else
  {
    lcd.setCursor(4 + coordenadaX, 1);
  }
}

void NombreReles_Principal()
{
  //  ConsoleKey tecla, tecla2;
  byte indice = 0;

  Inicio();

  while (true)
  {
    lcd.cursor(); // Mostrar cursor.
    lcd.blink();  // Cursosr parpadeando.
    //tecla = Console.ReadKey(true).Key;

    // ¿Has pulsado tecla flecha arriba?
    if (HIGH == digitalRead(A1)) // Sí.
    {
      if (textBox == 0)
      {
        lcd.setCursor(4, 1);
        textBox = 1;
      }
      else // textBox == 1
      {
        if (coordenadaX < 15)
        {
          coordenadaX++;
          lcd.setCursor(4 + coordenadaX, 1);
        }
      }
    }
    // Entonces. ¿Haz pulsado flecha izquierda?
    else if (HIGH == digitalRead(A3)) // Sí.
    {
      if (textBox == 1)
      {
        if (coordenadaX > 0)
        {
          coordenadaX--;
          lcd.setCursor(4 + coordenadaX, 1);
        }
        else
        {
          lcd.setCursor(2, 1);
          textBox = 0;
        }
      }
    }
    // Entonces. ¿Haz pulsado flecha abajo?
    else if (HIGH == digitalRead(A2)) // Sí.
    {
      if (textBox == 0)
      {
        indiceNumerico--;
        if (indiceNumerico < 0)
        {
          indiceNumerico = 7;
        }
        lcd.setCursor(2, 1);
        lcd.print(NUMERICO[indiceNumerico]);
        MostrarLineaNombre();
        lcd.setCursor(2, 1);
      }
      else // textBox == 1
      {
        indiceArray[indiceNumerico][coordenadaX]--;
        if (indiceArray[indiceNumerico][coordenadaX] < 0)
        {
          indiceArray[indiceNumerico][coordenadaX] = 85;
        }
        lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][coordenadaX]]);
        lcd.setCursor(4 + coordenadaX, 1);
      }
    }
    // Entonces. ¿Haz pulsado flecha arriba?
    else if (HIGH == digitalRead(A1)) // Sí.
    {
      if (textBox == 0)
      {
        indiceNumerico++;
        if (indiceNumerico >= 8)
        {
          indiceNumerico = 0;
        }
        lcd.setCursor(2, 1);
        lcd.print(NUMERICO[indiceNumerico]);
        MostrarLineaNombre();
        lcd.setCursor(2, 1);
      }
      else // textBox == 1
      {
        indiceArray[indiceNumerico][coordenadaX]++;
        if (indiceArray[indiceNumerico][coordenadaX] > 85)  // Aquí es > 85 (o >= 86) porque 86 es la cantidad
        { // total y al alcanzarla ahí paso al comienzo (0).
          indiceArray[indiceNumerico][coordenadaX] = 0;
        }
        lcd.print(ALFANUMERICO[indiceArray[indiceNumerico][coordenadaX]]);
        lcd.setCursor(4 + coordenadaX, 1);
      }
    }
    // Entonces. ¿Haz pulsado la tecla Enter?
    else if (HIGH == digitalRead(A5)) // Sí.
    {
      lcd.cursor();   // Ocultar cursor.
      lcd.noBlink();  // Sin parpadeos el cursor.
      lcd.setCursor(0, 3);
      lcd.print("> ATRAS     GUARDAR ");
      index = 0;
      while (digitalRead(A5))
      {
        if ((HIGH == digitalRead(A4)) || (HIGH == digitalRead(A3)))
        {
          index = 1 - index;  // Si vale 0 valdrá 1, si vale 1 valdrá 0.
          lcd.setCursor(0, 3);
          if (index == 0)
          {
            lcd.print(F("> ATRAS     GUARDAR "));
          }
          else
          {
            lcd.print(F("  ATRAS   > GUARDAR "));
          }
        }
      }
      if (index == 1)  // Se pulsó Enter en Guardar.
      {
        nombresDeLosReles[8];
        for (byte a = 0; a < 8; a++)
        {
          for (byte b = 0; b < 16; b++)
          {
            //            nombresDeLosReles[a] += ALFANUMERICO[indiceArray[a][b]];
          }
        }

        // Guardar archivo de texto con los nombres de los relés.
        //File.WriteAllLines("NombresReles.txt", nombresDeLosReles);

        // En esta parte, justo arriba se hace con el lenguaje de C#, aquí hay que usar la
        // EEPROM interna de Arduino que haré más adelante.

        // Puede que los nombres contengan espacios al final, que no se verán pero no
        // hay que borrarlos porque al principio leerá 16 char y si faltan, fallará.
        lcd.clear();
        lcd.setCursor(2, 1);
        lcd.print(F("Haz guardado:"));
        lcd.setCursor(2, 3);
        lcd.print((indice + 1));
        lcd.setCursor(4, 3);
        //lcd.print(nombresDeLosReles[indice]);

        // Mientras no pulses la tecla Enter, sigue las demás intrucciones.
        while (HIGH == digitalRead(A5))
        {
          // ¿Haz pulsado flecha arriba?
          if (HIGH == digitalRead(A1)) // Sí. Ejecuta código dentro de ella.
          {
            indice--; // Decrementa la variable indice.
            // ¿indice es menor que 0?
            if (indice < 0) // Sí.
            {
              indice = 7;
            }
          }
          // Entonces. ¿Haz pulsado flecha abajo?
          else if (HIGH == digitalRead(A2)) // Sí.
          {
            indice++; // Incrementa la variable indice.
            // ¿indice es mayor o igual que 8?
            if (indice >= 8) // Sí.
            {
              indice = 0;
            }
          }
          lcd.setCursor(2, 3);
          lcd.print((indice + 1));
          lcd.setCursor(4, 3);
          lcd.print(nombresDeLosReles[indice]);
        }
        Inicio();
      }
      else if (index == 0)
      {
        break;
      }
    }
  }
}