Go Down

Topic: Enviar datos al monitor serial con SD  (Read 2423 times) previous topic - next topic

CaleBit

Muchas gracias Lucario 448 por las correcciones y ajustes al código, ahora ha surgido otro problemita y es que estaba lavando mi ropa ja ja (Porque yo la lavo), y me parece que detectó una pequeña alza de voltaje  y comenzó a mostrar todos los contactos como si tuviera el botón presionado y también lo probé con el coin que me prestan para estas pruebas, y genera una especie de bucle, estuve investigando un poco y me parece que es el efecto rebote, alguna idea para solucionar esto. Gracias y disculpen tantas molestias.

noter

La cuestión es que creo que el código de Lucario no espera a que toques el botón como querías, sino que muestra los registros separados por una pausa. Para que responda al botón, puedes sustituir el delay del tiempo de muestra en pantalla por un bucle infinito, mientras no se pulse botón (o hacer un delay pequeño y luego el bucle para evitar rebotes).
Code: [Select]

delay(100);
while (!digitalRead(Btn)); // poniendo punto y coma, cerramos el while


De todas formas, sería conveniente una aclaración de lo que querías obtener, porque creo recordar que buscabas hacer simultáneamente alguna acción más.

CaleBit

Gracias por sus aportaciones y ayuda. Así es noter me parece que no me he dado a entender en ésto, lo que estoy buscando hacer es que los mensajes de bienvenida que tengo en el código estén apareciendo continuamente en un bucle, y que al leer el pulso del coin o botón que pienso que funcionan de la misma manera, me muestre en pantalla un solo registro con un delay de máximo 4 segundos, y desaparezca y siga mostrando los mensajes de bienvenida que tengo en el código.

Al principio lo hice ocupando una interrupción, mientras el bucle estaba mostrando los mensajes de bienvenida, al detectar el pulso del coin o botón (que se me quemó, pero compraré otro), me mostraba un registro en el monitor y en la lcd, el problema aquí era que solo me mostraba uno solo y lo repetía cada vez que leía la interrupción y no hacía el salto al siguiente registro, además, lo mostraba un poco rápido, y volvía de nuevo al bucle, me aconsejaron que esta no era la forma correcta de hacerlo que mejor lo hiciera leyendo el pin con digitalRead y haciendo las pruebas de las correcciones que agradezco infinitamente a Lucario, no espera a que el botón este presionado o que lea el pulso del coin solo lo muestra en un bucle infinito, también probé lo que me pusiste Noter y muestra  el bucle mucho más rápido, y no es lo que busco.

Agradezco su ayuda y tiempo, espero me haya dado entender y me puedan ayudar. Mil gracias

CaleBit

Hola he estado leyendo y creo que al fin he comprendido algo de lo que me decía noter, necesito crear un reloj de millis que emule una interrupción de aproximadamente 5 segundos en millis =5000 milisegundos tiempo necesario para mostrar un registro en la LCD, necesito también crear otras variables para conocer el estado del coin (Ya que no he comprado mi botón),  estoy haciendo los ejemplos simples de prender y apagar un Led para entenderlo mejor.

Si alguien me puede guiar y ayudar a entender mejor se lo agradeceré.

1-Una primera duda el coin que tengo funciona también como un botón, es decir al entrar una moneda, sería como pulsar un botón?

2- He visto la configuración de este equipo y según yo esta en NC que sería en LOW por eso en la interrupción la tenia en RISSING el flanco de voltaje era de subida.
Pregunta ¿Al poner el cable en pin 2 este espera el pulso para activarse(HIGH)?, o todo el tiempo esta entregando un voltaje porque si es así como podría conocer su estado.

Gracias

Cree nuevas variables aparte de las demás.

Code: [Select]


const byte Btn=2;
bool EstadoBtn =False ;
MostrarContacto=millis();



Alguien conoce la sintaxis de esta función?

De antemano gracias por su ayuda.

Lucario448

