En la entrega pasada logramos instalar el IDE de Arduino y además realizar el primer programa, en esta entrega, seguiremos haciendo código para poder entender mejor el Arduino, utilizando entradas digitales.


Un led y un pulsador

En el ejemplo del post pasado, controlamos el tiempo de encendido y apagado de un led por software, en esta oportunidad, lo haremos por hardware.

¿Cuál es nuestro nuevo elemento?

Exacto. El pulsador.

Antes de empezar, veremos cómo funciona un pulsador.

Existen diferentes tipos de pulsador, está el que tiene 2 patitas y 4 patitas, pero al final, la funcionalidad es la misma, si se presiona permite el paso de la corriente, si se deja de presionar lo interrumpe,  si lo vemos de esta manera es súper simple, pero al igual que con el led, es necesario una resistencia, pero en este caso, es utilizada para establecer el estado en el que estará el Pin mientras no se presione el interruptor.

Hay 2 tipos, la resistencia Pull Up y la resistencia Pull Down, pero…

¿En qué se diferencian? ¿Cuál debería usar?

Con la resistencia Pull Up el Vout siempre vera un HIGH (1 lógico) mientras no se presione el pulsador, al momento de presionarlo la corriente va a “preferir” irse a tierra porque no tiene nada que interrumpa su paso (resistencia) y mostrar un LOW (0 lógico).

En forma contraria pasa con la Pull Down, el Vout siempre vera un LOW (0 lógico) mientras no se presione el pulsador, pero al momento de presionarlo, se mostrara un HIGH (1 lógico) porque no tiene nada que interrumpa su paso (resistencia).

De vuelta al pulsador, cuando tenemos un pulsador de 2 patitas, es fácil conectarlo, pero cuando es de 4. ¿Cómo sabemos la forma correcta de conectarlo?

La parte A es utilizada por un lado del pulsador y la parte B por el otro lado, es decir, para que pueda funcionar, debo conectar A con B, no importa si conecto el primer A o el segundo A, de igual manera con el B.

Teniendo en cuenta esto, la conexión física sería algo como esto:

Y el de 2 patitas sería algo así, sin tantas complicaciones:

Bastante fácil, ¿verdad?

Bueno, ahora que sabemos cómo funciona un pulsador vamos a integrarlo en un programa.

Imaginemos que queremos controlar el encendido y apagado de un led, pero esta vez necesitamos presionar un pulsador para lograrlo. El circuito será algo así:

El pulsador tiene una resistencia pull up, por lo que el puerto siempre estará viendo 1 lógico, y el Led se encuentra conectado al pin 13 junto a su resistencia, para el caso de la resistencia del pulsador, esta normalmente esta entre 1k y 10k, eso depende del diseñador y la resistencia del led como hablamos anteriormente oscila entre 220ohm y 330ohm.

¿Ya realizaste las conexiones?

Ahora hablemos de código.

/*
Un LED y un pulsador -----------------------------------
Oprimir un pulsador y mientras este se mantenga presionado el led enciende
*/
//------------------------------------
//Declaramos los puertos de entradas y salidas
//------------------------------------
     int pulsador=2; //Pin donde se encuentra el pulsador, entrada
     int led=13; //Pin donde se encuentra el LED, salida
//------------------------------------
//Función principal
//------------------------------------
void setup()
          {
          pinMode(pulsador, INPUT); // Pulsador como entrada
          pinMode(led,OUTPUT); // LED como salida
          }
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop()
          {
//Condicional para saber estado del pulsador
          if (digitalRead(pulsador)==HIGH)
                {
                //Pulsador oprimido
                digitalWrite(led,HIGH); //Enciende el LED
                }
          else
                {
                //Pulsador NO oprimido
                digitalWrite(led,LOW); //Apaga el LED
                }
           }
//Fin programa

  • El pinMode permite configurar el modo de trabajo del puerto, puede ser INPUT (entrada) u OUTPUT (salida)
  • El digitalWrite permite escribir una salida digital HIGH (alta) o LOW (baja).
  • El digitalRead permite leer el estado del puerto digital, HIGH (alta) o LOW (baja).

Hasta los momentos todo está bien, pero hay un refrán que dice “papel aguanta todo”, cuando trabajamos con pulsadores existe algo llamado “efecto rebote”.

Normalmente al presionar un pulsador esperamos que la señal que entra al Arduino sea limpia, pero físicamente al presionar el pulsador generará un rebote por un lapso muy corto de tiempo pero que el Arduino puede interpretar como si fueran muchas pulsaciones al mismo tiempo dando resultados inesperados en la mayoría de los casos.

¿Cómo solucionamos esto?

Existen 2 formas de hacerlo, por hardware y por software.

Anti-rebote por hardware

Podemos eliminar el rebote colocando un condensador en paralelo a tierra, ¿qué efecto hace eso? Al momento de presionar el pulsador, el capacitor se va cargando, durante el tiempo de carga y descarga, el pin de Arduino dejara de leer pulsaciones. Esto es bueno y malo, porque si el tiempo es muy prolongado, ignorara las pulsaciones posteriores.

Para poder calcular el tiempo que durara el capacitor en cargarse y descargarse utilizaremos la formula

t=R*C,

R es nuestra resistencia y C nuestro capacitor. El resultado sera el tiempo que tardara el capacitor para que puedas volver a presionar el pulsador, es recomendable que tu capacitor se encuentre en el orden de los nf ya que se obtiene menor tiempo de respuesta en ese orden.

Si no puedes modificar el hardware por alguna razón, también podemos generar un retardo por software.

Anti-rebote por software.

Por software hay que ser muy cuidadoso igual que por hardware, pero en este caso podemos tomar 2 vías.

Podemos agregarle un delay después de presionar el pulsador, de tal manera que el programa tarde en leer la próxima pulsación como por ejemplo tomando referencia el programa anterior:

/*
-----------------------------------
Un LED y un pulsador
-----------------------------------
Oprimir un pulsador y mientras este se mantenga presionado el led enciende
*/
//------------------------------------
//Declaramos los puertos de entradas y salidas
//------------------------------------
int pulsador=2; //Pin donde se encuentra el pulsador, entrada
int led=13; //Pin donde se encuentra el LED, salida
//------------------------------------
//Función principal
//------------------------------------
void setup()
{
pinMode(pulsador, INPUT); // Pulsador como entrada
pinMode(led,OUTPUT); // LED como salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop()
{
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH)
{
//Pulsador oprimido
digitalWrite(led,HIGH); //Enciende el LED
delay(50);
}
else
{
//Pulsador NO oprimido
digitalWrite(led,LOW); //Apaga el LED
}
}
//Fin programa

Hay otras formas de generar antirebote usando interrupciones, pero después de todo, eres quien decide cómo te sientes más cómodo programando.

Esto fue una pequeña explicación de un ejemplo con pulsador. Espero sea útil y de tu agrado.

¿Te gustó? ¿Quieres más?

¡Espera nuestra próxima entrega!