En esta entrada presentaremos quién es y para qué nos puede servir el módulo Keyes KY015, o KY-015 que vemos en la foto.
Este módulo, que nos lo solemos encontrar dentro del kit de módulos Keyes, es un sensor de temperatura y humedad, que está basado en el comportamiento del DHT11 que ya presentamos en una entrada anterior.
El DHT11 es un sensor digital de temperatura y humedad, que está calibrado en fábrica para dar precisiones del orden del 5% en humedad y 2% en temperatura. Trabaja en el rango de 0-50ºC y 20-90% de humedad relativa. La señal se genera en un solo terminal, el mismo que usa para recibir instrucciones, y esto hace que su integración en cualquier proyecto sea muy sencilla.
Como el circuito de polarización recomendado es
El valor que nos aportará este módulo será exclusivamente reducir el número de terminales de 3 a 4, anulando el PIN 4 que no se conectaba, e incorporando la resistencia de pull-up en el PIN de señal, para evitarnos tener que incorporarlas nosotros al circuito, si solo montásemos el DHT11 de forma individual.
De este modo lo que conseguimos es compactar en un solo módulo lo que de otro modo lo haríamos así
Si releemos lo que hablábamos en la entrada asociada al DHT11 , vimos que también sería recomendable incluir un condensador entre el GND y la alimentación con objeto de filtrar un poco la alimentación. Pues bien, según el módulo que compremos bien de Keyes o bien de otros fabricantes, vemos que algunas versiones sí han incorporado nuestra recomendación, así que siempre que el precio no lo impida, debemos fijarnos en este detalle y seleccionar la versión mejorada. Un par de ejemplos los presentamos a continuación.
El DHT11 es un sensor digital de
temperatura y humedad, que está calibrado en fábrica para dar precisiones del
orden del 5% en humedad y 2% en temperatura, y trabaja en el rango de 0-50ºC y
20-90% de humedad relativa. Por lo que dará cobertura a la mayor parte de
nuestras aplicaciones.
La señal se genera en un solo
terminal y esto hace que su integración en cualquier proyecto sea de lo más
sencilla.
El encapsulado es pequeño como podemos observar en la figura
y puede llegar a transmitir
señales a través del terminal de salida hasta 20 metros.
El circuito de polarización
típico para este sensor es el que se presenta a continuación
donde podemos ver que la alimentación puede ser de 3 o de 5
Voltios y que al terminal de la señal le colocamos una resistencia pull-up de
5Kohms para garantizar que las ligeras fluctuaciones en las tensiones de la
señal, asociadas a ruidos electrónicos, no afectan a la información que reciba
nuestro Arduino. De hecho incluso podríamos meter algún condensador de 100 nF
entre la alimentación y el GND con el propósito de filtrar también los ruidos
en la misma.
De promedio no suele consumir más que 1mA como podemos ver
en su hoja de datos, aunque puede llegar a tener picos de 2.5mA cuando está
registrando y transmitiendo la señal. Algo que está muy dentro de las capacidades
nominales de nuestros pines digitales del Arduino (40mA máx.)
El esquema de conexionado con nuestra protoboard podría ser
algo similar a esto:
Si queremos ver cómo se llegan a entender nuestro Arduino y
nuestro sensor DHT11, basta echarle un vistazo a la gráfica que de pulsos que
se presenta abajo. Tanto nuestro Arduino como nuestro sensor usan el mismo
canal para comunicarse y para transmitir, por lo que se tienen que organizar
como lo harían dos trenes pasando por una misma vía.
Primero el Arduino cambia el estado del PIN de detección (en
nuestro caso el PIN 8) de Alto a Bajo (o lo que es lo mismo de los 5 Voltios
que tenía gracias a nuestra resistencia pull-up de 5K, a 0Voltios que es el
nivel que da el PIN GND), y se queda así al menos 18 ms, con objeto de que el
sensor DHT11 detecte que algo ha pasado. Transcurridos ese tiempo, y sabiendo
que esa señal es la que avisa al DHT11 para que esté atento a las órdenes, el
Arduino genera un pulso de 5voltios de 20 a 40 microsegundos y espera a ver qué
le contesta el sensor DHT11, manteniéndose en nivel bajo y a la espera de la
respuesta del sensor, quien le contesta con otro pulso de 5voltios de
80microsegundos y a partir de ahí le manda la información en formato digital,
una vez hecho esto, pone de nuevo la línea en nivel bajo y Arduino entiende
“cierra” la comunicación volviendo a poner el canal a 5 voltios como al
principio.
El proyecto que presentamos a continuación pretende generar aviso visuales por impactos mecánicos. Sus fundamentos nos permitirán implementar a nuestro robot de capacidad de evaluar terremotos, el oleaje que soporta nuestra embarcación, o simplemente las vibraciones que soportamos cada vez que pasa un maquinaria pesada cerca nuestra. Para ello vamos a requerir del sensor de choque Keyes KY-002 disponible en el Kit de sensores Keyes 37 en 1, que fundamentalmente monta un sensor mecánico de muelle del que ya estuvimos estudiando en la entrada sensores de muelle. Su interior básicamente consiste en un muelle basculante, como podemos ver en la imagen que mostramos a continuación
que cuando se monta en el módulo Keyes KY-002 y recibe un impacto mecánico, cierra un circuito de alimentación que es capaz de detectarlo nuestro Arduino
Nota: cómo pueden existir distintos proveedores de este módulo, prestad atención a la identificación del GND(-) y de la señal (S), por si en algún caso fuera diferente. Ante la duda, como sabemos por el esquema de funcionamiento que la señal está conectada a través de una resistencia con la alimentación, nos basta con usar un multímetro para medir la resistencia entre dos pines, y si da infinito (circuito abierto) es que uno de los pines es el GND y si nos da el valor de la resistencia de pull-up que viene montada, es que estamos midiendo los pines de alimentación y señal.
Para su construcción necesitaremos los siguientes elementos:
REFERENCIA
CANTIDAD
FOTO
Sensor de choque
1
Protoboard
1
Cables colores
3
Arduino
1
El funcionamiento de un LED, de las resistencias de protección y del los sensores de muelle, lo vimos en entradas anteriores, y el programa está comentado para permitirnos entender las instrucciones que le estamos dando a nuestro microcontrolador.
DIAGRAMA DE CONEXIÓN
FUNCIONAMIENTO
Primero definiremos un pin donde vamos a enclavar el aviso visual, nuestro LED, y el pin desde donde vamos a monitorizar nuestro detector de choque. Esto lo podemos hacer bien usando variables del tipo entero o bien con la directiva #define (que ahorra memoria en caso de que nuestro sketch muy complejo). En este caso usaremos el pin 13, de nuestra placa que ya monta su propio LED.
Y también definiremos la variable que vamos a usar, para registrar si detectamos vibración o no (en nuestro caso AlarmaChoque). Luego tendremos que configurar el setup de nuestro proyecto, que en este caso se limitará a definir si los pines que vamos a usar son de entrada o salida. En este ejemplo, el LED de aviso, es un output y como el sensor de muelle nos manda una señal, este pin será un input (una entrada). A partir de aquí monitorizaremos la variable de detección de choque y si detecta una vibración hará que se encienda nuestro LED, y si no permanecerá apagado.
Si queréis descargaros el sketch y usarlo directamente en vuestra placa, el fichero os lo dejo aquí, aunque es mejor que intentemos siempre copiarlo a mano, de este modo nos vamos familiarizando con las estructuras de programación, sus funciones y los modos más comunes de error que cometeremos a medida que vayamos desarrollando programas más complejos.
Y ya sabéis, si tenéis alguna sugerencia de mejora o duda, no tenéis más que mandarnos un correo a
e intentaremos responder a vuestra pregunta lo antes que podamos.
Ahora que ya sabemos qué es un pulsador y cómo se usa, vamos a buscarle utilidad para nuestro Arduino.
Vamos a enseñar a nuestro Arduino a hacer una acción cuando se presiona un botón. Sería el ejemplo más simple de lo que nuevo será la operativa para que nuestro futuro robot actúe de forma autónoma. Cuando reciba una señal (en nuestro ejemplo la presión del botón, pero podría ser una vibración, un ruido, ...) nuestro robot ejecutará una acción (en nuestro caso el encendido de un LED, pero puede ser la activación de un sistema de vigilancia, el envío de un mensaje, la emisión de una alarma acuística, etc.).
Para esta práctica necesitaremos
Qué
Imagen
Coste
estimado
Placa
Arduino
24 €
Placa de
prototipado
5-6€
Adaptador
de red
6€
LED
naranja
0,1€
Resistencias
0,1€
Pulsador
0,2€
Cablecitos
2€
Ahora, ayudándonos de Fritzing para nuestro prototipo, vamos a desarrollar nuestro proyecto
cuyo esquema sería
donde para calcular la resistencia de protección de nuestro LED hemos usado lo que aprendimos en Cálculo de la resistencia para un led, y hemos propuesto una de 220 ohms.
y le cargamos este pequeño Sketch que hemos preparado
/*
Práctica con el pulsador_1 Basado en un sketch de DojoDave y Tom Igoe Enciende y apaga un LED conectado al pin digital 13, cuando se presiona el pulsador unido al pin 2 El circuito se coompone de: * un LED unido desde el pin 13 a tierra * un pulsador unido a pin con +5 voltios adaptado en 2013 M. Domínguez Basado en el ejemplo de dominio público http://www.arduino.cc/en/Tutorial/Button */// Bloque de definición de constantes que usaremos en nuestro sketch// Define la asignación de los pines a usarconstint pulsadorPin = 2; // El número del pin asociado al pulsadorconstint ledPin = 13; // El número del pin asociado al LED// Bloque de declaración de las variables que usaremosint pulsadorEstado= 0; // Es la variable que registrará el estado del pulsador// Bloque de configuración // Definimos qué pines vamos a usar// y si lo usaremos como entradas o como salida de datosvoidsetup() {
// Inicializamos el pin del LED y lo definimos del tipo Salida:pinMode(ledPin, OUTPUT);
// Inicializamos el pin del pulsador y lo definimos del tipo Entrada:pinMode(pulsadorPin, INPUT);
}
// Bloque de definición del programa a ejecutarse voidloop(){
// lee el valor del estado del pulsador:
pulsadorEstado = digitalRead(pulsadorPin);
// verifica si el pulsador está presionado// si es así, el estado del pulsador es Alto:// y enciende el LEDif (pulsadorEstado == HIGH) {
// enciende el LED digitalWrite(ledPin, HIGH);
}
// si no lo es, el estado del pulsador es Bajo:// y apaga el LEDelse {
// turn LED off:digitalWrite(ledPin, LOW);
}
}
Con lo que obtenemos un resultado como éste
Si nos fijamos parece que funciona, pero si nos fijamos con más detenimiento, vemos no va demasiado fino.
Cuando pulsamos el botón (o pulsador), el LED se enciende, pero cuando dejamos de pulsarlo, se mantiene encendido durante un instante, y éste no es el comportamiento que queríamos reproducir. Nuestro robot ejcutará una acción (por ejemplo activar un sistema anti-incendios) mientras se de una condición concreta (en nuestro caso, alguien presionando una botón), pero una vez que esa situación se finaliza, queremos que desactive el sistema que haya activado (en nuestro caso nuestro LED). ¿Por qué sucede ésto?
Si recordamos lo que vimos en la entrada Resistencias Pull-Up - Pull-Down, la tensión que ejercemos sobre el pin 2 de nuestro Arduino, es como el empujón que damos para abrir una puerta, si no implementamos en la puerta un mecanismos de autocierre, puede que se quede abierta durante un tiempo e incluso que se cierre y se abra debido a pequeñas perturbaciones (lo que en electrónica se llama ruido). Para ello si queremos que nuestro pin note que hemos dejado de presionar el botón tenemos que implementar nuestro pequeño resorte para cerrar "nuestra puerta". Y esto lo hacíamos conectandole una resistencia de 10K a tierra. De este modo, una vez que el pulsador deja de actuar, y los 5 voltios no llegan al pin 2, la carga que quede en ese pin, fluirá hacia la tierra a través de la resistencia de pull-down.
Para ello tendremos que modificar nuestro prototipo como sigue:
cuyo esquema sería
Y ahora sí funcionaría como queremos.
Pero ¿cómo lo hacemos si lo que queremos es justo el comportamiento contrario? Queremos que nuestro Arduino mantenga activado el sistema de iluminación de nuestro edificio (en nuestro caso, representado por el LED) a menos que se dispare una señal de emergencia, como puede ser un detector de terremotos (en nuestro caso representado por el pulsador)?.
Pues en ese caso, si pensamos de nuevo en la analogía de la puerta, lo que queremos es siempre que la puerta esté abierta, osea que querríamos que siempre hubiera 5 voltios en la entrada del pin 2 a menos que algo mande una señal contraria. Es lo que viene ser una resistencia de Pull-up
siendo su prototipo como sigue
y su comportamiento lo podemos ver más claramente en este vídeo
En resumen:
Este ejemplo enciende el LED asociado al pin 13 cuando
pulsas el botón asociado al pin 2.
Con resistencia Pull-down:
Cuando el pulsador está abierto (sin pulsar) no hay conexión
entre las dos patas del pulsador, de forma que el pin está conectado a tierra
(a través de la resistencia pull-down) y leemos un LOW (bajo ó 0). Cuando el
botón se cierra (pulsado), se establece la unión entre sus dos extremos,
conectando el pin a 5 voltios, por lo que leemos un HIGH (alto ó 1).
Con resistencia Pull-up:
Cuando cableamos el circuito en sentido contrario, con
una resistencia "pull-up" que mantiene la entrada del pin 2 en HIGH, ésta pasa LOW cuando se pulsa el botón. Así, el comportamiento del programa (sketch) se
invertie, con el LED normalmente encendido y apagado cuando se pulsa el botón.
Si resistencias pull-down o pull-up:
Si se desconectas el pin digital de E/S del todo, el LED
puede llegar a parpadear de forma errática. Esto se debe a la entrada es
"flotante", es decir, al azar se tornará en HIGH o LOW. Y este efecto se puede ver si esperas un poco o usas un LED de tensión baja y que lo haga muy sensible a las señales generadas por el ruido. Por eso se
necesita la resistencia pull-up o pull-down estos tipos de circuitos. De otro modo nuestro futuro robot, podría malinterpretar el ruido como señales de disparo, y actuar cuando debería no hacerlo.
Como ya hemos
visto, algunas de los pines de nuestro controlador funcionan en estados HIGH
(alto), o en estados LOW
(bajo).
Si usábamos el
pin 13 y decidíamos que generara una señal de salida, lo hacíamos en el bloque
de configuración de nuestro sketch, declarando el pin que íbamos a usar como OUTPUT (salida).
Para ello usamos
los pines digitales del Arduino, señalados del 13 al 2 en la sección digital de
la placa.
Por ejemplo el PIN 13, entonces: void setup() { pinMode(13, OUTPUT); // declara el pin digital 13 como de salida }
Y lo usábamos,
por ejemplo, para decirle a nuestro LED bien que se encendiera o bien que se apagara.
Para ello lo que hacíamos
era usar la funcióndigitalWrite()y pasarle sus dos parámetros . Estos parámetros son utilizados
por la función digitalWrite() para decidir qué pin y qué estado utilizar, si
bien “encendido” o HIGH, o por el contrario “apagado” o LOW.
En nuestro código
lo escribíamos:
digitalWrite(ledPin, HIGH); // pone el estado del pin a Encendido
que hablando de
voltajes, sería ponerlo a 5 voltios,
o si queríamos
apagarlo:
digitalWrite(ledPin, LOW); // pone el estado del pin a Apagado
que hablando de
voltajes, sería conectarlo a tierra o a 0 Voltios.
Esto que hemos
hecho con un pin de salida, OUTPUT, también lo podríamos hacer para los
pines digitales en modo entrada, INPUT.Podríamos definir que el pin 12, por ejemplo, se quedara “escuchando” y
según si escucha algo o no, activara un sistema de alarma.
Si usábamos el
pin 12 y decidimos que configurarlo como entrada, lo haríamos en el bloque de
configuración de nuestro sketch, declarando el pin que íbamos a usar como INPUT
(entrada).
void setup()
{
pinMode(12, INPUT); // declara el pin digital 12 como de entrada
}
Entonces cada vez
que le llegaran 5 voltios, se pondría a HIGH (Alto) y cuando se pusiera a 0
voltios, o conectado a tierra, se pondría a LOW (bajo). Es el lenguaje digital.
Es el más simple
que podamos definir, es como si la bombilla solo pudiera estar apagada o
encendida, los colores fueran blancos o negros, los números fueran 0 ó 1…
Pero aunque el lenguaje
sea simple, nuestro circuito electrónico puede necesitar algo más. Porque
¿cuándo el murmullo se convierte en silencio?, ¿Cuándo el murmullo se convierte
en grito?. Al igual que pasa cuando hablamos, las señales electrónicas siempre llevan
su parte de ruido de fondo, y esto puede hacer que las cosas no sean lo que
parecen.
Antes habíamos
imaginado que el pin 12 era una entrada que “escuchaba”, ahora imaginémosla
físicamente como la entrada a una casa.
Considere la
posibilidad de una puerta de una casa, con bisagras muy lisas, y sin pestillo. Una
puerta tan ligera y tan bien articulada que la más leve brisa hace que se abra
o que quede cerrada.
Ahora agreguemos una puerta un mecanismo automático de cierre. El resorte mantendrá
la puerta cerrada, pero no firmemente: Un suave empujón permitirá abrirla, y
luego hacer que se cierre sola.
La llamada "entrada flotante" es como nuestra puerta, la más mínima perturbación,
como la brisa arriba, hará que la entrada para cambiar aleatoriamente entre
abierto y cerrado (bajo y alto).
Al igual que con
nuestra puerta, a la que podríamos ponerle un mecanismo para que se cerrara
tras el empujón, o bien un mecanismo que la mantuviera siempre abierta, a pesar
de que puntualmente alguien la cierre.Con nuestro circuito podemos hacer justo lo mismo usando Resistencias
Pull-Up o Resistencias
Pull-Down.
Son resistencias
normales, solo llevan el nombre pull up por la función que cumplen. Las resistencias pull-up puede ser cualquier
resistencia. Lo importante es que está conectada entre la señal y la fuente de
alimentación lógica. Los rangos comunes de resistencias de pull-ups pueden ser
de 1k ohm a 100k ohms, pero depende de la familia lógica de tu microcontrolador
Se podría decir
que normalmente se llaman resistencias pull up a resistencias que en general se
conectan entre una señal lógica y el positivo y su función es asegurar que esa
señal no quede en un estado “flotante”. En la siguiente entrada veremos el valor de ellas en un ejemplo en el que usamos un pulsador en el circuito de nuestro Arduino.