Pónte cómodo, agarra palomitas y refresco que esta respuesta se me ha alargado tanto por acumulación de varias preguntas/respuestas de este hilo.




Al principio lo hice ocupando una interrupción, mientras el bucle estaba mostrando los mensajes de bienvenida, al detectar el pulso del coin o botón (que se me quemó, pero compraré otro), me mostraba un registro en el monitor y en la lcd, el problema aquí era que solo me mostraba uno solo y lo repetía cada vez que leía la interrupción y no hacía el salto al siguiente registro, además, lo mostraba un poco rápido, y volvía de nuevo al bucle, me aconsejaron que esta no era la forma correcta de hacerlo que mejor lo hiciera leyendo el pin con digitalRead y haciendo las pruebas de las correcciones que agradezco infinitamente a Lucario
De nada.

Aunque de ser así, tendrás que implementar máquina de estados para no quedarte atascado en el "demo" y no detectar el botón a tiempo. La idea era leer un registro por cada pulso, entonces esta rutina no tenía que ser cíclica (cosa que hice en mi sugerencia por la falta de entendimiento), y la variable File debe ser global (o static).


Las rutinas de interrupción realmente no se crean para "repentinamente" cambiar el flujo de ejecución del programa principal, sino para atender tareas cortas pero que tienen prioridad de atención. No vas a dejar de ver televisión (programa principal) solo porque fuiste a atender el teléfono (interrupción).

No digo que no sea posible; lo que pasa es que por algo no se debe hacer.
Una de las razones son las "operaciones moleculares", que usualmente suelen ser operaciones matemáticas con float y otros tipos de datos de más del "ancho" del CPU (en este caso, 8 bits); en general las operaciones matemáticas combinadas en una sola línea son "moleculares".
Lo opuesto a la "operación molecular", es la "operación atómica"; la cuál, por definición, no se puede dividir; o mejor dicho, no se puede interrumpir. Las atómicas básicamente son aquellas que se pueden ejecutar una sola instrucción máquina; cabe aclarar que una instrucción máquina no necesariamente equivale a una línea de código (excepto en lenguaje ensamblador).

A todo esto, ¿entonces qué tiene de malo hacerlo? ¿Recuerdas cuando dije que las operaciones atómicas no se pueden interrumpir? Bueno pues ese el problema: sólo las atómicas.
Imagina que en plena suma de dos int se dispara una interrupción, se ejecuta su respectiva rutina pero al terminar, en vez de retomar esa suma, ejecuta otro proceso completamente distinto. ¿Qué ocurrió con la suma? La respuesta puede variar dependiendo del momento exacto en que se disparó, pero las posibilidades son: se realizó con éxito (en el mejor de los casos), la variable del resultado tiene un valor incorrecto (no es ni el anterior ni el esperado), o no ocurrió absolutamente nada (en el peor de los casos).
Sé que en "demo" no hay operaciones matemáticas, ¿pero en print, clear y setCursor? Ahí quizá sí; el no completar la ejecución como se debe, podría incluso ser fatal.



Utilizar una interrupción para alterar el flujo del programa principal es mucho más complicado de lo parece (y no recomendado por lo antes dicho); y no, no hablo de simplemente modificar el valor de una "bandera" porque eso implicaría máquina de estados de todos modos (es igual que con digitalRead).
Es tan complicado como estudiar la estructura de la pila de ejecución ("stack" en inglés) para así poder alterar el valor previo a la interrupción del "program counter"; lo cual debería resultar, efectivamente, en la alteración del flujo del programa principal posterior a esta rutina. Con decirte que eso solo es posible hacerlo con un fragmento de código en ensamblador, quizá eso te eche para atrás y prefieras mejor quedarte con lo de la máquina de estados.
Encima habrían otros efectos secundarios como perder el rastro de la pila, que a la larga provoca cuelgues por el desbordamiento de esta; a menos que con más código ensamblador, conviertas la rutina de mostrar un contacto, en algo parecido a una interrupción (capacidad de retornar al punto en el que realmente estaba) pero con poder usar Serial y delay.



