TODOPIC

Microcontroladores PIC => * PROYECTOS * => Mensaje iniciado por: Abner_emanuel en 07 de Junio de 2022, 18:54:55

Título: Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 07 de Junio de 2022, 18:54:55
Hola, les comento lo que pretendo con un código en ccs c y no e conseguido realizar.

Lo que pretendo hacer es que a partir del abecedario en un arreglo recorrerlo (con un pulsador1), con otro pulsador2 seleccionar la letra deseada y estarla guardando en la eeprom, asi sucesivamente hasta formar una palabra de no máximo 10 letras. Esta palabra formada deberá guardarse en la eeprom y mostrarse al presionar un tercer pulsador3.

Tengo algo de codigo..

Código: C#
  1. char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};  
  2.          char x=-1;
  3.          
  4.          void main(void)
  5.          {
  6.          lcd_init();
  7.          
  8.          while (true)
  9.          {
  10.          if(!input(pin_A0))                                                            // ESCRIBE ABECEDARIO
  11.          {
  12.          x++; if(x >= 27){ x = 0; }; while(!input(pin_A0)); {}  
  13.          lcd_gotoxy(1,2); printf(lcd_putc," %c ",abecedario[x]);        
  14.                    
  15.          }
  16.          
  17.          if(!input(pin_A1))                                                            // GRABA
  18.          {  
  19.          printf(lcd_putc,"\f" ) ;
  20.          lcd_gotoxy(6,1); printf(lcd_putc,"Grabado");
  21.          
  22.          }; while(!input(pin_A1)); {}
  23.          
  24.          
  25.          if(!input(pin_A2))                                                            // LEE LO GRABADO
  26.          {
  27.          printf(lcd_putc,"\f") ;
  28.        
  29.      
  30.          lcd_gotoxy(2,1); printf(lcd_putc,"valor guardado");      
  31.          
  32.          }; while(!input(pin_A2)); {}
  33.          }  
  34.          }

Alguien me ayuda con algún consejo o avance?..
Gracias...
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Robert76 en 08 de Junio de 2022, 07:34:29
Hola, de igual manera como creaste un array que contiene el abecedario.
Deberás crear un array de diez elementos, que contenga  cada letra seleccionada.
Luego mediante un barrido por ese array, vas almacenando caracter por caracter en la EEPROM, hasta completar los diez elementos.
Recuerda que la EEPROM contiene un tamaño de palabra de 8bits.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: DominusDRR en 08 de Junio de 2022, 10:47:08
Cita de: Abner_emanuel en 07 de Junio de 2022, 18:54:55
Hola, les comento lo que pretendo con un código en ccs c y no e conseguido realizar.

Lo que pretendo hacer es que a partir del abecedario en un arreglo recorrerlo (con un pulsador1), con otro pulsador2 seleccionar la letra deseada y estarla guardando en la eeprom, asi sucesivamente hasta formar una palabra de no máximo 10 letras. Esta palabra formada deberá guardarse en la eeprom y mostrarse al presionar un tercer pulsador3.

Tengo algo de codigo..

Código: C#
  1. char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};  
  2.          char x=-1;
  3.          
  4.          void main(void)
  5.          {
  6.          lcd_init();
  7.          
  8.          while (true)
  9.          {
  10.          if(!input(pin_A0))                                                            // ESCRIBE ABECEDARIO
  11.          {
  12.          x++; if(x >= 27){ x = 0; }; while(!input(pin_A0)); {}  
  13.          lcd_gotoxy(1,2); printf(lcd_putc," %c ",abecedario[x]);        
  14.                    
  15.          }
  16.          
  17.          if(!input(pin_A1))                                                            // GRABA
  18.          {  
  19.          printf(lcd_putc,"\f" ) ;
  20.          lcd_gotoxy(6,1); printf(lcd_putc,"Grabado");
  21.          
  22.          }; while(!input(pin_A1)); {}
  23.          
  24.          
  25.          if(!input(pin_A2))                                                            // LEE LO GRABADO
  26.          {
  27.          printf(lcd_putc,"\f") ;
  28.        
  29.      
  30.          lcd_gotoxy(2,1); printf(lcd_putc,"valor guardado");      
  31.          
  32.          }; while(!input(pin_A2)); {}
  33.          }  
  34.          }

