Club Delphi  
    FTP   CCD     Buscar   Trucos   Trabajo   Foros

Retroceder   Foros Club Delphi > Otros entornos y lenguajes > ASM y Microcontroladores
Registrarse FAQ Miembros Calendario Guía de estilo Buscar Temas de Hoy Marcar Foros Como Leídos

Respuesta
 
Herramientas Buscar en Tema Desplegado
  #1  
Antiguo 20-05-2022
REHome REHome is offline
Miembro
 
Registrado: jul 2003
Ubicación: España
Posts: 454
Poder: 21
REHome Va por buen camino
Adaptar código a Arduino

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:
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:
Código:
// 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.
__________________
http://electronica-pic.blogspot.com....n-arduino.html Manuales de electrónica general, PIC y Arduino.
Responder Con Cita
  #2  
Antiguo 22-05-2022
tsk tsk is offline
Miembro
 
Registrado: dic 2017
Posts: 52
Poder: 7
tsk Va por buen camino
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?

Cita:
- 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.
Responder Con Cita
  #3  
Antiguo 27-05-2022
REHome REHome is offline
Miembro
 
Registrado: jul 2003
Ubicación: España
Posts: 454
Poder: 21
REHome Va por buen camino
Lo tendré en cuenta. Por ahora solo hice ahorrar RAM.

Código:
// 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;
      }
    }
  }
}
__________________
http://electronica-pic.blogspot.com....n-arduino.html Manuales de electrónica general, PIC y Arduino.
Responder Con Cita
Respuesta


Herramientas Buscar en Tema
Buscar en Tema:

Búsqueda Avanzada
Desplegado

Normas de Publicación
no Puedes crear nuevos temas
no Puedes responder a temas
no Puedes adjuntar archivos
no Puedes editar tus mensajes

El código vB está habilitado
Las caritas están habilitado
Código [IMG] está habilitado
Código HTML está deshabilitado
Saltar a Foro

Temas Similares
Tema Autor Foro Respuestas Último mensaje
Adaptar código a FMX Android wilcg FireMonkey 5 11-01-2018 19:11:42
Cargar Arduino UNO mediante Delphi 7 mariano22 ASM y Microcontroladores 7 20-07-2017 15:40:35
Delphi y Arduino REHome OOP 3 14-07-2017 15:14:42
Kit Arduino para Delphi K-ba ASM y Microcontroladores 9 25-03-2017 17:58:01
Comunicar Rad Studio XE8 con Arduino por Bluetooth shadowdark93 Desarrollo en Delphi para Android 2 10-04-2016 04:43:15


La franja horaria es GMT +2. Ahora son las 11:48:08.


Powered by vBulletin® Version 3.6.8
Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
Traducción al castellano por el equipo de moderadores del Club Delphi
Copyright 1996-2007 Club Delphi