Tengo entendido que eres principiante, así que si quieres evitar tanta confusión, te sugiero que prosigas con lo de la máquina de estados y nos preguntes por dónde te perdiste. Pero eso sí, ¡que se vea un esfuerzo de tu parte!


estuve investigando un poco y me parece que es el efecto rebote, alguna idea para solucionar esto
Por software: un pequeño delay apenas se detecta el pulso.
Por hardware: un condensador de 10 uF paralelo al botón.


1-Una primera duda el coin que tengo funciona también como un botón, es decir al entrar una moneda, sería como pulsar un botón?
Correcto. Al pasar la moneda, se cierra un circuito durante una fracción de segundo; pero lo suficiente para que el programa lo detecte mientras no esté atascado en retrasos.


¿Al poner el cable en pin 2 este espera el pulso para activarse(HIGH)?, o todo el tiempo esta entregando un voltaje porque si es así como podría conocer su estado.
Eso de sí se conecta a tierra o a voltaje depende de la lógica de la salida: el "estado activo" puede ser alto o bajo. O también determina en un botón u otro contacto simple si usar resistencia pull-up o pull-down (usados para estabilizar los estados digitales, pero no soluciona los rebotes).


Alguien conoce la sintaxis de esta función?
millis() no requiere parámetros. Retorna un unsigned long que representa los milisegundos transcurridos desde que el Arduino se enciende o reinicia. Se desborda cada 49.71 días.


Gracias y disculpen tantas molestias.
¿Molestias de qué? Para eso estamos, y con más razón para los que apenas empiezan ;)

CaleBit

Ok agradezco su apoyo y ayuda...la palabra "principiante" me queda grande jaja, apenas estoy comenzando con esto, pero si me gustaría terminar con este proyecto y que sea funcional. Por lo que entendí tengo que quitar los mensajes de bienvenida para evitar que se pierda el pulso dentro de esos retrasos y poner uno que este de forma permanente hasta detectar el pulso.

Bueno gracias lo intentaré hasta lograrlo aunque el tiempo me esta comiendo  :smiley-confuse:.

Lucario448

Por lo que entendí tengo que quitar los mensajes de bienvenida para evitar que se pierda el pulso dentro de esos retrasos y poner uno que este de forma permanente hasta detectar el pulso.
No es necesario que quites eso que yo he estado llamando "demo". Sigo insistiendo en el tema de la máquina de estados; con eso podrás hacer ambas cosas dando sensación de simultaneidad.

CaleBit

Ok ya entendí, mañana lo volveré a intentar creando la maquina de Estados, con switch y case. Gracias

noter

Si tengo un ratillo esta noche te doy alguna idea de cómo plantear tu máquina de estados. Lo único, me centraré sólo en puerto serie, porque me está dando problemas en deviot la librería liquidcristal, y no quiero perder más tiempo en una cuestión accesoria.

noter

Una posible vía. No está comprobado, pero creo que te puede dar una idea.
Code: [Select]

#include <SPI.h>
#include <SD.h>

File myFile;
const byte Coin=2;
const byte chipSelect=4;
int sigfase=0;
unsigned long millis_inicio=millis(), millis_espera=1000;
bool Estado=0;
char user[17]; // buffer de almacenamiento temporal
char tel[17]; // buffer de almacenamiento temporal



void setup() {
 
  pinMode(Coin,INPUT_PULLUP);

  Serial.begin (9600);
  Serial.print (" COMPROBANDO");
  delay(1000);
 
  Serial.print ("   HARDWARE...");
  delay (5000);
 
  Serial.println ("Inicializando SD card...");
  pinMode (chipSelect, OUTPUT);
  Serial.print ("Inicializando SD");
  delay (2000);
 
  if (!SD.begin(chipSelect)) {
  Serial.println ("Fallo lectura de tarjeta SD");
  Serial.print("ERROR al iniciar SD");
  delay (1000);

  Serial.print ("Inserta la SD");
  delay (5000);
    return;
  }
  myFile=SD.open ("Contactos.txt");
  if (myFile) Serial.println ("SD inicializada correctamente");
  Serial.print("BOOT exitoso...");
  delay (2000);
 }
 