Alguien me ayuda con algún consejo o avance?..
Gracias...

Suponiendo que no tienes problemas con los rebotes de los pulsadores y/o los has eliminado de alguna manera, yo creo que lo haría así: (Imagen adjunta. Por alguna razón no me deja copiar y pegar el código como texto)


Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 08 de Junio de 2022, 20:40:38
Creo que no se como se guarda y se escribe sobre la eeprom lo que cometas.

Intente de la siguiente manera pero no me resulto..

Código: C#
  1. char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
  2.          char x=0;
  3.          char y=0;
  4.          char i;
  5.                  
  6.          void main(void)
  7.          {
  8.  
  9.          lcd_init();
  10.          
  11.          read_eeprom(0); delay_ms(200);              // Para leer la Eeprom
  12.          
  13.          while (true)
  14.          {
  15.  
  16.          if(!input(pin_A0))                                       // Pulsador para seleccionar la tecla
  17.          {
  18.          lcd_gotoxy(1,2); printf(lcd_putc," %c ",abecedario[x]);
  19.          x++;
  20.          if(x >= 26)
  21.          {
  22.          x = 0;
  23.          }
  24.          while(!input(pin_A0));
  25.          }
  26.  
  27.  
  28.  
  29.          if(!input(pin_A1))                              // Pulsador paraalmacenar las techas elegidas                                    
  30.          {
  31.          if(y<10)
  32.          {
  33.         // FuncionParaGrabarUnCharEnEprom(abecedario[y]);
  34.        
  35.          [b]write_eeprom(0, abecedario[y]);[/b]                // Para escricir la Eeprom
  36.  
  37.          y++;
  38.          printf(lcd_putc,"\f");
  39.          lcd_gotoxy(6,1); printf(lcd_putc," Grabando ");
  40.          }
  41.          else
  42.          {
  43.          lcd_gotoxy(6,1); printf(lcd_putc," Maximo 10 Letras ");
  44.          }
  45.          }; while(!input(pin_A1));
  46.  
  47.  
  48.  
  49.          if(!input(pin_A2))                              // Pulsador paraalmacenar las techas elegidas                                    
  50.          {
  51.          // char i;
  52.          for(i=0; i < y; i++)
  53.          {
  54.          //lcd_gotoxy(i,2); printf(lcd_putc," %c ",FuncinParaLeerUnCharDesdeEeprom);
  55.          
  56.          [b]abecedario[i] = read_eeprom(0);  [/b]            // Para leer la Eeprom
  57.  
  58.          lcd_gotoxy(i,2); printf(lcd_putc," %c ",abecedario[i]);
  59.          }
  60.          printf(lcd_putc,"\f");
  61.          lcd_gotoxy(2,1); printf(lcd_putc," Valor Guardado ");
  62.          }; while(!input(pin_A2)); {}
  63.          }
  64.          }

No me resulta bien, AYUUDAAAA. Please...
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 12 de Junio de 2022, 02:36:35
Aquí aferrado e intentado, Ahora por otra camino un poquito diferente jeje. Creo que ahora solo falta leer lo que se a grabado en la Eeprom. E logrado escribir pero como lo leo lo grabado en nombreEstacion ????

