/*
La función millis

Devuelve el número de milisegundos (ms) desde 
que la placa Arduino empezó a ejecutar el sketch 
(partiendo desde cero). Este conteo se reiniciara 
aproximadamente después de 50 días (cuando su valor 
supere el máximo permitido por su tipo de variable, 
que es “unsigned long”). No tiene parámetros.

La función micros

Devuelve el número de microsegundos (μs) desde que 
la placa Arduino empezó a ejecutar el sketch. Este 
número (de tipo unsigned long) se reseteará a cero 
aproximadamente después de 70 minutos. Esta instrucción 
tiene una resolución de 4 μs (es decir, que el valor 
retornado es siempre un múltiplo de cuatro). Recordar 
que 1.000 μs es un milisegundo y por tanto, .1000.000 μs 
es un segundo. No tiene parámetros.

Ejemplo 1 – Conteo de tiempo en microsegundos
*/
/*
unsigned long time; //Declara un variable del mismo tipo 
                    //que la que devuelve micros()
void setup(){
    Serial.begin(9600); //Inicializa la comunicación serial
}
void loop(){
    time = micros(); // Consulta los microsegundos desde que
                     // se inició el sketch
    Serial.println(time); //Imprime el valor en el monitor serial
    delay(1000); //Espera 1 segundo
}
*/
/*
La espera es con delay()

Pausa el sketch durante la cantidad de milisegundos especificados 
como parámetro (de tipo unsigned long). No tiene valor de retorno.
Y la espera con delayMicroseconds()

Pausa el sketch durante la cantidad de microsegundos especificados
como parámetro (de tipo unsigned long) . Actualmente el máximo valor
que se puede utilizar con precisión es de 16383. Para esperas mayores 
que esta, se recomienda usar la instrucción delay(). El mínimo valor 
que se puede utilizar con precisión es de 3 μs. No tiene valor de 
retorno.

Ejemplo 2 – Como funciona millis()
*/
/*
unsigned long inicio, fin, transcurrido;  // Declaramos 3 variables

void setup(){
   Serial.begin(9600);  //Inicializa la comunicación serial
}
void loop(){
   
   inicio=millis();  //Consulta los milisegundos desde que se inició 
                    //el sketch
   delay(1000);  //espera un segundo
   fin=millis();  //Consulta los milisegundos desde que se inició el sketch
   transcurrido=fin-inicio;  //Calcula el tiempo desde la última lectura
   Serial.println(transcurrido);  //Imprime el valor en el monitor serial
   delay(500);  //espera 0.5 segundos
}
*/
/*
Las funciones delay() y delayMicroseconds() como lo mencionamos anteriormente, 
ponen en pausa el sketch, lo cual puede resultar un problema cuando tenemos 
otras tareas que atender, y este problema se ve acentuado cuando los tiempos 
de espera son largos. Para resolver esto es recomendable usar la función 
millis() para controlar esos tiempos. En el siguiente ejemplo veremos como 
hacer parpadear un led usando millis(). Y podemos usar una programación similar 
para atender eventos periódicos.

Ejemplo 3 – Hacer parpadear un led con millis()
*/
int led = 13; // declaro el pin 13 como led
int estadoLed;  //guarda el estado del led (encendido o apagado)
int periodo = 1000;  // tiempo que esta el LED en alto y bajo
unsigned long tiempoAnterior = 0;  //guarda tiempo de referencia para comparar

void setup() {
    pinMode(led,OUTPUT);  //el led se configura como salida
}
void loop() {
  if(millis()-tiempoAnterior>=periodo){  //si ha transcurrido el periodo programado
    estadoLed=!estadoLed;  //cambia el estado del led cada 1000 ms
    digitalWrite(led,estadoLed);  //actualiza el estado del led
    tiempoAnterior=millis();  //guarda el tiempo actual como referencia
    }
}