void loop() {

  // Aquí tratamos la pulsación y la muestra de un registro
  Estado=digitalRead(Coin);
  if (Estado==LOW){ // Si está como pullup, pulsado será LOW
    Serial.println("Boton pulsado.");
    if (!myFile.available()) {
      user[myFile.readBytesUntil(',', user, 16)]='\0';
      tel[myFile.readBytesUntil('\n', tel, 16)]='\0';
      Serial.println(user);
      Serial.println(tel);
      delay(5000); // en este paso, como es bloqueante, podemos dejar delay
    } else {
      Serial.println ("Final del Archivo");
      myFile.seek(0L);
      delay (3000);
    }
  }

  // Aquí tratamos la demo
  if ( (millis() - millis_inicio) >= millis_espera ) {
    switch (sigfase){
      case 0:
        Serial.println("Bienveniddos a:");
        millis_espera = 2000;
      break;
      case 1:
        Serial.println("Arduino.");
        millis_espera = 7000;
      break;
      case 2: // Aprovechamos para poner todos los casos en los que hay lo mismo (borrado de pantalla y espera 1000)
      case 5:
      case 8:
        Serial.println("(borrado pantalla)");
        millis_espera = 1000;
      break;
      case 3:
        Serial.println("Aprender a");
        //millis_espera = 1000; // no es necesrio , porque ya es 1000 desde el case anterior.       
      break;
      case 4:
        Serial.println("Programar");
        millis_espera = 7000;
      break;
      // caso 5 igual que 2
      case 6:
        Serial.println("Bienvenidos");
        millis_espera = 2000;
      break;
      case 7:
        Serial.println("¡¡¡Todos!!!");
        millis_espera = 5000;
      break;
      // caso 8 igual que 2 y 5
    }
    sigfase++;
    if (sigfase > 8) sigfase=0;
    millis_inicio = millis();
  }
}

CaleBit

Muchísimas gracias por su ayuda,  he estado probando  y haciendo unos cambios, al parecer cuando el programa esta haciendo los delays para borrar pantalla deja de leer el pulso, no se si tenga un arreglo eso...Pero lo he cambiado un poco...
Code: [Select]

#include <SPI.h>
#include <SD.h>
#include <LiquidCrystal.h>


LiquidCrystal lcd(10, 9, 8, 7, 6, 5);
File myFile;
const byte VO=3;
const byte chipSelect=4;
const byte Coin=2;
bool Estado=0;
char nom[17]; // buffer de almacenamiento temporal
char tel[17]; // buffer de almacenamiento temporal
const byte BtnOn=3;


