Flanco para arriba, flanco para abajo… ¡Qué mareo!

Los flancos en ArduinoAloha! A ver si hoy entre tantos petardos y mascletàs podemos escribir algo. Algo de lo que siempre he hablado y nunca acabo de concretar. Los flancos de subida y bajada. Los unos y ceros de la electrónica digital.

Cuando trabajas con los pines digitales generas unas señales que encienden y apagan cosas. Vamos a hablar de esas señales y de su uso, porque sino no tendría ningún sentido esto.

Para qué sirven los unos y los ceros…

Siempre te hablo de ceros y unos. Que cero corresponde con 0 Voltios y que uno corresponde con 5 Voltios. Podría darse el caso de que un uno correspondiera a 3.3V, todo depende de el voltaje al que trabaje tu placa o elemento. En el caso Arduino, ya sabes que son 0 y 5 Voltios (a no ser que utilices las versiones nano y cosas así que funcionan a 3.3 Voltios…).

Entonces, cuando un led está apagado y lo queremos encender enviaremos un uno. Cuando lo queramos apagar mandaremos un cero… Pero esto es válido para un sensor óptico, el cuál manda un uno o un cero dependiendo de si encuentra algún objeto cerca o no lo encuentra.

Claro, no nos serviría ante un sensor de temperatura ya que éste nos va a dar un valor continuo, no discreto. Continuo quiere decir que toma un rango de valores, igual nos ofrece 2.1 Voltios que 3.6 Voltios. Ya que la temperatura no es algo que se pueda apagar y encender, medimos su valor.

Un valor discreto es eso, encender o apagar. Solamente hay dos opciones que nos pueden llegar… Y eso es lo que utilizamos con sensores ópticos, con interruptores, para encender un motor, para crear una señal de aviso o simplemente para encender un led.

Y aquí es cuando aparecen los flancos…

Imagina que tengo un sensor óptico y quiero contar el número de veces que alguien pasa su mano por él. ¿Cómo lo hago? Si lo hago como mis entrañas me dicen, lo que haré será medir cada momento que el sensor se ponga a uno… pero claro, esto no es lo mismo que contar el número de veces que alguien toca.

¿Por qué? Imagínate a tu cuñado, ahí muy majo él, que le enseñas tu proyecto. Le dices que cuenta cada vez que alguien toca. ¿Sabes lo que hará? Lo que todo buen cuñado hace: poner la mano durante 10 segundos o más, de manera que la cuenta se te irá al garete porque en realidad no contabas las veces que alguien tocaba, sino el tiempo que la señal estaba a uno.

Tras aguantar la burla de tu cuñado, seguramente decidas dejar de lado el experimento. Pero no es necesario, simplemente debes de conocer qué son los flancos de subida y los flancos de bajada. El flanco de subida es cuando la señal pasa de cero a uno, la línea vertical que aparece para marcar ese cambio en la señal. (Imagen alojada en Wikimedia perteneciente a MrLejinad con una licencia Creative Commons)

onda cuadrada

El flanco de bajada es la inversa, cuando la señal baja y pasa de uno a cero repentinamente. Con estos flancos puedes conocer el número de veces ya que lo que haces es contar las veces que la señal sube y baja. A veces dará igual utilizar un flanco u otro para llevar la cuenta (como en el caso del sensor contador) pero en otros puede que te interese contar uno de ellos.

Lo que hay que tener en cuenta son los rebotes. Objetos como los pulsadores pueden crear rebotes, es decir, pueden crear varios flancos de subida y bajada por  cada vez que se pulsen. La solución para esto es que al tomar el valor del primer flanco, uses la función delay para crear una espera y no vuelvas a tomar valores en un tiempo razonable.

Opt In Image

Código para detectar flancos en Arduino

Hay aparatos que detectan los flancos automáticamente. De hecho, Arduino lo hace con sus interrupciones. Las cuáles detectan un flanco de subida o bajada y se activan cuando eso sucede.

Pero si quieres utilizar esto de los flancos en tus programas de Arduino de tu día a día puedes utilizar esperas como en el caso de los rebotes de los pulsadores. Puedes tomar el valor cada vez y cuando llega un uno sumas en el contador y haces una espera para que no cuente nada más. Esto lo puedes hacer si sabes que va a ser algo que se terminará en un tiempo determinado y corto.

Lo más normal sería esto:

int contador = 0;
bool dato = LOW;
bool datoAnterior = LOW;

void setup() {
pinMode(6,INPUT);
}

void loop() {
 dato = digitalRead(6);
 if (dato == HIGH && datoAnterior == LOW)
 {
  contador++;
 }
 datoAnterior = dato;

}

Lo que hago es mirar cada vez el valor. En el momento en que cambia a uno y el anterior era un cero sumo al contador. Claro, cuando se dé el flanco de bajada no lo detectará y solamente contaré los flancos de subida tal y como quería. Este código acepta modificaciones, pudiendo contar los flancos de bajada:

int contador = 0;
bool dato = LOW;
bool datoAnterior = LOW;

void setup() {
pinMode(6,INPUT);
}

void loop() {
 dato = digitalRead(6);
 if (dato == LOW && datoAnterior == HIGH)
 {
  contador++;
 }
 datoAnterior = dato;
}

O simplemente contar un cambio, lo que viene siendo tanto flancos de subida como de bajada:

int contador = 0;
bool dato = LOW;
bool datoAnterior = LOW;

void setup() {
pinMode(6,INPUT);
}

void loop() {
 dato = digitalRead(6);
 if (dato != datoAnterior)
 {
  contador++;
 }
 datoAnterior = dato;
}

Te dejo con tu cuñado, que ya tienes bastante…

Los flancos pueden servirte para cualquier cuenta, de hecho si no los usas siempre puede aparecerte tu cuñado por detrás y echarse unas risas a tu costa…

Y además, que el código es muy muy simple, creo que vale la pena implementarlo y dejar de ir contando cuanto tiempo estamos en uno y en cero. ¿Tú qué opinas? Déjamelo escrito en los comentarios 😉

[Total:2    Promedio:3.5/5]

Déjame un comentario que en el fondo soy buen chaval

  1. Oscar

    Responder

  2. Responder

  3. luis fdo jaramillo

    Responder

    • Responder

Deja un comentario