Código: C++
  1. signed char letra = 0;
  2.          char contador = 0;
  3.          const char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
  4.          char nombreEstacion[],leerEEPROM[];
  5.  
  6.          
  7.          void main(void)
  8.          {
  9.          lcd_init();
  10.  
  11.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",abecedario[letra]);
  12.          
  13.          while (true)
  14.          {        
  15.          
  16.          if(!input(pin_a0))                                                      // Aumenta Letra
  17.          {
  18.          letra++;
  19.          if(letra > 25) letra=0;  
  20.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",abecedario[letra]);
  21.          delay_ms(400);
  22.          }
  23.          
  24.          else if(!input(pin_a1))                                                 // Disminuye Letra
  25.          {
  26.          letra--;
  27.          if(letra < 0) letra=25;  
  28.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c ",abecedario[letra]);
  29.          delay_ms(400);
  30.          }
  31.          
  32.          else if(!input(pin_a2))                                                 // Graba letra en Eeprom
  33.          {
  34.          nombreEstacion = abecedario[letra];
  35.          write_eeprom(0 + contador, nombreEstacion);
  36.          contador++;
  37.          lcd_gotoxy(contador,3); printf(lcd_putc,"%c",nombreEstacion);
  38.          delay_ms(400);
  39.          }
  40.          
  41.          else if(!input(pin_a3))                                                 // Leer letra de Eeprom ??????????????
  42.          {
  43.          leerEEPROM = read_eeprom(nombreEstacion);
  44.          lcd_gotoxy(1,4); printf(lcd_putc,"%c",leerEEPROM );
  45.          delay_ms(1000);
  46.          }        
  47.          }
  48.          }
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Robert76 en 12 de Junio de 2022, 10:23:54
Pues para leer usa los mismos pasos que con la acción de guardar.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Ruco en 12 de Junio de 2022, 11:47:03
Pusiera se como string
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 12 de Junio de 2022, 11:50:23
Robert76

Intente los mismos pasos para leer la Eeprom pero no me resultó. No imprime sobre la LCD.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Robert76 en 13 de Junio de 2022, 23:16:07
Bueno, puede que estés leyendo bien la EEPROM, pero estás implementando mal la impresión al LCD.
La verdad no me he puesto a ver tu programa, pero la estructura básica sería.
Alojar cada caracter en un byte de memoria RAM.
Luego mediante un bucle definido que cuente diez elementos, los guardas de a uno en la EEPROM. No olvidar esperar 20ms entre escrituras, salvo que la librería que estás usando tenga eso contemplado.
Luego para leer,.el proceso es inverso, lees cada posición de memoria EEPROM  y alojas cada byte en un buffer o array de 10 elementos.
Luego lees el array de a uno y lo imprimes en pantalla.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 14 de Junio de 2022, 01:03:02
Robert76

La secuencia creo que me a quedado clara. Lo que no me a resultado es ponerlo en código. Me falta mucho por aprender de código c.   :-)
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 17 de Junio de 2022, 10:01:19
Ya lo escribe, ya lo guarda en eeprom  creo   :lol: ahora lo único es que lo imprime carácter a carácter y no como string.


Código: C#
  1. else if(!input(pin_a2))                                                 // Graba letra en Eeprom
  2.  59
  3.  
  4.          {
  5.  60
  6.  
  7.          write_eeprom(0 + contador, abecedario[letra]);
  8.  61
  9.  
  10.          contador++;
  11.  62
  12.  
  13.          lcd_gotoxy(contador,3); printf(lcd_putc,"%c",abecedario[letra]);
  14.  63
  15.  
  16.          delay_ms(400);
  17.  64
  18.  
  19.          }
  20.  65
  21.  
  22.          
  23.  66
  24.  
  25.          else if(!input(pin_a3))                                                 // Leer letra de Eepro ??????????????
  26.  67
  27.  
  28.          {
  29.  68
  30.  
  31.          for(contador=0; contador < 4; contador++){
  32.  69
  33.  
  34.          nombreEstacion = read_eeprom(contador);
  35.  70
  36.  
  37.          lcd_gotoxy(contador,4); printf(lcd_putc," %c", nombreEstacion);
  38.  71
  39.  
  40.          delay_ms(1000);
  41.  72
  42.  
  43.          }        
  44.  73
  45.  
  46.          }
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Eduardo2 en 17 de Junio de 2022, 13:08:32
Para imprimir un string debe ser:
Código: [Seleccionar]
   printf(lcd_putc,"%s",abecedario);