void setup() {
 
  pinMode (VO,OUTPUT);
  analogWrite (VO, 5);
  pinMode(Coin, INPUT_PULLUP);
 
    lcd.begin(16, 2);
    Serial.begin (9600);

     lcd.print (" COMPROBANDO");
  delay(1000);
 
  lcd.setCursor (0, 1);
  lcd.print ("   HARDWARE...");
  delay (5000);
  lcd.clear ();
  delay (1000);
 
  Serial.println ("Inicializando SD card...");
  pinMode (chipSelect, OUTPUT);
  lcd.print ("Inicializando SD");
  delay (2000);
  lcd.clear();
 
  if (!SD.begin(chipSelect)) {
  Serial.println ("Fallo lectura de tarjeta SD");
  lcd.print("ERROR al iniciar SD");
  delay (1000);

  lcd.setCursor (0, 1);
  lcd.print ("Inserta la SD");
  delay (5000);
  lcd.clear ();
  delay (1000);
    return;
   
  }

 Serial.println ("SD inicializada correctamente");
  lcd.setCursor (0, 0);
  lcd.print("BOOT exitoso...");
  delay (2000);
  lcd.clear ();
 
 lcd.print(" Bienvenidos a: ");
 delay(2000);
   lcd.setCursor(0, 1);
  lcd.print("ARDUINO");
  delay(7000);
  lcd.clear();
  delay(1000); 

  lcd.print(" APRENDE");
  delay(1000);
  lcd.setCursor(0, 0);

  lcd.setCursor(0, 1);
  lcd.print("CADA DIA");
  delay(7000);
  lcd.clear();
  delay(1000);

  lcd.print("*NO ESPERES MAS*");
  delay(2000);
 
  lcd.setCursor(0, 1);
  lcd.print("!!!!!!");
  delay(5000);
  lcd.clear();
  delay(900);

 myFile=SD.open ("Contactos.txt");
  if (myFile)
    lcd.print ("NOMBRE:");
    lcd.setCursor (0, 1);
    lcd.print ("TEL:");
   
 
 
 }
   
  void loop() {
 
  Estado=digitalRead (Coin);
  if (Estado==LOW){
   
  Serial.println ("Boton pulsado");
  if (myFile.available()){
  user[myFile.readBytesUntil(',', user, 16)]='\0';
  pass[myFile.readBytesUntil('\n', pass, 16)]='\0';
  Serial.println(nom);
  Serial.println(tel);
  lcd.clear();
  lcd.print (nom);
  lcd.setCursor (0, 1);
  lcd.print (tel);
  delay (5000);


  if (Estado==HIGH){

    lcd.setCursor (0, 0);
    lcd.print ("NOMBRE:");
    lcd.setCursor (0, 1);
    lcd.print ("TEL:");
 
 }

 
}else {

  Serial.println ("Final del Archivo");
  myFile.seek (0L);
  lcd.clear ();
  lcd.print ("Final del Archivo");
  delay (3000);

 
}

  }

  }




Ahora solo al leer el pulso mostrará los datos, y volverá a mostrar este mensaje en pantalla:
Nom:
Tel:
Y solo irán cambiando los datos de registro, solo que por ahora se quedan los datos en pantalla sin respetar el delay, necesitare un botón para borrarlos??

Lucario448

Aquí me tomé la libertad de corregirlo y de agregarle un detalle que hace el código un poco más robusto: manejar la situación de cuando no se puede abrir el archivo, o si el loop llega con la tarjeta sin inicializar.

Code: [Select]
#include <SD.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(10, 9, 8, 7, 6, 5);
File myFile;

const byte VO = 3;
const byte chipSelect = 4;
const byte Coin = 2;
const byte BtnOn = 3;

bool Estado = 0;
char nom[17]; // buffer de almacenamiento temporal
char tel[17]; // buffer de almacenamiento temporal

void setup() {

  pinMode (VO, OUTPUT);
  analogWrite (VO, 5);
  pinMode(Coin, INPUT_PULLUP);

  lcd.begin(16, 2);
  Serial.begin (9600);

  lcd.print (" COMPROBANDO");
  delay(1000);

  lcd.setCursor (0, 1);
  lcd.print ("   HARDWARE...");
  delay (5000);
  lcd.clear ();
  delay (1000);

  Serial.println ("Inicializando SD card...");
  pinMode (chipSelect, OUTPUT);
  lcd.print ("Inicializando SD");
  delay (2000);
  lcd.clear();

  if (!SD.begin(chipSelect)) {
    Serial.println ("Fallo lectura de tarjeta SD");
    lcd.print("ERROR al iniciar SD");
    delay (1000);

    lcd.setCursor (0, 1);
    lcd.print ("Inserta la SD");
    delay (5000);
    lcd.clear ();
    delay (1000);
    return;

  }

  Serial.println ("SD inicializada correctamente");
  lcd.setCursor (0, 0);
  lcd.print("BOOT exitoso...");
  delay (2000);
  lcd.clear ();

  lcd.print(" Bienvenidos a: ");
  delay(2000);
  lcd.setCursor(0, 1);
  lcd.print("ARDUINO");
  delay(7000);
  lcd.clear();
  delay(1000);

  lcd.print(" APRENDE");
  delay(1000);
  lcd.setCursor(0, 0);

  lcd.setCursor(0, 1);
  lcd.print("CADA DIA");
  delay(7000);
  lcd.clear();
  delay(1000);

  lcd.print("*NO ESPERES MAS*");
  delay(2000);

  lcd.setCursor(0, 1);
  lcd.print("!!!!!!");
  delay(5000);
  lcd.clear();
  delay(900);

  myFile = SD.open ("Contactos.txt"); // ¿Seguro que abre con ese nombre? Según mis "cálculos", al ser uno que no cumple con el formato 8.3; se deberá referenciar por "CONTAC~1.TXT"
  if (myFile) {
    lcd.print ("NOMBRE:");
    lcd.setCursor (0, 1);
    lcd.print ("TEL:");
  } else lcd.print ("No se pudo abrir");
}

