{"id":283,"date":"2010-11-13T19:02:19","date_gmt":"2010-11-13T18:02:19","guid":{"rendered":"http:\/\/electronicapractica.crearblog.com\/?p=283"},"modified":"2019-06-13T19:47:29","modified_gmt":"2019-06-13T17:47:29","slug":"pulsadores-sin-rebotes","status":"publish","type":"post","link":"https:\/\/www.diarioelectronicohoy.com\/blog\/pulsadores-sin-rebotes","title":{"rendered":"Pulsadores"},"content":{"rendered":"

Introducci\u00f3n.<\/span><\/h2>\n

<\/a><\/p>\n

Que son los pulsadores.<\/strong> Pulsadores o interruptores, hay toneladas de ellos en su casa. Un interruptor es un dispositivo simple con dos posiciones, EN y AP (EN<\/strong>cendido y AP<\/strong>agado). Una clase de interruptor que usted usa cada d\u00eda es el interruptor de la luz. Cuando conecta, dentro del interruptor, dos cables son unidos, lo que permite fluir a la corriente que enciende la luz o la tostadora se caliente. Cuando lo desconecta, los dos cables son desunidos y corta el flujo de la corriente. Esto esta muy bien pero creo que esto no es lo que interesa aqu\u00ed.<\/p>\n

En definitiva, se trata de un mecanismo simple (los hay muy sofisticados), constituido por un par de contactos el\u00e9ctricos que se unen o separan por medios mec\u00e1nicos. En electricidad, los falsos contactos que se producen el ser utilizados normalmente, en algunos casos produce una chispa debido a la corriente que atraviesa los contactos, provocando que quemen en parte y ennegreciendo los contactos el\u00e9ctricos, lo que a la larga acaba deteriorando dichos contactos. La chispa se produce siempre al separar los contactos (desconectar), en ocasiones parece que tambi\u00e9n salta al conectarlos, eso es debido a los rebotes mec\u00e1nicos que se producen al cambiar de estado.<\/p>\n

<\/p>\n

Esto que en electricidad se considera normal, en electr\u00f3nica es un verdadero nido de problemas, debido a dichos falsos contactos. Por su propia naturaleza, al cambiar de posici\u00f3n un interruptor, los contactos chocan entre s\u00ed y esto significa una serie de falsos contactos que se reproducen de un modo sin control, por lo que se generan los temidos rebotes (debounce en ingl\u00e9s), estos rebotes, se producen incluso cuando unimos dos cables desnudos, simulando un interruptor o pulsador.<\/p>\n

Pulsadores.<\/span><\/h2>\n

Estos peque\u00f1os pulsadores son un 1\/4 \u00bb por cada lado, son bastante econ\u00f3micos y se pueden ‘pinchar’ directamente en una placa de prototipado. Estos dispositivos mec\u00e1nicos tienen 4 patillas, que pueden hacernos pensar que hay 4 cables que son EN y AP, pero de hecho, dos de cada lado en realidad dentro est\u00e1n unidos. Por tanto realmente, este pulsador es solamente un pulsador de 2 cables.<\/p>\n

\"\"<\/a>Como digo, en electr\u00f3nica los rebotes suelen fastidiar a los intr\u00e9pidos reci\u00e9n iniciados que creen en la teor\u00eda y sin embargo se salta este punto en muchas ocasiones, lo que les lleva a recordar la importancia que tiene el antirrebote.<\/p>\n

Resistencias de polarizaci\u00f3n.<\/span><\/h2>\n

Cuando nos de desenvolvemos en el entorno de los microcontroladores, nos encontramos con un t\u00e9rmino poco com\u00fan, me refiero a la polarizaci\u00f3n de una E\/S, debemos saber que hay dos tipos de polarizaci\u00f3n, polarizaci\u00f3n alta la resistencia (t\u00e9rmino ingl\u00e9s Pullup<\/strong>) va conectada a + (5V) o polarizaci\u00f3n baja la resistencia (t\u00e9rmino ingl\u00e9s Pulldown<\/strong>) va conectada a masa – (0V). Siguen dos esquemas de estos t\u00e9rminos:<\/p>\n

 <\/p>\n

\"\"<\/a>Si disponemos los tres componentes del esquema para realizar el circuito que representa, cada vez que se presione el pulsador, el LED ir\u00e1 a EN (encender) y al ser liberado el pulsador el LED ir\u00e1 a AP (apagar).<\/p>\n

\"\"<\/a>El efecto de rebote mec\u00e1nico que produce inevitablemente, el pulsador al ser presionado o al soltarlo, no permite apreciar el parpadeo en este sencillo montaje, debido a la velocidad con que se produce el parpadeo del LED, simplemente por que es inapreciable por el ojo humano. El ojo humano tiene una persistencia de alrededor de 0’1 de segundo. Vamos a seguir con otros ejemplos para ver este efecto y como evitarlo.<\/p>\n

Pulsador.<\/span><\/h2>\n

Vamos a hacer nuestra primera prueba de bot\u00f3n (pulsador) conectando un LED en nuestra tarjeta Arduino. El s\u00edmbolo del esquema para un pulsador de bot\u00f3n es algo diferente que el mostrado. Prepare un LED rojo y una resistencia de 10K Ohms, as\u00ed como el pulsador de bot\u00f3n y construya un montaje del esquema en su tabla de prototipado cerca del Arduino.<\/p>\n

\"\"<\/a>Ha llegado la hora de ponernos a programar, llegados aqu\u00ed, deber\u00edamos decidir que tipo de entrada utilizar, anal\u00f3gica o digital. Para no demorar m\u00e1s el tema, haremos la prueba con un pin digital, ya que se trata de un pulsador que presentar\u00e1 1 o 0, lo conectamos a +5V a trav\u00e9s de una resistencia y para mantener el consumo del LED, lo conectamos con una resistencia (de 270 Ohm) para limitar su consumo dentro de t\u00e9rminos admisibles de las salidas de Arduino (sobre los 20mA).<\/p>\n

\"\"<\/a>Analizaremos el esquema, he elegido la RPB polarizaci\u00f3n a bajo (Pulldown), por simular el efecto de un estado 0 (L) en descanso del pulsador, lo que en buena l\u00f3gica es 0, es apagado y lo que es 1, es encendido, del mismo modo, cuando presione el pulsador ir\u00e1 a 1, el LED se encender\u00e1, permaneciendo apagado a 0 el resto del tiempo, \u00a1l\u00f3gico!. El resto del circuito, no tiene demasiado inter\u00e9s.<\/p>\n

El c\u00f3digo.<\/span><\/h2>\n

En primer lugar, quiero recordar al lector que debe documentar sobre la marcha los c\u00f3digos, esto har\u00e1 que no pierda tiempo posteriormente, cuando quiera reutilizar alguna rutina de este listado, para no volver a escribir tanto c\u00f3digo.<\/p>\n

Como siempre, es buena costumbre darle un nombre al principio del archivo dentro del mismo y una peque\u00f1a descripci\u00f3n de que hace o para que sirve, fecha de creaci\u00f3n, autor, etc. As\u00ed que empecemos.<\/p>\n

Este es el listado del c\u00f3digo que utilizaremos en esta ocasi\u00f3n, servir\u00e1 para el caso. Como se ve, es propiedad de Massimo Banzi (gracias). Copiar este c\u00f3digo y guardarlo con el nombre pulsador03.pde<\/em><\/span> en la carpeta destino de vuestros ejemplos o ejercicios, para comprobar su funcionamiento.<\/p>\n

\n
\/* Pulsador y LED\r\n\r\n *\r\n * Detectar si el bot\u00f3n ha sido presionado o no y encender\r\n * el LED en consecuencia.\r\n *\r\n * Basado en un c\u00f3digo de: Massimo Banzi\r\n *\r\n *\/\r\n\r\n int inPin = 10;              \/\/ pin del pulsador\r\n\r\nvoid setup()     \/\/ establecer la configuraci\u00f3n de pines a usar.\r\n {\r\n  Serial.begin(9600);         \/\/  Inicializa el puerto serie a 9600 baudios\r\n  pinMode(inPin, INPUT);      \/\/ Inicializa el pin 10 como entrada digital\r\n }\r\n\r\nvoid loop()                   \/\/ Lazo que se repite indefinidamente\r\n {\r\n  Serial.print(\"Estado del pulsador: \"); \/\/ muestra el \"Estado del pulsador: \"\r\n  Serial.println(digitalRead(inPin));     \/\/ imprime el estado del (pulsador)\r\n                                         \/\/ y lo muestra en decimal (0\/1)\r\n  delay (50);      \/\/ toma un poco de tiempo.\r\n }<\/pre>\n<\/blockquote>\n
Este es un c\u00f3digo escueto, corto que, funciona, sin embargo prefiero un c\u00f3digo que ‘diga m\u00e1s’, algo m\u00e1s completo y did\u00e1ctico, si es posible. Como el que sigue:<\/p>\n
\n
\/* Pulsador\r\n\r\n *\r\n * Detectar si el bot\u00f3n ha sido presionado o no y encender\r\n * el LED en consecuencia.\r\n *\r\n * Basado en un c\u00f3digo de: Massimo Banzi\r\n *\r\n *\/\r\n\r\n int inPin = 10;                 \/\/ pin del pulsador\r\n int ledPin = 2;                 \/\/ pin del LED\r\n int value = 0;                  \/\/ valor que tomara el pulsador\r\n\r\nvoid setup()     \/\/ establecer la configuraci\u00f3n de pines a usar.\r\n {\r\n  Serial.begin(9600);         \/\/  Inicializa el puerto serie a 9600 baudios\r\n  pinMode(inPin, INPUT);      \/\/ Inicializa el pin 10 como entrada digital\r\n  pinMode(ledPin, OUTPUT);    \/\/ Inicializa el pin 2 como salida digital\r\n }\r\n\r\nvoid loop()               \/\/ Lazo que se repite indefinidamente\r\n {\r\n  value = digitalRead(inPin); \/\/ Lee el valor de la entrada digital (pulsador)\r\n  Serial.print(\"Estado del pulsador: \"); \/\/ muestra el \"Estado del pulsador: \"\r\n  Serial.print(value, DEC);  \/\/ imprime el estado del (pulsador)\r\n                             \/\/ y lo muestra en decimal (0\/1)\r\n  digitalWrite(ledPin, value);     \/\/ enciende el LED cuando el value es = 1.\r\n }<\/pre>\n<\/blockquote>\n
An\u00e1lisis.<\/span><\/h2>\n
Como se aprecia, las l\u00edneas est\u00e1n comentadas en su mayor\u00eda, tampoco es necesario pasarse, aqu\u00ed lo hago, para que se pueda entender por los no iniciados.<\/p>\n
En primer lugar, se declaran las variables globales que, se usaran en cualquier parte del programa, se designan los nombres que damos a los pines de E\/S y a las variables de estado o lo que se haya previsto como tal. Seguidamente, el m\u00f3dulo de configuraci\u00f3n de los pines como E\/S y si utilizaremos el puerto serie para comunicaci\u00f3n que, utilizar\u00e1 el programa void setup()<\/strong>, siguen si hay las rutinas generales, aqu\u00ed esta su sitio, en otro caso, se llega al lazo principal que se ejecutar\u00e1 sin descanso, estoy refiri\u00e9ndome al m\u00f3dulo void loop()<\/strong>, con el que se da por terminado el c\u00f3digo.<\/p>\n
void setup()<\/span><\/h3>\n
Tenemos que decirle a Arduino que ponga el pin que designamos para el pulsador, como entrada. Esto es bastante f\u00e1cil, empleando pinMode ()<\/strong> para usar la ENTRADA, para leer el pulsador o en su lugar de SALIDA para leer el el valor del pin. Por cierto, el m\u00f3dulo void setup()<\/strong> s\u00f3lo se leer\u00e1 una vez, cuando se inicia o reinicia la ejecuci\u00f3n del programa.<\/p>\n
Lectura Digital.<\/span><\/h3>\n
Podemos usar el nuevo procedimiento digitalRead ()<\/strong>, que solamente toma como entrada el pin a examinar. El procedimiento digitalRead () devuelve un resultado cada vez que es le\u00eddo. Dicho resultado es 0 (BAJO) o 1 (ALTO) dependiendo de lo que vio cuando mir\u00f3 el voltaje del pin. En este caso, leemos el pin y luego pasamos el resultado como una entrada a otro procedimiento,  println ()<\/strong>, por ejemplo. Seguramente podr\u00edamos usar una variable para guardar el resultado de digitalRead ()<\/strong> y luego usar aquella variable como entrada al println ()<\/strong> pero esto es mucho m\u00e1s directo.<\/p>\n
\n
  . . .\r\n  pinMode(switchpin, INPUT);  \/\/ hace switchpin, pin de entrada.\r\n  pinMode(ledpin, OUTPUT);    \/\/ hace ledpin, pin de salida.\r\n  . . .\r\n  . . .\r\n  Serial.println(digitalRead(switchpin));  \/\/ imprime el estado del (pulsador)\r\n   . . .<\/pre>\n<\/blockquote>\n
El caso de la variable se ver\u00e1 m\u00e1s adelante.<\/p>\n
  value = digitalRead(inPin); \/\/ Lee el valor de la entrada digital (pulsador)\r\n  Serial.print(value);  \/\/ imprime el estado del (pulsador)<\/pre>\n
Escritura Digital.<\/span><\/h2>\n
Con el procedimiento DigitalWrite()<\/strong> pondremos el voltaje en un pin a ALTO 5V o a BAJO masa 0V y luego usaremos DigitalRead()<\/strong> para preguntar si aquel pin es ALTO o BAJO. Este procedimiento se usa normalmente como salida, mayormente en el m\u00f3dulo void loop()<\/strong>, como tendremos ocasi\u00f3n de comprobar.<\/p>\n
Compilar el c\u00f3digo.<\/span><\/h2>\n
\"\"<\/a>Utilizando el software, libre de Arduino. Copie y pegue el c\u00f3digo del ejercicio, en la zona habilitada para este fin. Conecte la tarjeta Arduino a su computadora (PC) y pulse el icono (n\u00ba1) de Verify<\/strong>.<\/p>\n
Si todo va bien, el c\u00f3digo saldr\u00e1 bien, sin errores, a continuaci\u00f3n pulse el icono de <\/span>Upload to I\/O board<\/strong> (es el n\u00ba 6), esta vez tambi\u00e9n cargar\u00e1 el programa que acaba de compilar en la memoria del Atmega (Arduino) y ahora, pulse el <\/span>Serial Monitor<\/strong> (n\u00ba 7) para ven en la parte inferior c\u00f3mo se muestra el estado del pulsador.\"\"<\/a><\/span><\/p>\n
Compilar el programa.
\n\"\"<\/a>Cargar el programa en el Arduino.
\n\"\"<\/a>Monitorizar el resultado<\/p>\n
En el monitor, se aprecia que mientras no se presiona el pulsador, la salida es 0 y cada vez que se presiona, al hacer contacto, se muestra un 1, lo que demuestra si se ha presionado o no el pulsador.<\/p>\n
Verifique que cuando el bot\u00f3n es presionado, enciende el LED y cuando el bot\u00f3n es liberado, el LEd se apaga. Si no le funciona, trate de usar declaraciones println<\/strong> para eliminar fallos de su proyecto. Cuando usted aprieta el bot\u00f3n, hace que imprima un mensaje. As\u00ed usted puede decir si la mitad de entrada funciona o si no funciona la mitad de salida. Ahora puede guardar el archivo pulsando el icono (n\u00ba5)<\/p>\n
 -El mejor modo de destruir completamente un microcontrolador como Arduino es, alimentarlo con voltajes demasiado altos. \u00a1Aseg\u00farese que sus voltajes de entrada est\u00e1n entre 0 y 5V! \u00a1Nunca conecte la bater\u00eda 9V directamente en un pin de entrada, esto freir\u00e1 el pin y posiblemente destruir\u00e1 al microcontrolador Arduino! <\/em><\/p>\n
Ahora, desconecte el Arduino de su computador y cambie el sistema de alimentaci\u00f3n del Arduino, por medio de una pila de 9V, conecte dicha pila al Arduino y ya puede presionar el bot\u00f3n. El LED deber\u00eda encenderse cuando el pulsador es presionado (la corriente es capaz de fluir) y vuelve a apagarse cuando se ha liberado el pulsador (la corriente no es capaz de fluir), esto demuestra que el Arduino una vez cargado el programa, puede funcionar de forma aut\u00f3noma.<\/p>\n
Si, ya se, el monitor tiene un ‘problema’ est\u00e1 mostrando continuamente la misma respuesta \u00abEstado del pulsador: 0\u00bb<\/strong> y s\u00f3lo cambia a \u00abEstado del pulsador: 1\u00bb<\/strong> en el momento en que se presiona el pulsador y seguidamente se repite el \u00abEstado del pulsador: 0\u00bb<\/strong>. Vaya, no es un grave problema, ya que todo funciona como se esperaba, la salvedad de lo que muestra el monitor. Como no es un verdadero problema no le daremos m\u00e1s importancia por el momento. El programa hace lo que se esperaba.<\/p>\n
El caso principal es que seguimos sin apreciar el tan mencionado rebote (debuncing). En el pr\u00f3ximo ejemplo veremos c\u00f3mo se produce dicho efecto.<\/p>\n
Tercer ejercicio.<\/span><\/h2>\n
En este momento, vamos a desarrollar el c\u00f3digo que nos permita constatar el efecto rebote. Para este fin, he aprovechado un c\u00f3digo de un maestro en esta materia como es H. Barragan, s\u00f3lo he hecho unas peque\u00f1as modificaciones para que se aprecie con m\u00e1s detalle lo que ocurre al ejecutar el programa.<\/p>\n
\n
\/*\r\n    Pulsador Conmutador \r\n\r\n  original: by BARRAGAN <http:\/\/barraganstudio.com>\r\n\r\n  El pin usado como entrada es conectado a un pulsador y el pin\r\n  usado como salida al LED. Cuando el pulsador es presionado,\r\n  parpadea el LED, el LED deber\u00eda apagarse cuando el pulsador es\r\n  liberado.\r\n\r\n  Se puede ver el efecto rebote (debouncing)\r\n\r\n   Revisado 26 Julio 2009\r\n   por V. Garcia.\r\n\r\n *\/ \r\n\r\nint direction = 1;  \/\/ usado para el ciclo de parpadeo\r\nint switchPin = 8;  \/\/ pin digital para unir el interruptor\r\nint ledPin = 2;    \/\/ pin para conectar el LED \r\n\r\nvoid setup() {\r\n  Serial.begin(9600);                  \/\/ establece comunicacion serie\r\n  pinMode(switchPin, INPUT);   \/\/ pone el pin digital 8 como la entrada\r\n  pinMode(ledPin, OUTPUT);     \/\/ pone el pin digital 2 como la salida\r\n} \r\n\r\nvoid loop()\r\n {\r\n  if(digitalRead(switchPin) == HIGH)  \/\/ si el interruptor es presionado\r\n   {\r\n     direction *= -1;                  \/\/ alterna entre 1 o -1\r\n     if (direction == 1)               \/\/ para decidir conectar o no la luz\r\n     {\r\n      digitalWrite(ledPin, HIGH);     \/\/ conecta la luz\r\n     }\r\n     else\r\n     {\r\n      digitalWrite(ledPin, LOW);      \/\/ desconecta la luz\r\n     }\r\n     Serial.print(direction);\r\n     delay(20);                       \/\/ espera 20 milliseconds\r\n   }\r\n }<\/pre>\n<\/blockquote>\n
Aunque est\u00e1 bien comentado, describir\u00e9 lo que hace el programa, sobre todo, en el punto que m\u00e1s define el efecto rebote. El punto determinante del programa se encuentra justo en la orden direction *= -1;<\/strong> , es la responsable de cambiar su estado, en cada paso del programa por ese punto. Y esto se produce muy velozmente (depende del reloj del micro). No se ha provocado nada nuevo, tan solo se ha puesto de relieve el efecto que habitualmente ocurre con un contacto mec\u00e1nico.<\/p>\n
Mantenga el pulsador presionado por un momento. Que ocurre. Que sucede. Que el LED parece que parpadea, s\u00f3lo lo parece, que va, realmente parpadea, dicen que alguno no ha visto parpadear a nadie tan r\u00e1pido \u00a1Un momento! Calma. Si, parpadea, es lo que ocurre normalmente, cuando un contacto no se protege contra los rebotes. Eso es lo que yo pretend\u00eda demostrar con tanto listado de c\u00f3digo y aqu\u00ed est\u00e1.<\/p>\n
Primero las variables:<\/p>\n
\n
\/\/ Aqu\u00ed ir\u00e1n los #includes XXXXXX.h si se usan y la definici\u00f3n de variables.\r\n\r\nint direction = 1;  \/\/ usado para el ciclo de parpadeo\r\nint switchPin = 8;  \/\/ pin digital para unir el interruptor\r\nint ledPin = 2;     \/\/ pin para conectar el LED<\/pre>\n<\/blockquote>\n
Seguido del m\u00f3dulo setup()<\/strong> para la configuraci\u00f3n de los pines E\/S implicados en el programa y definir el puerto serie para la comunicaci\u00f3n (definir el puerto serie, no es siempre necesario) con el PC por ejemplo.<\/p>\n
\n
void setup() {\r\n  Serial.begin(9600);          \/\/ establece comunicacion serie\r\n  pinMode(switchPin, INPUT);   \/\/ pone el pin digital 8 como la entrada\r\n  pinMode(ledPin, OUTPUT);     \/\/ pone el pin digital 2 como la salida\r\n}<\/pre>\n<\/blockquote>\n
Por cierto, cuando utilizamos los microcontroladores, en ocasiones podemos utilizar la resistencia de polarizaci\u00f3n interna del pin indicado. Con esto, ahorramos las resistencias de polarizaci\u00f3n externas que anteriormente se comentaron y su comportamiento es id\u00e9ntico. Este es un buen momento para utilizar esta posibilidad, veamos c\u00f3mo.<\/p>\n
\n
 void setup()\r\n {\r\n  Serial.begin(9600);            \/\/ establece comunicacion serie\r\n  pinMode(switchPin, INPUT);\r\n  digitalWrite(switchPin, HIGH);<\/span> \/\/ conecta RPA interna a alto (5V)\r\n  pinMode(ledPin, OUTPUT);\r\n }<\/pre>\n<\/blockquote>\n
Si hubiera subrutinas en nuestro programa, se pondr\u00edan aqu\u00ed, antes del siguiente m\u00f3dulo. Como no es el caso, el m\u00f3dulo que sigue es el bucle void loop()<\/strong> que se ejecutar\u00e1 continuamente.<\/p>\n
La declaraci\u00f3n if()<\/span><\/h3>\n
Este escenario (sketch), introduce un tipo completamente nuevo y apasionante de declaraci\u00f3n. La declaraci\u00f3n if<\/strong>. Esto es, una declaraci\u00f3n l\u00f3gica, que usted puede recordar de su clase de matem\u00e1ticas de escuela primaria. B\u00e1sicamente, hasta ahora hemos tenido al Arduino haciendo; solamente encienda; parpadear LEDs; imprima mensajes; etc. Pero ahora queremos que adem\u00e1s tome decisiones.<\/p>\n
\n
void loop()\r\n {\r\n  if(digitalRead(switchPin) == HIGH)  \/\/ si el interruptor es presionado\r\n   {\r\n     direction *= -1;                \/\/ alterna entre 1 o -1\r\n     if (direction == 1)             \/\/ para decidir conectar o no la luz\r\n     {\r\n      digitalWrite(ledPin, HIGH);    \/\/ conecta la luz\r\n      Serial.print(\" H:\");           \/\/ muestra la H de Alto.\r\n     }\r\n     else\r\n     {\r\n      digitalWrite(ledPin, LOW);     \/\/ desconecta la luz\r\n      Serial.print(\" L:\");           \/\/ muestra la L de Bajo.\r\n     }\r\n     Serial.print(direction);\r\n     delay(20);                       \/\/ espera 20 milliseconds\r\n   }\r\n }<\/pre>\n<\/blockquote>\n
La declaraci\u00f3n if, es la primera declaraci\u00f3n que es condicional, esta s\u00f3lo controla las declaraciones si una condici\u00f3n es verdadera. En este caso, las condiciones son el \u00abbot\u00f3n se ha presionado\u00bb o el \u00abbot\u00f3n no es presionado\u00bb.<\/p>\n
Operadores de Comparaci\u00f3n:<\/span><\/h4>\n
\n
 x == y (x es igual a y) x != y (x no es igual a y) x < y (x es menor que y) x > y (x es mayor que y) x <= y (x es menor o igual a y) x >= y (x es mayor o igual a y)<\/span><\/pre>\n<\/blockquote>\n
En la primera l\u00ednea del if<\/strong>, se compara el estado del pin de entrada perteneciente al pulsador, para saber si se ha pulsado. Si se ha presionado, el estado del pulsador ser\u00e1 1 (H) y por lo tanto se ejecutar\u00e1 lo que hay dentro del siguiente corchete \u00ab{ …. }\u00bb<\/p>\n
\n
   if(digitalRead(switchPin) == HIGH)  \/\/ si el interruptor es presionado\r\n   {\r\n    . . .\r\n   }<\/pre>\n<\/blockquote>\n
En cuyo caso, se conmunta el estado de la variable direction<\/strong> y se consulta si su valor ahora es 1 (o -1).<\/p>\n
\n
     direction *= -1;      \/\/ alterna entre 1 o -1\r\n     if (direction == 1)   \/\/ nueva compraci\u00f3n. Para conectar o no el LED\r\n     {\r\n      digitalWrite(ledPin, HIGH);   \/\/ conecta el LED\r\n      Serial.print(\" H:\");          \/\/ muestra la H de Alto.\r\n     }<\/pre>\n<\/blockquote>\n
Si no, se ejecutar\u00e1 lo que sigue a else { <\/strong>, que puede ser lo contrario a la acci\u00f3n anterior.<\/p>\n
\n
     else\r\n      {\r\n       digitalWrite(ledPin, LOW);   \/\/ desconecta el LED\r\n      Serial.print(\" L:\");          \/\/ muestra la L de Bajo.\r\n      }<\/pre>\n<\/blockquote>\n
En este caso, tambi\u00e9n a\u00f1adimos una salida para el puerto serie que permita ver el resultado de los dos estados posibles del pulsador.<\/p>\n
\n
   Serial.print(direction); \/\/ imprime el contenido de la variable 'direction'.\r\n   delay(20);                \/\/ espera 20 milliseconds<\/pre>\n<\/blockquote>\n
Pruebe a comentar la l\u00ednea delay y vuelva a compilar el c\u00f3digo, luego modifique el valor del par\u00e9ntesis (expresado en milisegundos) y vuelva a compilar el c\u00f3digo cada vez, aprender\u00e1 de la importancia de este par\u00e1metro.<\/p>\n
El programa de arriba, tal cual, demuestra que mientras se presiona el pulsador, el LED se enciende e incluso parpadea, aunque la presi\u00f3n sobre el bot\u00f3n sea muy r\u00e1pida. Puede que si es muy r\u00e1pido, a la vista no se aprecie, sin embargo, si utilizamos el monitor del sistema Arduino, \u00e9ste delatar\u00e1 el efecto rebote. Procedamos, una vez cargado el programa en la placa de Arduino, pulse el icono 7 (corresponde al monitor), ahora, intente realizar una r\u00e1pida presi\u00f3n del pulsador, qu\u00e9 ocurre, en el monitor se ve, cada letra lleva su valor asociado, como se muestra en la imagen siguiente.<\/p>\n
\"\"<\/a>Presencia de Rebote<\/p>\n
Esto es lo que siempre trataremos de evitar. Imaginase por un momento que, hemos construido de un reloj electr\u00f3nico y ha llegado el esperado momento de su puesta en hora. Qu\u00e9 ocurre si al realizar el programa no hemos previsto un sistema antirrebote, cree usted que puede poner en hora el minutero o acaso el segundero, sinceramente creo que le costar\u00eda incluso poner la hora actual sin m\u00e1s. Piense que con cada pulsaci\u00f3n, se produce un tren de impulsos (observe la imagen anterior) que el contador del reloj interpretar\u00e1 como pulsos separados, de modo que ser\u00e1 una ardua tarea la puesta en hora.<\/p>\n
Volvamos al tema que nos ocupa, vayamos a dar soluci\u00f3n a nuestro problema. Si usted ha hecho los cambios que le he sugerido, habr\u00e1 notado que al comentar el delay, aumentan exageradamente el n\u00famero de rebotes, sin embargo, si aument\u00f3 el valor del tiempo (dentro del par\u00e9ntesis), por ejemplo, si subimos el valor a 200, se observa que dejan de producirse rebotes, salvo que mantengamos presionado el pulsador, cosa a todas luces, innecesaria.<\/p>\n
\n
 \/* Pulsador Conmutador \r\n\r\n  original: by BARRAGAN <;http:\/\/barraganstudio.com>\r\n\r\n  El pin usado como entrada es conectado a un pulsador y el pin usado\r\n  como salida se conecta al LED. Cuando el pulsador es presionado,\r\n  parpadea el LED, el LED deber\u00eda apagarse cuando el pulsador es\r\n  liberado.\r\n\r\n  Se puede apreciar el efecto rebote (debouncing)\r\n\r\n   Revisado 26 Julio 2009\r\n   por V. Garcia.\r\n\r\n *\/\t \r\n\r\nint direction = 1;  \/\/ usado para el ciclo de parpadeo\r\nint switchPin = 8;  \/\/ pin digital para unir el interruptor\r\nint ledPin = 2;    \/\/ pin para conectar el LED  \r\n\r\nvoid setup() {\r\n  Serial.begin(9600);          \/\/ establece comunicacion serie\r\n  pinMode(switchPin, INPUT);   \/\/ pone el pin digital 8 como la entrada\r\n  pinMode(ledPin, OUTPUT);     \/\/ pone el pin digital 2 como la salida\r\n} \r\n\r\nvoid loop() { \r\n\r\n  if(digitalRead(switchPin) == HIGH)  \/\/ si el interruptor es presionado\r\n  {\r\n    direction *= -1;                  \/\/ alterna entre 1 o -1\r\n    if (direction == 1)               \/\/ para decidir conectar o no la luz\r\n    {\r\n      digitalWrite(ledPin, HIGH);     \/\/ conecta la luz\r\n      Serial.print(\" H:\");\r\n    }\r\n    else\r\n    {\r\n      digitalWrite(ledPin, LOW);      \/\/ desconecta la luz\r\n      Serial.print(\" L:\");\r\n    }\r\n    Serial.print(direction);\r\n    delay(200);                       \/\/ espera 20 milliseconds\r\n  }\r\n}<\/pre>\n<\/blockquote>\n
A pesar de todo, no es esta la soluci\u00f3n definitiva. Hemos de dar con una forma que de ninguna manera se produzcan rebotes, o al menos que, no dependa de condiciones circunstanciales dependientes del azahar.<\/p>\n
CIRCUITO SIN REBOTES.<\/span><\/h2>\n
\"\"<\/a>He encontrado la forma de evitar los rebotes, en cuanto he considerado c\u00f3mo encarar el problema. La soluci\u00f3n pasa por leer el estado del bot\u00f3n cuando se produce el borde ascendente de la tensi\u00f3n a extremos de los contactos del pulsador e introducir inmediatamente la salida con ese estado, el resto de entradas (se llama ruido) se inhiben o anulan mediante un lapsus de tiempo. V\u00e9ase la imagen de debajo para entender mejor lo dicho.<\/p>\n
\n
El lapsus de tiempo se puede variar para que no se lea m\u00e1s que el primer pulso del tren de pulsos que se generan. Y este es el listado del c\u00f3digo que cumple estos par\u00e1metros. Puede copiar y pegar este c\u00f3digo<\/a> que sigue, en su software para comprobar su efectividad.<\/p>\n
\n
\/*          conmutador.pde   (switch)\r\n *\r\n * Cada vez el pin de entrada va de BAJO a ALTO (p.ej. debido a apretar un\r\n * bot\u00f3n),el pin de salida es basculado de BAJO a ALTO o de ALTO a BAJO. Hay\r\n * un retraso m\u00ednimo entre basculados para los rebotes del circuito.\r\n *  (no hacer caso del ruido).\r\n *\r\n *   http:\/\/www.arduino.cc\/en\/Tutorial\/Switch\r\n *\r\n *  David A. Mellis\r\n *  21 November 2006\r\n *\r\n * Modificado por V.Garcia 29072009 23:10H\r\n *\r\n *\r\n * Funciona correctamente, emplea 2.442 bytes.\r\n *\r\n *\/\r\n\r\nint inPin = 8;         \/\/ pin8 entrada\r\nint outPin = 2;        \/\/ pin2  salida\r\nint previous = LOW;    \/\/ lectura anterior del pinX de entrada\r\nint state = LOW;       \/\/ estado actual del pin de salida\r\nint reading;           \/\/ lectura actual del pin de entrada\r\n\r\n\/\/ las siguientes variables son largas por el tiempo medido en miliseconds,\r\n\/\/ r\u00e1pidamente se har\u00e1 un n\u00famero m\u00e1s grande que puede ser almacenado en un int.\r\nlong time = 0;         \/\/ la ultima vez que el pin de salida fue basculado\r\nlong debounce = 500;   \/\/ tiempo de rebote, se aumenta si la salida parpadea \r\n\r\nvoid setup()            \/\/ Config. pines\r\n{\r\n   pinMode(inPin, INPUT);\r\n   pinMode(outPin, OUTPUT);\r\n   Serial.begin(9600);\r\n}\r\n\r\nvoid loop()\r\n{\r\n  reading = digitalRead(inPin); \r\n\r\n\/\/ si la entrada solamente fuera de BAJO a ALTO y hemos esperado bastante\r\n\/\/ tiempo para que ning\u00fan ruido afecte al circuito, el pin de salida bascula y\r\n\/\/ recuerda el tiempo\r\n\r\n  if (reading == HIGH && previous == LOW && millis()+100 - time > debounce) {\r\n    if (state == HIGH) {\r\n     state = LOW;\r\n     Serial.print(\" Estado Pin: L \"); \/\/muestra estado actual de variable state\r\n     Serial.println(state);\r\n     time = millis();\r\n    }\r\n    else {\r\n     state = HIGH;\r\n     Serial.print(\" Estado Pin: H \"); \/\/muestra estado actual de variable state\r\n     Serial.println(state);\r\n     time = millis();\r\n    }\r\n  }\r\n  digitalWrite(outPin, state);\r\n  previous = reading;\r\n}<\/pre>\n<\/blockquote>\n
El listado del c\u00f3digo est\u00e1 bastante comentado, sin embargo hago recordar que en este listado hay una gran diferencia ante los listados anteriores, consiste en que si usted mantiene presionado el pulsador, no se modifica nada en la salida. Si viera un cambio, es debido a que ha cambiado el estado del pulsador, aunque s\u00f3lo sea por un inapreciable instante. Ver el resultado que muestra wl monitor.\"\"<\/a><\/p>\n
\n
NUEVO CIRCUITO SIN REBOTES.<\/span><\/h2>\n
Hemos visto un ejemplo que funciona bien basado en la lectura del borde (o flanco) ascendente, es decir, el primer estado de ABAJO a ARRIBA. Seguidamente se muestra un nuevo ejemplo que se basa en el borde descendiente, es decir, el \u00faltimo estado de ARRIBA a ABAJO.<\/p>\n
Puede copiar y pegar el siguiente listado del c\u00f3digo y guardarlo como conmutador_ab.pde, en su software para comprobar una vez m\u00e1s que funciona y adem\u00e1s que lo hace al soltar el pulsador.<\/p>\n
\n
 \/*\r\n *  conmutador sin rebote (debounced)\r\n *\r\n * Cuando el pin de entrada va de ALTO a BAJO (p.ej. al liberar un bot\u00f3n),\r\n * el pin de salida es basculado de ALTO a BAJO o de BAJO a ALTO. Hay un\r\n * retraso m\u00ednimo entre basculados para los rebotes del circuito.\r\n *\r\n *     29\/07\/09\r\n *  Autor: V. Garcia\r\n *\/\r\n\r\nint switchPin = 8;          \/\/ switch se conecta al pin 8\r\nint ledPin = 2;             \/\/ el LED se conecta al pin 2\r\n\r\nint val;                    \/\/ variable para lectura del estado del pin\r\nint val2;                   \/\/ variable para leer el estado delayed\/debounced\r\nint botonStado;             \/\/ variable para mantener el estado del bot\u00f3n\r\n\r\nint lightMode = 0;          \/\/ Esta la luz EN o AP\r\n\r\nvoid setup() {\r\n  pinMode(switchPin, INPUT); \/\/ pone el pin switch como entrada\r\n  pinMode(ledPin, OUTPUT);\r\n  Serial.begin(9600);           \/\/ Comunicaci\u00f3n serie puesta a 9600bps\r\n  botonStado = digitalRead(switchPin);  \/\/ lee el estado inicial\r\n}\r\n\r\nvoid loop(){\r\n val = digitalRead(switchPin); \/\/ lee el valor de entrada y almac\u00e9nlo en val\r\n delay(10);                    \/\/ 10 milisegundos es un  tiempo bueno\r\n val2 = digitalRead(switchPin);\/\/ lea la entrada otra vez para comprobar saltos\r\n if (val == val2) {           \/\/ aseg\u00farar que conseguimos 2 lecturas constantes\r\n   if (val != botonStado) {   \/\/ el estado de bot\u00f3n ha cambiado!\r\n     if (val == LOW) {         \/\/ compruebe si el bot\u00f3n es presionado\r\n       if (lightMode == 0) {   \/\/ esta la luz AP?\r\n        lightMode = 1;         \/\/ conecta la luz!\r\n\r\n          digitalWrite(ledPin, HIGH);\r\n          Serial.print(\"Estado: \");\r\n          Serial.println(lightMode);\r\n        } else {\r\n          lightMode = 0;               \/\/ apaga la luz!\r\n          digitalWrite(ledPin, LOW);\r\n          Serial.print(\"Estado: \");\r\n          Serial.println(lightMode);\r\n        }\r\n      }\r\n    }\r\n    botonStado = val;              \/\/ guardar el nuevo estado en la variable\r\n  }\r\n}<\/pre>\n<\/blockquote>\n
V\u00e9ase en la figura que sigue los resultados que se corresponden con lo que se describe m\u00e1s arriba.<\/p>\n
\"\"<\/a>Sin rebotes<\/p>\n
A DESTACAR.<\/span><\/h3>\n
Que podemos destacar en el procedimiento que se sigue para realizar el c\u00f3digo que evita los rebotes. Si observamos con atenci\u00f3n el comportamiento del programa, veremos que los cambios en la salida del pin #2, se producen justo en lo que se llama, flanco de bajada<\/em><\/strong> o borde de bajada<\/em><\/strong>, es decir, no en el momento de la conexi\u00f3n, si no en el momento de soltar o dejar de presionar.<\/p>\n
Compruebe usted el efecto, presiones y mantenga presionado el pulsador, no ha ocurrido nada, se ha cambiado el estado del LED, ahora, suelte el pulsador, en ese momento se produce el cambio del LED, vuelva a realizar lo mismo y experimente que los cambios se producen siempre al ser liberado el pulsador. Considero probado la eliminaci\u00f3n del efecto que se persegu\u00eda, el rebote o  debounce<\/em>.<\/p>\n
Una vez comprobado que, el programa proporciona los resultados esperados, puesto que no siempre se tienen que mostrar los resultados en el monitor, se puede eliminar del c\u00f3digo las referencias a la comunicaci\u00f3n serie, dejando m\u00e1s compacto el c\u00f3digo.<\/p>\n
El lector, nuevamente, con unos pocos cambios puede adaptar este listado a sus proyectos.<\/p>\n
Como siempre, comentarios, criticas y sugerencias para mejorar este art\u00edculo, son bienvenidos y apreciados.<\/p>\n
\"\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Introducci\u00f3n. Que son los pulsadores. Pulsadores o interruptores, hay toneladas de ellos en su casa. Un interruptor es un dispositivo simple con dos posiciones, EN y AP (ENcendido y APagado). Una clase de interruptor que usted usa cada d\u00eda es el interruptor de la luz. Cuando conecta, dentro del interruptor, dos cables son unidos, lo […]<\/p>\n","protected":false},"author":4,"featured_media":1550,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_exactmetrics_skip_tracking":false,"_exactmetrics_sitenote_active":false,"_exactmetrics_sitenote_note":"","_exactmetrics_sitenote_category":0,"footnotes":""},"categories":[22,15,39],"tags":[80,126,127,138,139],"class_list":["post-283","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-arduino","category-microcontroladores","category-pulsadores-sin-rebotes","tag-debucing","tag-pulsador","tag-rebotes","tag-switch","tag-teclado"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/283","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/comments?post=283"}],"version-history":[{"count":9,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/283\/revisions"}],"predecessor-version":[{"id":4843,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/posts\/283\/revisions\/4843"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/media\/1550"}],"wp:attachment":[{"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/media?parent=283"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/categories?post=283"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.diarioelectronicohoy.com\/blog\/wp-json\/wp\/v2\/tags?post=283"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}