Pero ojo, no estoy seguro que definiendo
Código: [Seleccionar]
char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};   siempre te vaya a guardar un 0 en la posición [26],  fundamental para saber que termina el string.
Mejor definila como:
Código: [Seleccionar]
char abecedario[] = {"abcdefghijklmnopqrstuvwxyz"};que de paso es mas breve.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: DominusDRR en 17 de Junio de 2022, 13:19:50
Cita de: Eduardo2 en 17 de Junio de 2022, 13:08:32
Para imprimir un string debe ser:
Código: [Seleccionar]
   printf(lcd_putc,"%s",abecedario);

Pero ojo, no estoy seguro que definiendo
Código: [Seleccionar]
char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};   

Lo que le falta ahí es un cero o final de carácter para que el printf sepa hasta donde imprimir el texto. (Imagen adjunta)

Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 17 de Junio de 2022, 13:36:08
Según un tema de este mismo foro dice así.

Código: C
  1. char arreglo[5];
  2.  
  3. se tendrá un arreglo de 5 elementos de tipo char. El contenido de cada char es aleatorio al arrancar el pic y usando el compilador de CCS para el ejemplo anterior. Se deberá inicializar el valor de cada elemento según el uso que se le vaya a dar.
  4.  
  5. Para convertir el arreglo de chars anterior en una cadena formal, el arreglo deberá contar con lo siguiente:
  6.  
  7. - Debe tener de 0 a 4 elementos (caracteres ascii) en las primeras 4 posiciones
  8. - El último elemento deberá ser un NULL char que equivale a 0x00
  9.  
  10. El elemento NULL marca el fin de los caracteres útiles de la cadena. Armemos una cadena sencilla con las características que se mencionaron:
  11.  
  12. arreglo[0]='c';
  13. arreglo[1]='a';
  14. arreglo[2]='s';
  15. arreglo[3]='a';
  16. arreglo[4]=0x00;
  17.  
  18. La cadena claramente contiene 'casa'. El quinto elemento dice: 'aquí terminó el texto'.
  19.  
  20. Al usar la declaración char arreglo[5]; en realidad se está declarando un apuntador a una secuencia de chars. El apuntador se llamará arreglo y será capaz de conocer la dirección ram de un char.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: DominusDRR en 17 de Junio de 2022, 13:46:30
Cita de: Abner_emanuel en 17 de Junio de 2022, 13:36:08
Según un tema de este mismo foro dice así.

Código: C
  1. char arreglo[5];
  2.  
  3. se tendrá un arreglo de 5 elementos de tipo char. El contenido de cada char es aleatorio al arrancar el pic y usando el compilador de CCS para el ejemplo anterior. Se deberá inicializar el valor de cada elemento según el uso que se le vaya a dar.
  4.  
  5. Para convertir el arreglo de chars anterior en una cadena formal, el arreglo deberá contar con lo siguiente:
  6.  
  7. - Debe tener de 0 a 4 elementos (caracteres ascii) en las primeras 4 posiciones
  8. - El último elemento deberá ser un NULL char que equivale a 0x00
  9.  
  10. El elemento NULL marca el fin de los caracteres útiles de la cadena. Armemos una cadena sencilla con las características que se mencionaron:
  11.  
  12. arreglo[0]='c';
  13. arreglo[1]='a';
  14. arreglo[2]='s';
  15. arreglo[3]='a';
  16. arreglo[4]=0x00;
  17.  
  18. La cadena claramente contiene 'casa'. El quinto elemento dice: 'aquí terminó el texto'.
  19.  
  20. Al usar la declaración char arreglo[5]; en realidad se está declarando un apuntador a una secuencia de chars. El apuntador se llamará arreglo y será capaz de conocer la dirección ram de un char.