void loop() {

  Estado = digitalRead (Coin);
  if (Estado == LOW) {

    Serial.println ("Boton pulsado");
    if (myFile) {
      if (myFile.available()) {
        nom[myFile.readBytesUntil(',', nom, 16)] = '\0';
        tel[myFile.readBytesUntil('\n', tel, 16)] = '\0';
        Serial.println(nom);
        Serial.println(tel);
        lcd.clear();
        lcd.print (nom);
        lcd.setCursor (0, 1);
        lcd.print (tel);
        delay (5000);
        lcd.clear();
        lcd.print ("NOMBRE:");
        lcd.setCursor (0, 1);
        lcd.print ("TEL:");



      } else {

        Serial.println ("Final del Archivo");
        myFile.seek (0L);
        lcd.clear ();
        lcd.print ("Final del Archivo");
        delay(3000);
        lcd.clear();
        lcd.print ("NOMBRE:");
        lcd.setCursor (0, 1);
        lcd.print ("TEL:");


      }
    } else {
      lcd.clear();
      lcd.print ("ERROR: no hay SD");
      lcd.setCursor (0, 1);
      lcd.print ("o archivo no exs");
    }

  }

}

noter

#27
Apr 21, 2018, 11:15 am Last Edit: Apr 21, 2018, 11:16 am by noter
Ahora estoy perdido. En los dos últimos códigos veo que ya no está la demo que se debe mostrar cuando no se ha pulsado el botón. Además veo que se imprimen primero los datos, y tras una pausa, las etiquetas "nombre y tel:". Creo que sería más bien así el código:
Code: [Select]
#include <SD.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(10, 9, 8, 7, 6, 5);
File myFile;

const byte VO = 3;
const byte chipSelect = 4;
const byte Coin = 2;
const byte BtnOn = 3;

bool Estado = 0;
char nom[17]; // buffer de almacenamiento temporal
char tel[17]; // buffer de almacenamiento temporal