Si es lo mismo que puse en la imagen de arriba, es decir debe ser así tu arreglo:

Código: C
  1. char abecedario[27] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z', 0x00};
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 17 de Junio de 2022, 14:05:52
Gracias Eduardo2.

Voy a intentar así..
Código: C++
  1. char abecedario[] = {"abcdefghijklmnopqrstuvwxyz"};

Sin las comillas.

Y probar el string al imprimir.

DominusDRR

Gracias me abrió un mejor panorama tu ayuda. La idea sigue siendo teclear 5 nombres guardar, leer en eeprom e imprimirlo imprimirlo la lcd.

Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: DominusDRR en 17 de Junio de 2022, 14:21:31
Cita de: Abner_emanuel en 17 de Junio de 2022, 14:05:52
Gracias Eduardo2.

Voy a intentar así..
Código: C++
  1. char abecedario[] = {"abcdefghijklmnopqrstuvwxyz"};

Sin las comillas.

Y probar el string al imprimir.

DominusDRR

Gracias me abrió un mejor panorama tu ayuda. La idea sigue siendo teclear 5 nombres guardar, leer en eeprom e imprimirlo imprimirlo la lcd.

Como quieras, al final es lo mismo (Imagen adjunta)

Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: KILLERJC en 18 de Junio de 2022, 15:52:48
Hay algunas cosas que se podrian hacer de otra forma...

1- Tener un array "abecedario", se podria quitar directamente...

Las letras minúsculas en su codificación ASCII son todos números que comienza en el 97 (0x61) y va hasta el 122 (0x7A), entonces en ves de hacer:

Código: C
  1. if(!input(pin_a0))                                                      // Aumenta Letra
  2.          {
  3.          letra++;
  4.          if(letra > 25) letra=0;  
  5.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",abecedario[letra]);
  6.          delay_ms(400);
  7.          }

Podemos hacer:

Código: C
  1. if(!input(pin_a0))                                                      // Aumenta Letra
  2.          {
  3.          letra++;
  4.          if(letra > 122) letra=97;  
  5.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",letra);
  6.          delay_ms(400);
  7.          }

Y eliminamos una variable....

2- Una cosa que leo es sobre estar pensando en el caracter nulo de "abecedario"... ¿Para que?

Lo que debería estar corroborando es el carácter nulo de otro array que sea "temporal"
La idea es que vaya llenando este array temporal..
Este array serviría para mostrarlo, algo mucho mas rápido que hacerlo tomando todos los datos de la eeprom.
En caso de grabarlo, solo se grabaría una sola vez todo junto y no carácter por carácter. Previo al grabado se pone un carácter nulo al final y llama a la función.
En la lectura, simplemente se lee hasta el carácter nulo en la EEPROM. Y la función de lectura debería poner el carácter nulo como seguridad.

Crear un par de funciones para esto (sin punteros, y considerando globales las variables para que sea mas sencillo para el usuario):

Código: C
  1. char temp_pass[11]; // Supongo que son 10 caracteres máximo
  2.  
  3. void escribirPass(cantidad){
  4.    int8 contador = 0;
  5.    while(temp_pass[contador])
  6.      write_eeprom(contador++, temp_pass[contador]);
  7.    write_eeprom(contador, '\0');
  8. }
  9.  
  10. void leerPass(){
  11.    int8 contador = 0;
  12.    do{
  13.       temp_pass[contador] = read_eeprom(contador);
  14.       if(contador >= sizeof temp_pass) contador++; break;
  15.    while(temp_pass[++contador]);
  16.    temp_pass[contador] = '\0';
  17.  
  18. }
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 18 de Junio de 2022, 18:51:09
SR. KILLERJC

Así puse la variable letra:

Código: C++
  1. char letra =+ 96;

Como bien dice, eliminamos el arreglo de caracteres  ((:-))

Y lo demás, así como lo comenta para aumentar letras y disminuir:

Código: C++
  1. void main(void)
  2.          {
  3.          lcd_init();
  4.          letra=97;
  5.          
  6.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",letra);
  7.          
  8.          while (true)
  9.          {        
  10.          
  11.          if(!input(pin_a0))                                                      // Aumenta Letra
  12.          {
  13.          letra++;
  14.          if(letra > 122) letra=97;  
  15.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",letra);
  16.          delay_ms(400);
  17.          }
  18.          
  19.          if(!input(pin_a1))                                                      // Aumenta Letra
  20.          {
  21.          letra--;
  22.          if(letra < 97) letra = 122;  
  23.          lcd_gotoxy(1,2); printf(lcd_putc,"Letra: %c",letra);
  24.          delay_ms(400);
  25.          }
  26. }
  27. }

Y si, silo hace, recorre letra a letra cada vez que se presiona el pulsador if(!input(pin_a0))   y disminuye con if(!input(pin_a1)) :mrgreen:


Ahora en la cita como comentario, como relaciono esto... Para que escriba y lea en Eeprom el nombre escrito y como lo imprimo después ??.

Citar

char temp_pass[11]; // Supongo que son 10 caracteres máximo
 
void escribirPass(cantidad){
   int8 contador = 0;
   while(temp_pass[contador])
     write_eeprom(contador++, temp_pass[contador]);
   write_eeprom(contador, '\0');
}
 
void leerPass(){
   int8 contador = 0;
   do{
      temp_pass[contador] = read_eeprom(contador);
      if(contador >= sizeof temp_pass) contador++; break;
   while(temp_pass[++contador]);
   temp_pass[contador] = '\0';
 
}

Disculpe usted mi ignorancia pero no tengo idea de como relacionarlo con el código de las letras escritas. Podría de favor despejar mis dudas?. Le agradezco!!.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: KILLERJC en 20 de Junio de 2022, 19:53:37
Creo que estuve divagando y luego cuando fui a crearlo me di cuenta que no era lo que querias hacer, pero si como yo lo haria, aunque eso significa tener mas botones.

Primero que nada escribir y leer el caracter asi como esta no tiene ningun sentido... Suponete que tenes guardado "password" y para poder ver la w, tenes que grabar los 4 primeros caracteres.... es absurdo.. Porque ahora tendrias 4 letras aleatorias que presionaste + el resto. Es decir jamas poder ver lo que esta guardado

Es por eso que considero que es necesario unos botones para "navegar" dentro del texto. Es decir, aumentar y disminuir la letra, derecha e izquierda para navegar hasta el maximo de caracteres, un boton de guardar y un boton de leer. (Al menos seria lo util en cualquier otro proyecto donde lo utilices)

Como no tengo para probarlo, dejo un posible codigo... ¿Puede ser mas compacto? Seguramente se pueda.. Especialmente todas las restricciones para verificar que sea una letra.

Código: C
  1. char temp_pass[11] = ""; // Supongo que son 10 caracteres máximo
  2.  
  3. void main(void) {
  4.        
  5.         lcd_init();
  6.         letra=97;
  7.         int8 indice;
  8.  
  9.         // Limpio por las dudas mi array
  10.         for(indice = 0; indice >= (sizeof temp_pass - 1); indice++ ){
  11.                 temp_pass[indice] = '\0';
  12.         }
  13.  
  14.         indice = 0;
  15.         temp_pass[indice] = 'a';
  16.  
  17.         lcd_gotoxy(1,1);
  18.         printf(lcd_putc,"Pass:");
  19.         lcd_gotoxy(1,2);
  20.         printf(lcd_putc,"%s",temp_pass);
  21.  
  22.         while (true)
  23.         {        
  24.  
  25.                 if(!input(pin_a0))                              // Aumenta Letra
  26.                 {
  27.                         delay_ms(10);
  28.                         while(!input(pin_a0));
  29.                         letra = temp_pass[indice];
  30.                         if(++letra > 122) letra = 97;
  31.                         if(letra < 97) letra = 97;
  32.                         temp_pass[indice] = letra;
  33.                         lcd_gotoxy(indice+1,2); printf(lcd_putc,"%c",letra);
  34.                 }
  35.  
  36.         else if(!input(pin_a1))                 // Disminuye Letra
  37.         {
  38.                         delay_ms(10);
  39.                         while(!input(pin_a1));
  40.                         letra = temp_pass[indice];
  41.                 if(--letra < 97) letra = 122;
  42.                 if(letra > 122) letra = 122;
  43.                 temp_pass[indice] = letra;
  44.                 lcd_gotoxy(indice+1,2); printf(lcd_putc,"%c",letra);
  45.         }
  46.  
  47.                 else if(!input(pin_a2))                 // Derecha
  48.                 {
  49.                         delay_ms(10);
  50.                         while(!input(pin_a2));
  51.                         indice++;
  52.                         if(indice >= (sizeof temp_pass-1)) {    // Si por las dudas me paso
  53.                                 indice = sizeof temp_pass - 1;          // Que quede como limite
  54.                         }
  55.                         if((temp_pass[indice]< 97) || (temp_pass[indice]> 122))  temp_pass[indice] = 'a'
  56.                         lcd_gotoxy(indice+1,2);
  57.                 }
  58.  
  59.                 else if(!input(pin_a3))                 // Izquierda
  60.                 {
  61.                         delay_ms(10);
  62.                         while(!input(pin_a3));
  63.                         if(!indice) {
  64.                                 indice--;
  65.                         }
  66.                         lcd_gotoxy(indice+1,2);
  67.                 }
  68.  
  69.  
  70.                 else if(!input(pin_a4))                 // Guarda
  71.                 {
  72.                         delay_ms(10);
  73.                         while(!input(pin_a4));
  74.                         temp_pass[++indice] = '\0';
  75.                         indice = 0;
  76.                         while(temp_pass[indice++]){
  77.                                 write_eeprom(indice,temp_pass[indice]);
  78.                         indice++;
  79.                         write_eeprom(indice,'\0');
  80.                         }
  81.                 }
  82.  
  83.                 else if(!input(pin_a5))                 // Lee
  84.                 {
  85.                         delay_ms(10);
  86.                         while(!input(pin_a5));
  87.                         for(indice = 0; indice >= (sizeof temp_pass - 1); indice++ ){
  88.                                 temp_pass[indice] = read_eeprom(indice);
  89.                         }
  90.                         temp_pass[++indice] = '\0';             // Por las dudas
  91.                         lcd_gotoxy(1,2); printf(lcd_putc,"%s",temp_pass);
  92.                 }
  93.         }
  94. }
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: Abner_emanuel en 21 de Junio de 2022, 18:37:30
Esta bien. El código se ve bien pensado, pero creo que trae detalles. Al menos lo e simulado en Proteus y no hace lo que debería. Pero es una buena manera de implementarlo. Al menos me dio otra forma de como lograrlo.

Gracias KILLERJC.
Título: Re:Guardar Tecla a tecla en EEprom interna
Publicado por: KILLERJC en 21 de Junio de 2022, 18:53:21
Cita de: Abner_emanuel en 21 de Junio de 2022, 18:37:30
Esta bien. El código se ve bien pensado, pero creo que trae detalles. Al menos lo e simulado en Proteus y no hace lo que debería. Pero es una buena manera de implementarlo. Al menos me dio otra forma de como lograrlo.

Gracias KILLERJC.

Seguramente tenga muchos problemas, es que no lo hice en ningun IDE, no lo probe tampoco y lo peor es que lo hice a las apuradas jejeje.
Cuando me acoste me di cuenta que me habia olvidado de los ! de los while jeje (luego se los agregue)