void setup() {

  pinMode (VO, OUTPUT);
  analogWrite (VO, 5);
  pinMode(Coin, INPUT_PULLUP);

  lcd.begin(16, 2);
  Serial.begin (9600);

  lcd.print (" COMPROBANDO");
  delay(1000);

  lcd.setCursor (0, 1);
  lcd.print ("   HARDWARE...");
  delay (5000);
  lcd.clear ();
  delay (1000);

  Serial.println ("Inicializando SD card...");
  pinMode (chipSelect, OUTPUT);
  lcd.print ("Inicializando SD");
  delay (2000);
  lcd.clear();

  if (!SD.begin(chipSelect)) {
    Serial.println ("Fallo lectura de tarjeta SD");
    lcd.print("ERROR al iniciar SD");
    delay (1000);

    lcd.setCursor (0, 1);
    lcd.print ("Inserta la SD");
    delay (5000);
    lcd.clear ();
    delay (1000);
    return;

  }

  Serial.println ("SD inicializada correctamente");
  lcd.setCursor (0, 0);
  lcd.print("BOOT exitoso...");
  delay (2000);
  lcd.clear ();

  lcd.print(" Bienvenidos a: ");
  delay(2000);
  lcd.setCursor(0, 1);
  lcd.print("ARDUINO");
  delay(7000);
  lcd.clear();
  delay(1000);

  lcd.print(" APRENDE");
  delay(1000);
  lcd.setCursor(0, 0);

  lcd.setCursor(0, 1);
  lcd.print("CADA DIA");
  delay(7000);
  lcd.clear();
  delay(1000);

  lcd.print("*NO ESPERES MAS*");
  delay(2000);

  lcd.setCursor(0, 1);
  lcd.print("!!!!!!");
  delay(5000);
  lcd.clear();
  delay(900);

  myFile = SD.open ("Contactos.txt"); // ¿Seguro que abre con ese nombre? Según mis "cálculos", al ser uno que no cumple con el formato 8.3; se deberá referenciar por "CONTAC~1.TXT"
  if (myFile) {
    lcd.print ("NOMBRE:");
    lcd.setCursor (0, 1);
    lcd.print ("TEL:");
  } else lcd.print ("No se pudo abrir");
}

void loop() {

  Estado = digitalRead (Coin);
  if (Estado == LOW) {

    Serial.println ("Boton pulsado");
    if (myFile) {
      if (myFile.available()) {
        nom[myFile.readBytesUntil(',', nom, 16)] = '\0';
        tel[myFile.readBytesUntil('\n', tel, 16)] = '\0';
        Serial.println(nom);
        Serial.println(tel);
        lcd.clear();
        lcd.print ("NOMBRE:"); // entiendo que este paso va aquí, no tras el delay
        lcd.print (nom);
        lcd.setCursor (0, 1);
        lcd.print ("TEL:"); // entiendo que este paso va aquí, no tras el delay
        lcd.print (tel);
        delay (5000);
      } else {
        Serial.println ("Final del Archivo");
        myFile.seek (0L);
        lcd.clear ();
        lcd.print ("Final del Archivo");
        delay(3000);
      }
    } else {
      lcd.clear();
      lcd.print ("ERROR: no hay SD");
      lcd.setCursor (0, 1);
      lcd.print ("o archivo no exs");
    }
  }

  // aquí iría el código de las pantallas de demo, con millis.
}


Y efectivamente, mientras se ejecuta el delay no se toma en cuenta el pulsador, pero como el nombre debe mostrarse sí o sí esos segundos, no hay por qué detectar pulsación ese tiempo, salvo que quieras guardarlas en una especie de buffer y mostrar tantos nombres seguidos como pulsaciones.

CaleBit

Gracias noter y lucario ustedes si son grandes, solo los grandes comparten sus conocimientos, y ayudan a los desvalidos como yo. Así es noter lo cambie por que pretendo leer todos los pulsos en cualquier momento que sea presione un botón o por el coin, sin que se pierda uno de ellos, ayer probé con millis el demo y se comía algunos pulsos.

Y pues quedaría muy somero al llegar al final del setup queda impreso el NOM: y TEL: en la lcd y al detectar el pulso limpia pantalla y muestra los datos y vuelve al estado original de la pantalla mostrando NOM: y TEL: para el siguiente pulso, parece que eso lo tengo, ahora quisiera que después de mostrado un registro en la lcd y monitor borrarlo para que no lo vuelva a mostrar ya. Ahora estoy mirado SD REmove y como aplicarlo.  Cualquier comentario es bienvenido. Gracias brothers.

Lucario448

ahora quisiera que después de mostrado un registro en la lcd y monitor borrarlo para que no lo vuelva a mostrar ya. Ahora estoy mirado SD REmove y como aplicarlo.
¡SD.remove() borra el archivo! ¿Seguro que es lo que quieres hacer?

¿No era mejor la idea de preguntar a available() cuando el archivo se termina, para así simplemente no repetir el recorrido ya más?

Go Up