Termopar

Termopar con Arduino y MAX6675 medición
de temperatura
by Admin | Jul 14, 2018 | Tutoriales Arduino | 0 comments
En este tutorial te enseñaremos a conectar un termopar con Arduino a través de
un circuito integrado MAX6675 que esta diseñado para termopares tipo K.
Los termopares son excelentes cuando se desean medir temperaturas elevadas,
donde los sensores de silicio como el LM35DZ no pueden ser aplicados debido a
que serían destruidos o dañados por temperaturas extremas.
Desafortunadamente un termopar no puede conectarse fácilmente al ADC de un
microcontrolador, ya que la señal que genera es muy pequeña, pero existen
circuitos como el MAX6675 que facilitan la tarea enormemente y en esta entrada
abordaremos el procedimiento para conectar este tipo de sensores a nuestra
tarjeta arduino favorita.
Dentro del pequeño encapsulado SOIC 8 del MAX6675 se encuentra la electrónica
necesaria para amplificar, compensar y convertir a digital el voltaje generado por el
termopar, lo que hace muy sencilla la tarea de conectar un sensor de este tipo a
un microcontrolador como el Arduino Uno.
Materiales necesarios para las prácticas del

termopar con Arduino
Para esta experiencia requerimos los materiales listados más abajo. Como
siempre te recomendamos revisar nuestra tienda virtual para que nos apoyes a
generar más contenido a través de tu compra.
 Módulo MAX6675 con termopar
 Arduino UNO R3 o Similar
 Pantalla LCD 16×2
 Potenciómetro de 10K
 Cables para conexión
Teoría de funcionamiento del termopar

Un termopar es un dispositivo formado por la unión de dos metales distintos que
produce un voltaje (efecto Seebeck), que es función de la diferencia de
temperatura entre uno de los extremos denominado “punto caliente” o unión
caliente o de medida y el otro denominado “punto frío” o unión fría o de referencia.
Este tipo de sensores son ampliamente utilizados en aplicaciones de
instrumentación industrial debido principalmente a su bajo costo y su amplio rango
de temperaturas. La principal desventaja de los termopar es su exactitud, ya que
rara vez se consiguen errores menores que 1 grado centígrado.
En la siguiente imagen podemos ver un típico termopar tipo K.
Para conocer los tipos de termopares que existen, dependiendo del material
con el que están elaborados, te recomendamos revisar este enlace, donde se
explica más a detalle el funcionamiento del termopar y los tipos que existen en el
mercado así como su composición.
Cómo conectar un termopar con Arduino usando

el módulo MAX6675.
El siguiente diagrama muestra como llevar a cabo la conexión de un módulo de
MAX6675 con el Arduino.
Cabe recordar que existen varios tipos de módulos en el mercado y debemos
prestar atención para no equivocarnos en la posición de las señales.
Si no usaremos la pantalla LCD, podemos omitir el armado de esta parte del
circuito.
Librería para conectar un termopar con Arduino y
MAX6675
Antes de continuar con el desarrollo de los ejemplos siguientes, es necesario
descargar e instalar la librería para el MAX6675. El enlace de descarga de la
librería se muestra a continuación:
Librería para MAX6675 con Arduino
Puedes consultar el tutorial para instalar librerías si tienes dudas sobre la
instalación de librerías en arduino.
Termopar con Arduino y monitor serial

El siguiente programa ilustra el funcionamiento de un termopar con Arduino, el
resultado de las mediciones se envía a la PC para mostrarse en el monitor serial
del Arduino.
En un ejemplo posterior, mostraremos como visualizar el resultado de la medición
en una pantalla LCD de 16×2. Cabe destacar que podemos cambiar a nuestra
voluntad los pines donde se conecta el módulo MAX6675 cambiando las
definiciones correspondientes. Esto permitirá administrar los pines de acuerdo al
proyecto que estemos realizando.
1 /**
2 GeekFactory - "INNOVATING TOGETHER"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5
6 SKETCH PARA MEDIR TEMPERATURA CON TERMOPAR Y MAX6675. MUESTRA EL
7 RESULTADO
8 DE LA MEDICION EN EL MONITOR SERIAL DE ARDUINO. ESTE EJEMPLO USA LA LIBRERIA
9 PARA EL MAX6675 DE ADAFRUIT.
10 */
11 #include "max6675.h"
12
13 // CONFIGURACION DE LOS PINES UTILIZADOS PARA LA COMUNICACIÓN CON EL MAX6675
14 #define CONFIG_TCGND_PIN 8
15 #define CONFIG_TCVCC_PIN 9
16 #define CONFIG_TCSCK_PIN 10
17 #define CONFIG_TCCS_PIN 11
18 #define CONFIG_TCDO_PIN 12
19
20 // OBJETO UTILIZADO PARA LA COMUNICACION CON EL MAX6675
21 MAX6675 thermocouple(CONFIG_TCSCK_PIN, CONFIG_TCCS_PIN, CONFIG_TCDO_PIN);
22
23 void setup() {
24 // PREPARAR LA INTERFAZ SERIAL
25 Serial.begin(9600);
26
27 // USAR PINES DE ARDUINO PARA ALIMENTAR EL MODULO MAX6675
28 pinMode(CONFIG_TCVCC_PIN, OUTPUT); digitalWrite(CONFIG_TCVCC_PIN, HIGH);
29 pinMode(CONFIG_TCGND_PIN, OUTPUT); digitalWrite(CONFIG_TCGND_PIN, LOW);
30
31 // IMPRIMR MENSAJE INICIAL A LA TERMINAL
32 Serial.println(F("----------------------------------------------------"));
33 Serial.println(F(" TUTORIAL TERMOPAR CON ARDUINO Y MAX6675 "));
34 Serial.println(F(" http://www.geekfactory.mx "));
35 Serial.println(F("----------------------------------------------------"));
36
37 // ESPERAR A QUE SE ESTABILICE LA ENERGIA
38 delay(500);
39 }
40
41 void loop() {
42 // IMPRIMIR LA TEMPERATURA EN LA TERMINAL SERIAL
43 Serial.print("C = ");
44 Serial.println(thermocouple.readCelsius());
45
46 // ESPERAR UN SEGUNDO ENTRE LAS LECTURAS
47 delay(1000);
}
Termopar con Arduino y pantalla LCD.

El código a continuación permite realizar un termómetro con pantalla LCD
utilizando un termopar como sensor. Por si mismo este programa puede ser muy
útil para visualizar la temperatura de algún proceso comercial o industrial.
1 /**
5
6 SKETCH PARA MEDIR TEMPERATURA CON TERMOPAR Y MAX6675. MUESTRA EL
7 RESULTADO
8 DE LA MEDICION EN EL MONITOR SERIAL DE ARDUINO Y ADEMÁS LO DESPLIEGA EN UNA
9 PANTALLA LCD DE 16X2.
10
11 ESTE EJEMPLO USA LA LIBRERIA PARA EL MAX6675 DE ADAFRUIT.
12 */
13 #include "LiquidCrystal.h"
14 #include "max6675.h"
15
16 // CONFIGURACION DE LOS PINES UTILIZADOS PARA LA COMUNICACIÓN CON EL MAX6675
17 #define CONFIG_TCGND_PIN 8 // ALIMENTACION GND
18 #define CONFIG_TCVCC_PIN 9 // ALIMENTACION VCC
19 #define CONFIG_TCSCK_PIN 10 // SPI SCK
20 #define CONFIG_TCCS_PIN 11 // SPI CS
21 #define CONFIG_TCDO_PIN 12 // SPI MISO
22
23 // CONSTRUCTOR PARA LA PANTALLA LCD 16X2
24 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA
25 LiquidCrystal lcd(7, 6, 5, 4, 3, 2);
26 // OBJETO UTILIZADO PARA LA COMUNICACION CON EL MAX6675
27 MAX6675 thermocouple(CONFIG_TCSCK_PIN, CONFIG_TCCS_PIN, CONFIG_TCDO_PIN);
28
29 void setup() {
30 // PREPARAR LA INTERFAZ SERIAL
32
33 // IMPRIMR MENSAJE INICIAL A LA TERMINAL
34 Serial.println(F("----------------------------------------------------"));
35 Serial.println(F(" TUTORIAL TERMOPAR CON ARDUINO Y MAX6675 "));
37 Serial.println(F("----------------------------------------------------"));
38
39 // USAR PINES DE ARDUINO PARA ALIMENTAR EL MODULO MAX6675
40 pinMode(CONFIG_TCVCC_PIN, OUTPUT); digitalWrite(CONFIG_TCVCC_PIN, HIGH);
41 pinMode(CONFIG_TCGND_PIN, OUTPUT); digitalWrite(CONFIG_TCGND_PIN, LOW);
42
43 // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2
44 // IMPRIMIR MENSAJE INICIAL EN PANTALLA
45 lcd.begin(16, 2);
46 lcd.clear();
47 lcd.print(F("TERMOPAR ARDUINO"));
48 lcd.setCursor( 0, 1 );
49 lcd.print(F(" CON MAX6675 "));
50
51 // ESPERAR UN SEGUNDO
52 delay(1000);
53 }
54
55 void loop() {
56 // LEER EL TERMOPAR Y ALMACENAR EL VALOR EN UNA VARIABLE
57 double t = thermocouple.readCelsius();
58
59 // PRIMERO LIMPIAMOS LA PANTALLA Y LUEGO IMPRIMIMOS LA TEMPERATURA
60 lcd.clear();
61 lcd.print(F("->TEMPERATURA<-"));
62 lcd.setCursor( 3, 1 );
63 lcd.print(t);
64
65 // IMPRIMIR LA TEMPERATURA EN LA TERMINAL SERIAL
66 Serial.print("C = ");
67 Serial.println(t);
68
69 // ESPERAR UN SEGUNDO ENTRE LAS LECTURAS
70 delay(1000);
}
Termómetro arduino con termopar y alarma de

temperatura
Finalmente en este ultimo programa agregamos la funcionalidad de alarma por
sobre temperatura o baja temperatura.
Conclusión y resumen
 Aprendimos a conectar un termopar con Arduino utilizando un módulo con el
MAX6675.
 En este tutorial aprendimos las aplicaciones de los termopares y sus ventajas
sobre otras tecnologías de sensado de temperatura.
 Instalamos la librería adecuada para usar el convertidor de termopar digital
MAX6675.
 Aprendimos a enviar la lectura del tremolar al monitor serial.
 Mostramos la lectura del termopar en una pantalla LCD de 16×2.
 Aprendimos a realizar una alarma por alta o baja temperatura usando un termopar.
 Con lo estudiado en esta página podemos realizar otros proyectos más
ambiciosos como controles de temperatura y registradores de datos.
Botón o pulsador con Arduino: Todo lo que

debes saber
by Admin | Jun 25, 2018 | Tutoriales Arduino | 0 comments
Casi cualquier aparato electrónico hoy en día incluye una tecla, botón, pulsador o
switch. Los proyectos con arduino no son la excepción y virtualmente cualquier
idea que desarrollemos dispondrá de al menos un par de botones.
En este tutorial hablaremos sobre como se puede conectar un botón al
arduino y como podemos hacer para procesar correctamente las señales que
envían. Además veremos como realizar aplicaciones más avanzadas con
botones, por ejemplo: como detectar pulsaciones largas, doble o triple clic,
etc.
Materiales necesarios para las prácticas
Para completar los ejercicios propuestos en esta página recomendamos adquirir
los siguiente materiales:
 Arduino Uno R3 o compatible
 Protoboard
 Resistencias de 10 K ohms
 Botones pulsadores o push-buttons
Utilizaremos el led en el pin 13 del arduino para realizar las prácticas sin la
necesidad de conectar leds externos.
¿Cómo conectar un botón a arduino?

Para conectar un botón al arduino conviene tener en mente ciertos puntos:
 Un botón puede conectarse a cualquier pin de arduino (digital o analógico, ya que
los analógicos usualmente funcionan también como digitales).
 Existen dos configuraciones posibles: con resistencia pull-up o resistencia
pull-down.
 Configuraremos el pin seleccionado como entrada digital.
 Debemos tomar en cuenta los rebotes y el ruido eléctrico en el software.
 Es necesario utilizar una resistencia pull-up o pull-down, ya sea interna o externa.
Las dos formas que existen para conectar un botón al arduino se visualizan en los
siguientes diagramas:
Botón con resistencia pull-up Botón con resistencia pull-down

Visto en el protoboard quedaría como se muestra más abajo, siendo el botón
colocado del lado izquierdo del protoboard el que está conectado con pull-
up, mientras que el derecho esta conectado con una resistencia pull-down.
El valor de las resistencias en este caso no es crítico, pero debemos
considerar que valores menores causarán que circule una corriente mayor cuando
se oprime el botón, mientras que los valores mayores pueden permitir que el ruido
se introduzca al pin de entrada.
Los valores típicos para resistencia pull-up o pull-down son de 1 a 10
KOhms.
¿Para que sirve una resistencia pull-up o pull-

down?
La función primordial de las resistencias en el circuito del botón es mantener un
estado lógico conocido cuando el botón no está siendo accionado.
Esto es necesario ya que las entradas del microcontrolador, si se dejan al aire, no
poseen un estado determinado y pueden ir a cualquiera de dos estados posibles
de forma aleatoria. Según la necesidad, se pueden colocar las resistencias en
pines de entrada, obteniendo los siguientes efectos:
 La resistencia pull-up mantiene un estado alto en el pin mientras el pulsador no
es accionado, el estado activo del botón es BAJO (cuando se presiona).
 La resistencia pull-down mantiene un estado bajo mientras el pulsador no es
accionado, el estado activo del botón es ALTO (cuando se presiona).
El microcontrolador AVR incluido en el arduino UNO, posee en cada pin de
entrada una resistencia pull-up que se puede activar bajo control de nuestro
programa, evitándonos tener que colocar de forma externa este
componente. Sin embargo, no todos los microcontroladores poseen esta
característica y por esta razón es común encontrar este componente colocado de
forma externa en la mayoría de los circuitos.
Armado del circuito para las prácticas con botón o

pulsador
El circuito que armaremos en el protoboard para la realización de las prácticas que
se proponen a continuación es el siguiente:
Aprovecharemos el led que viene conectado por defecto en el pin 13 del arduino y
por esta razón no necesitamos otro aditamento como dispositivo de
salida. Estaremos utilizando ambos botones con resistencia pull-up externa.
Realizar la programación del botón o pulsador con

arduino
El siguiente ejemplo muestra como encender un led con un pulsador y apagar con
otro botón. Es un ejemplo muy sencillo pero que ilustra muy bien el uso de las
funciones pinMode() y digitalRead(). Como en la mayoría de nuestros
programas, hemos procurado comentar bastante para hacer que el código sea
fácil de entender.
En este programa hemos leído el estado de los pines a variables intermedias, ya
que lo usamos dentro de los cursos para que los estudiantes se familiaricen con el
uso de las variables, pero puede saltarse este paso y colocar directamente la
función digitalRead() dentro de las condiciones.
1 /**
5
6 EJEMPLO DE ENTRADAS DIGITALES 2
7
8 EJEMPLO ON/OFF LED CON 2 BOTONES, EN ESTE EJEMPLO SE ENCIENDE EL LED
9 CON UN BOTON Y SE APAGA CON OTRO BOTON DISTINTO, EL LED PERMANECE EN
10 EL ESTADO CORRESPONDIENTE AL ULTIMO BOTON ENCENDIDO.
11 */
12
13 // ASIGNACION DE PINES
14 const int pinon = 2;
15 const int pinoff = 3;
16 const int pinled = 13;
17
18 // VARIABLES DE ESTADO DE BOTONES
19 int estaon = HIGH;
20 int estaoff = HIGH;
21
22 void setup() {
23 // CONFIGURAR PINES COMO ENTRADAS
24 pinMode(pinon, INPUT);
25 pinMode(pinoff, INPUT);
26 // CONFIGURAR PIN DE LED COMO SALIDA
27 pinMode(pinled, OUTPUT);
28 }
29
30 void loop() {
31 // LEER EL ESTADO DE PINES DE BOTON A VARIABLES
32 estaon = digitalRead(pinon);
33 estaoff = digitalRead(pinoff);
34
35 // SE OPRIMIO EL BOTON DE ENCENDIDO?
36 if (estaon == LOW) {
37 // ENTONCES ENCENDEMOS EL LED
38 digitalWrite(pinled, HIGH);
39 }
40
41 // SE OPRIMIO EL BOTON DE APAGADO?
42 if (estaoff == LOW) {
43 // ENTONCES APAGAMOS EL LED
44 digitalWrite(pinled, LOW);
45 }
46 }
Eliminar rebotes y el ruido de un botón en arduino

El ruido eléctrico y el fenómeno conocido como rebote, son problemas que
debemos tomar en cuenta al procesar la señal proveniente de un botón.
El fenómeno del rebote se da debido a las imperfecciones que existen en los
contactos internos del pulsador. El problema es especialmente notorio cuando se
atiende un botón mediante interrupciones, ya que el microcontrolador verá varios
cambios de estado antes de que la señal se estabilice y tengamos un estado
lógico definido en el pin de entrada.
La siguiente imagen nos muestra como se ve la señal típica proveniente de
un pulsador.
El ruido eléctrico es otro de los problemas que debemos considerar al

incorporar botones en nuestros proyectos. Una chispa en la cercanía de
nuestro circuito, ruido en la red eléctrica, rayos, descargas electrostáticas o la
manipulación directa del circuito electrónico (PCB) pueden causar que nuestro
microcontrolador “vea” un estado activo en el pin de entrada por algunos instantes
y realice la acción asignada a un botón, es decir, se pueden realizar activaciones
falsas del botón debidas a perturbaciones externas.
Debido a la situación explicada anteriormente, es necesario elaborar el software
para que funcione a pesar de las imperfecciones en la señal de entrada. El
algoritmo más sencillo que hemos probado es el siguiente:
1. Leer continuamente el estado del pin y detectar el flanco (descendente o
ascendente) que indica que se ha pulsado un botón
2. Esperar un tiempo prudente (alrededor de 10 a 100 mili segundos) hasta que se
estabilice la señal
3. Leer nuevamente el estado del pin y comprobar que se encuentre en el estado
deseado
4. Ejecutar la acción asignada al botón, una vez que nos aseguramos que
efectivamente fue presionado.
Este algoritmo garantiza principalmente dos cosas:
 Elimina las falsas activaciones del botón por ruido eléctrico
 Se encarga de cualquier efecto de los rebotes.
Básicamente lo que hacemos es “muestrear” en dos momentos distintos la
señal del botón y garantizar que el estado lógico que buscamos esta
presente. Vamos ahora a mejorar un poco el programa anterior, incluyendo este
algoritmo para la eliminación de rebotes y ruido eléctrico.
Programación de botón con eliminación de rebotes

y ruido eléctrico
La siguiente programación es una mejora del ejercicio anterior en la cual se
mejora la resistencia a ruido eléctrico, aplicando el algoritmo descrito en la sección
anterior.
1 /**
5
6 EJEMPLO DE ENTRADAS DIGITALES 5
7
8 EJEMPLO ON/OFF LED CON 2 BOTONES, EN ESTE EJEMPLO SE ENCIENDE EL LED
9 CON UN BOTON Y SE APAGA CON OTRO BOTON DISTINTO, EL LED PERMANECE EN
10 EL ESTADO CORRESPONDIENTE AL ULTIMO BOTON ACTIVADO.
11
12 ADICIONALMENTE EN ESTE EJEMPLO PROPONEMOS UNA DOBLE COMPROBACIÓN PARA
13 EVITAR QUE EL RUIDO ELÉCTRICO INTERFIERA EN NUESTRO CIRCUITO. DE ESTA
14 MANERA ES MUCHO MÁS SERGURO DE USAR EN APLICACIONES REALES.
15 */
16
17 // ASIGNACION DE PINES
18 const int pinon = 2;
19 const int pinoff = 3;
21
22 // VARIABLES DE ESTADO DE BOTONES
23 int estaon = HIGH;
24 int estaoff = HIGH;
25
26 void setup() {
27 // CONFIGURAR PINES COMO ENTRADAS
28 pinMode(pinon, INPUT);
29 pinMode(pinoff, INPUT);
30 // CONFIGURAR PIN DE LED COMO SALIDA
31 pinMode(pinled, OUTPUT);
32 }
33
34 void loop() {
35 // LEER EL ESTADO DE PINES DE BOTON A VARIABLES
36 estaon = digitalRead(pinon);
37 estaoff = digitalRead(pinoff);
38
39 // SE OPRIMIO EL BOTON DE ENCENDIDO?
40 // HACEMOS DOBLE COMPROBACION DEL ESTADO DEL BOTÓN
41 if (estaon == LOW) {
42 // ESPERAMOS ANTES DE COMPROBAR NUEVAMENTE
43 delay(50);
44 if (estaon == LOW ) {
45 // ENTONCES ENCENDEMOS EL LED
46 digitalWrite(pinled, HIGH);
47 }
48 }
49
50 // SE OPRIMIO EL BOTON DE APAGADO?
51 // HACEMOS DOBLE COMPROBACION DEL ESTADO DEL BOTÓN
53 // ESPERAMOS ANTES DE COMPROBAR NUEVAMENTE
54 delay(50);
56 // ENTONCES APAGAMOS EL LED
57 digitalWrite(pinled, LOW);
58 }
59 }
60 }
Programación avanzada de botones con arduino

usando una librería
Para los ejemplos siguientes estaremos utilizando la librería GFButton que
debe instalarse en nuestro IDE para poder compilar los ejemplos.
Realizaremos el ejercicio de prender un led con un botón y apagarlo con
otro, pero ahora utilizaremos la librería para apoyarnos. Como podemos ver,
hemos movido algo del código a la librería, quedando nuestro programa mucho
más compacto.
Aprovechando que se simplifica el programa, podemos incluir sentencias para
enviar datos al monitor serial y saber que está pasando en cada momento.
1 /**
5
6 Basic example for the GFButton library. This example shows the basic library usage with
7 the polling (synchronous) API. This is the easiest and more intuitive way to use the library.
8 */
9
10 #include "GFButton.h"
11
12 // Create two button instances on pins 2 & 3
13 GFButton buttonOn(2);
14 GFButton buttonOff(3);
15
16 /**
17 PROGRAM INITIALIZATION
18 */
19 void setup() {
20 // Prepare serial interface
22
23 // Show dialog to serial monitor
24 Serial.println(F("----------------------------------------------------"));
25 Serial.println(F(" GFBUTTON LIBRARY TEST PROGRAM "));
27 Serial.println(F("----------------------------------------------------"));
28 }
29
30 /**
31 MAIN PROGRAM LOOP
32 */
33 void loop() {
34 // Check if "on" button is pressed
35 if (buttonOn.isPressed()) {
36 Serial.println(F("On button is pressed"));
37 // Turn on the led
38 digitalWrite(13, HIGH);
39 }
40
41 // Check if "off" button is pressed
42 if (buttonOff.wasPressed()) {
43 Serial.println(F("Off button was pressed"));
44 // Turn off the led
45 digitalWrite(13, LOW);
46 }
47 }
Detección de pulsaciones largas en un botón

usando una librería
En este ejemplo vamos a aprender a detectar el tiempo que dura oprimido un
botón, con esto podemos realizar acciones solamente si el botón permanece
oprimido durante mas del tiempo programado.
En nuestro ejemplo a continuación, vamos a realizar la programación de dos
botones: Uno encenderá un led si se mantiene oprimido más de 5 segundos
y el otro apagará el led si se mantiene oprimido más de 5
segundos. Cualquier otra acción en los botones NO tendrá efecto en el estado de
los leds.
1 /**
5
6 EJEMPLO PARA EL USO AVANZADO DE BOTONES. EN ESTE EJEMPLO DETECTAMOS
7 CUANDO
8 SE HA DEJADO OPRIMIDO UN BOTON POR MAS DE 5 SEGUNDOS (EL TIEMPO PUEDE SER
9 CONFIGURADO)
10 Y SOLAMENTE ACTUA EN CASO DE QUE SE DETECTE ESTA CONDICION.
11
12 ESTE EJEMPLO ESTÁ BASADO EN LA LIBRERÍA GFBUTTON DESARROLLADA POR GEEK
13 FACTORY.
14 */
16
17 // CREAR INSTANCIAS DE LOS BOTONES EN LOS PINES 2 Y 3
18 // SE PUEDE UTILIZAR CUALQUIER PIN DEL ARDUINO PARA LOS BOTONES
19 // YA QUE LA LIBRERIA NO DEPENDE DE INTERRUPCIONES
20 GFButton btn1 = GFButton(2);
22
23 void setup() {
24 // PREPARAR COMUNICACION SERIAL
26
27 // CONFIGURAR PIN DE SALIDA
28 pinMode(13, OUTPUT);
29
30 // CONFIGURAR MANEJADORES DE EVENTOS (FUNCIONES CALLBACK)
31 btn1.setHoldHandler(button1_on_hold);
32 btn2.setHoldHandler(button2_on_hold);
33
34 // CONFIGURAR TEMPORIZADOR DE REBOTES EN 100 MILISEGUNDOS
35 btn1.setDebounceTime(100);
37
38 // MOSTRAR DIALOGO INICIAL EN EL MONITOR SERIAL
39 Serial.println(F("----------------------------------------------------"));
40 Serial.println(F(" PROGRAMACION DE BOTONES CON LIBRERIA GFBUTTON "));
42 Serial.println(F("----------------------------------------------------"));
43 }
44
45 void loop() {
46 // SIEMPRE DEBEMOS LLAMAR AL METODO PROCESS DE CADA INSTANCIA
47 btn1.process();
48 btn2.process();
49
50 // PODEMOS REALIZAR OTRAS TAREAS DENTRO DEL CICLO PRINCIPAL
51 }
52
53 // MANEJADOR DE EVENTOS DEL BOTON DE ENCENDIDO
54 void button1_on_hold(GFButton & button)
55 {
56 // EL EVENTO SE DISPARARA VARIAS VECES, ACTUAREMOS DISTINTO LA PRIMERA VEZ
57 // EL METODO ISFIRSTHOLD() DETERMINA SI ES LA PRIMERA VEZ QUE SE LLAMA AL
58 MANEJADOR DE EVENTOS
59 if (button.isFirstHold())
60 {
61 // PODEMOS OBTENER LA CANTIDAD DE TIEMPO QUE SE HA MANTENIDO PRESIONADO EL
62 BOTON
63 // ESTA CANTIDAD ESTA EXPRESADA EN MILISEGUNDOS
64 Serial.print(F("BOTON OPRIMIDO DURANTE "));
65 Serial.print(button.getHoldTime() / 1000);
66 Serial.println(F(" SEGUNDOS."));
67 // ENDENDER EL LED
68 Serial.println(F("ENCENDER LED"));
70 } else {
71 // IMPRIMIMOS PUNTOS MIENTRAS EL BOTON ESTE OPRIMIDO
72 Serial.print('.');
73 }
74 }
75
76 // MANEJADOR DE EVENTOS DEL BOTON DE APAGADO
77 void button2_on_hold(GFButton & button)
78 {
79 // EL EVENTO SE DISPARARA VARIAS VECES, ACTUAREMOS DISTINTO LA PRIMERA VEZ
80 // EL METODO ISFIRSTHOLD() DETERMINA SI ES LA PRIMERA VEZ QUE SE LLAMA AL
81 MANEJADOR DE EVENTOS
82 if (button.isFirstHold())
83 {
84 // PODEMOS OBTENER LA CANTIDAD DE TIEMPO QUE SE HA MANTENIDO PRESIONADO EL
85 BOTON
86 // ESTA CANTIDAD ESTA EXPRESADA EN MILISEGUNDOS
87 Serial.print(F("BOTON OPRIMIDO DURANTE "));
88 Serial.print(button.getHoldTime() / 1000);
89 Serial.println(F(" SEGUNDOS."));
90 // APAGAR EL LED
Serial.println(F("APAGAR LED"));
digitalWrite(13, LOW);
} else {
// IMPRIMIMOS PUNTOS MIENTRAS EL BOTON ESTE OPRIMIDO
Serial.print('.');
}
}
Detección de doble y triple clic en un botón usando

una librería
En algunas situaciones, puede ser necesario detectar cuando el usuario hace
doble o triple clic en un botón. En este caso podemos hacer uso de las
funcionalidades de programación mediante eventos que provee nuestra librería.
El siguiente ejemplo demuestra como hacer que se puedan encender o
apagar un par de leds dando doble clic en el botón asociado a cada led. El
programa ignorará las pulsaciones sencillas y solamente actuará cuando se
oprima 2 veces seguidas el mismo botón en menos de un segundo.
1 /**
5
6 EJEMPLO PARA EL USO AVANZADO DE BOTONES. EN ESTE EJEMPLO DETECTAMOS
7 CUANDO
8 SE HA DADO "DOBLE CLICK" EN UN BOTÓN Y SOLAMENTE SE REALIZA ALGUNA ACCIÓN
9 CUANDO SE DETECTA ESTA CONDICIÓN.
10
11 ESTE EJEMPLO ESTÁ BASADO EN LA LIBRERÍA GFBUTTON DESARROLLADA POR GEEK
12 FACTORY.
13 */
15
16 // CREAR INSTANCIAS DE LOS BOTONES EN LOS PINES 2 Y 3
17 // SE PUEDE UTILIZAR CUALQUIER PIN DEL ARDUINO PARA LOS BOTONES
18 // YA QUE LA LIBRERIA NO DEPENDE DE INTERRUPCIONES
21
22 void setup() {
23 // PREPARAR COMUNICACION SERIAL
25
26 // CONFIGURAR PIN DE SALIDA
28
29 // CONFIGURAR MANEJADORES DE EVENTOS (FUNCIONES CALLBACK)
30 btn1.setClicksHandler(button1_on_click);
31 btn2.setClicksHandler(button2_on_click);
32
33 // CONFIGURAR TEMPORIZADOR DE REBOTES EN 100 MILISEGUNDOS
36
37 // MOSTRAR DIALOGO INICIAL EN EL MONITOR SERIAL
38 Serial.println(F("----------------------------------------------------"));
39 Serial.println(F(" PROGRAMACION DE BOTONES CON LIBRERIA GFBUTTON "));
41 Serial.println(F("----------------------------------------------------"));
42 }
43
44 void loop() {
45 // SIEMPRE DEBEMOS LLAMAR AL METODO PROCESS DE CADA INSTANCIA
46 btn1.process();
47 btn2.process();
48
49 // PODEMOS REALIZAR OTRAS TAREAS DENTRO DEL CICLO PRINCIPAL
50 }
51
52 // MANEJADOR DE EVENTOS DEL BOTON DE ENCENDIDO
53 void button1_on_click(GFButton & button)
54 {
55 Serial.print(F("DETECTADOS VARIOS CLICKS EN 1 SEGUNDO: "));
56 Serial.println(button.getClicks());
57 // ENCENDER LED AL DETECTAR DOBLE CLICK
58 if (button.getClicks() >= 2) {
59 Serial.println(F("ENCENDER LED"));
61 }
62 }
63
64 // MANEJADOR DE EVENTOS DEL BOTON DE APAGADO
65 void button2_on_click(GFButton & button)
66 {
67 Serial.print(F("DETECTADOS VARIOS CLICKS EN 1 SEGUNDO: "));
68 Serial.println(button.getClicks());
69 // APAGAR EL LED AL DETECTAR DOBLE CLICK
70 if (button.getClicks() >= 2) {
71 Serial.println(F("APAGAR LED"));
72 digitalWrite(13, LOW);
}
}
Alimentar el Arduino: La guía definitiva

by Admin | Sep 28, 2017 | Tutoriales Arduino | 4 comments
En este artículo vamos a tratar un tema fundamental para aplicar las tarjetas
arduino en el mundo real: cómo podemos alimentar el Arduino una vez que
este se desconecta del puerto USB. Vamos a discutir las opciones disponibles y
a brindar consejos útiles al respecto adentrándonos en los detalles del hardware.
La forma más sencilla de alimentar el arduino UNO es a través del puerto USB.
Sin embargo una vez que deseamos colocar nuestra tarjeta arduino en su
aplicación final, el puerto USB puede no ser la forma más óptima de alimentarla.
Desafortunadamente la falta de conocimiento o experiencia en el tema de
alimentación puede llevar a errores. Errores que a su vez pueden terminar en un
funcionamiento inadecuado o la destrucción del microcontrolador y/o la tarjeta
completa. El objetivo de este artículo es brindar una guía que nos ayude a
evitar dichos errores.
Queremos aclarar en esta introducción que estaremos tratando principalmente
con las tarjetas que funcionan a 5 volts (mega, uno, duemilanove, leonardo,
etc) y que vamos a referirnos a estas en conjunto como “la tarjeta arduino”, ya que
todas comparten un diseño similar en cuanto a sus circuitos de alimentación.
Mecanismos de alimentación para el arduino

Las placas arduino más populares son muy versátiles y admiten varias formas
para ser alimentadas. En este apartado vamos a ver en detalle cada una de las
opciones que tenemos para darle poder a nuestra tarjeta. La siguiente imagen
resume los mecanismos que podemos utilizar para alimentar el Arduino UNO.
Alimentar el arduino mediante USB
Como ya mencionamos, es la forma más sencilla de alimentar el arduino. A través

de esta entrada se admiten ÚNICAMENTE 5 volts.
Podemos obtener los 5 volts del puerto USB de nuestra PC y/o de cualquier otro
dispositivo compatible con USB (como un televisor con puerto USB, por ejemplo),
de un adaptador de teléfono móvil con salida a USB o a través de uno de los
“cargadores de emergencia” disponibles también para teléfonos móviles.
El puerto USB cuenta con un fusible PPTC que limita la corriente que el
arduino (y sus accesorios) pueden demandar del puerto USB. La corriente máxima
entonces queda limitada a unos 500 mA. Usualmente no podemos cometer
errores de polaridad ni de voltaje cuando usamos USB para alimentar.
Resumen: Podemos alimentar el arduino a través del conector USB cuando se utilizan cargas
pequeñas y no se requieran voltajes mayores a 5 volts. En este caso no debemos
preocuparnos de la polaridad / voltaje, ya que es estándar en todos los dispositivos USB.
El jack de alimentación externa del arduino
La tarjeta arduino viene diseñada para aceptar alimentación mediante el jack

estándar que se encuentra en muchos equipos electrónicos. Normalmente se
utiliza un adaptador de corriente (AC/DC), o como los conocemos en México
popularmente “un eliminador”.
Al tratarse de una entrada de corriente directa, la conexión del eliminador tiene
una polaridad que debe ser respetada: el polo positivo debe ir al centro del
conector. El voltaje adecuado a usar en esta entrada es de 7 a 12 volts DC.
Voltajes menores (5 a 7 volts) en esta entrada pueden causar que el regulador
interno del arduino no pueda trabajar correctamente. Voltajes mayores a 12
pueden causar el rápido sobrecalentamiento del regulador, aunque la cantidad de
accesorios conectados (la demanda de corriente) no sea grande.
Esta entrada tiene un diodo de protección para inversión de polaridad, por lo que
si no se respeta la polaridad, no ocurrirán daños, pero la tarjeta arduino NO
funcionará.
Cuidado con el tipo de adaptador (eliminador)
Uno de los errores más frecuentes puede ser el reciclar cualquier fuente de poder
de nuestra caja de “sobras electrónicas” y tratar todas las fuentes de poder como
si fueran idénticas y aptas para usarse con arduino.
La fuente preferida debe ser de 12 volts 1 ampere con salida de corriente
directa (DC). El problema es que algunas fuentes antiguas pueden tener una
salida de corriente alterna y no son aptas para usarse con arduino, tal como
se muestra en la siguiente imagen comparativa.
La fuente de alimentación a la izquierda es una fuente de poder con salida de 12 VDC, mientras que a la
derecha se muestra una fuente con salida de 12 VAC.
Limitantes del regulador de voltaje (sobrecalientamiento del

arduino)
Un problema común que podemos encontrar al alimentar el arduino a través del
jack de alimentación externa es que el regulador integrado en la placa puede
sobrecalentarse.
Para entender por que sucede esto, debemos comprender como funciona el
regulador de voltaje NCP1117ST50T3G que se presenta en encapsulado SOT-
223 en las tarjetas arduino. Este circuito integrado es un regulador de voltaje
lineal, es decir, un regulador que varía su resistencia eléctrica interna para
mantener un voltaje de salida constante en la salida.
Al comportarse este como una resistencia eléctrica, tiende a calentarse de
forma proporcional a la corriente y al diferencial de voltaje entre su salida y
entrada. Por lo tanto, si incrementamos la diferencia entre el voltaje de entrada y
el de salida, la potencia disipada en el regulador aumentará.
Hemos hecho algunos cálculos básicos y te mostramos a continuación la corriente
máxima recomendada para distintos voltajes de entrada, asumiendo que
permitiremos una disipación de 2 Watts en el regulador:
 Alimentación a 12 Volts: I = 2 / (12-5) = 2 / 7 = 285mA
 Alimentación a 9 Volts: I = 2 / (9-5) = 2/4 = 500mA
 Alimentación a 7 Volts: I = 2 / (7-5) = 2/2 = 1A
Como podemos ver, mientras más alto es el voltaje de entrada, menor es la
corriente que podemos obtener del regulador sin que este se caliente. Para
trabajar en el punto más óptimo, se requiere un adaptador AC/DC de 7 volts.
Resumen: El jack de alimentación es la forma más segura de alimentar el arduino además del
USB, sin embargo debemos tomar en cuenta la potencia eléctrica que disipará el regulador de
la tarjeta arduino. El rango de voltaje es de 7 a 12 volts y recomendamos mantener el
regulador trabajando con una corriente apropiada según el voltaje de entrada (ver texto
arriba).
Alimentar el Arduino a través del pin VIN
El pin VIN, que se localiza en el grupo de pines de alimentación y tierras cumple

con una doble función:
 Permite aplicar una fuente de alimentación externa en el rango de 12 a 6
volts DIRECTAMENTE a la entrada del regulador de la tarjeta Arduino. En este caso, NO
se cuenta con protección contra inversión de polaridad ni contra sobre corriente. En caso
de aplicar voltaje directamente al pin VIN, no se debe aplicar simultáneamente un voltaje
en el jack.
 Funciona como salida de voltaje cuando el arduino se está alimentando a través del
jack de alimentación. En este caso el voltaje presente en VIN será aquel que estemos
aplicando en el jack, restando la caída de tensión en el diodo de protección de inversión
de polaridad (alrededor de 0.7 volts). No se recomienda conectar cargas mayores a 1000
mA en este pin, ya que podemos dañar el diodo de protección.
En ambos casos el polo negativo de la alimentación estará conectado a cualquiera
de los pines etiquetados como GND. La conexión de un porta pilas de 6 celdas
AA quedaría como se observa en la siguiente fotografía:
Resumen: Podemos utilizar el pin VIN para alimentar el arduino con fuentes no reguladas de
corriente directa o un conjunto de baterías AA o AAA (4 a 6 pilas). La alimentación con
baterías es recomendable a través de este pin cuando nuestras baterías proporcionan 6 volts,
ya que no hay diodo de protección que cause caidas de tensión adicionales
Alimentar el Arduino a través del pin 5V
De igual forma que VIN, el pin de 5 volts se puede usar de dos formas:
 Este pin funciona como una salida de 5 volts para otros circuitos. El pin de 5 volts se
conecta directamente a la salida del regulador en la placa. Cuando alimentamos el
arduino a través de USB o el jack de alimentación, la salida de 5 volts del regulador o
USB está presente en este pin.
 Podemos utilizar el pin de 5 volts para alimentar directamente el arduino con una
fuente de poder estabilizada y regulada a 5 volts cuando no hay un cable USB
conectado o un adaptador de corriente conectado al jack.
Resumen: Al alimentar el arduino a través del pin 5V no tenemos protección contra
inversiones de polaridad, sobre voltaje o corto circuito, pues todos los mecanismos de
protección en la placa se encuentran antes llegar a este punto del circuito. Solo se debe usar
este método de alimentación si planeamos tener una fuente de salida fija (5V) y una
conexión permanente con el arduino (para evitar errores).
Alimentación de arduino con baterías

Otra posible necesidad es alimentar el arduino con baterías. En este apartado
hay que considerar el voltaje de operación de la placa arduino y el tiempo de
operación que requerimos, para elegir el tipo de batería adecuado según la
aplicación. Los siguientes son algunos tipos de baterías comunes:
Arreglos de batería en serie y paralelo
En algunos casos puede ser necesario aumentar el voltaje de operación o la
capacidad total de batería, por esto es importante conocer el funcionamiento de
los arreglos en serie y paralelo de baterías.
En caso de requerir aumentar la capacidad de las baterías, se puede utilizar un
arreglo de baterías conectadas en paralelo, es decir, conectando los positivos de
las baterías todos juntos, como se muestra en la imagen:
En caso de que se requiera obtener un voltaje mayor, se pueden utilizar baterías

conectadas en serie. Por ejemplo, para obtener voltaje para alimentar un
arduino UNO se pueden utilizar 5 baterías de 1.2 volts recargables.
Ejemplos para alimentar el arduino UNO con baterías
 Podemos utilizar una batería de plomo – acido a 12 volts y alimentar el arduino a través
del jack de alimentación externa. Para alimentar nuestra tarjeta de esta manera, es
aconsejable realizar un cable especial con el plug invertido soldado en un extremos y
terminales adecuadas según la batería.
 Utilizando una arreglo de 5 o 6 baterías recargables AA NiMH o un arreglo de 4 baterías
alcalinas podemos alimentar el arduino a través del pin VIN
 Podemos utilizar una pila cuadrada de 9 volts con un plug invertido para alimentar el
arduino a través del jack de alimentación externa. Aunque este método no es eficiente
y debemos esperar una vida no muy larga de la pila.
 Podemos usar un arreglo de baterías de Polímero de Litio (lipo) de 7.4 volts (2 celdas en
serie) para alimentar nuestro arduino. Normalmente estos arreglos ya se venden hechos
como una sola unidad de alta capacidad.
Conclusión
 Aprendimos que la forma más simple de alimentar el arduino es a través del conector
USB.
 Conocimos las limitaciones del jack de alimentación externa, así como los casos en los
que se recomienda su uso.
 Ahora sabemos que el arduino se puede alimentar directamente a través del pin VIN con
baterías o con una fuente de poder (incluso sin regular) siempre que no se sobrepasen los
límites del regulador incluido en la placa.
 Sabemos que se pueden inyectar 5 volts directamente al arduino a través del pin
correspondiente
 Aprendimos sobre los arreglos de baterías en serie y paralelo y como se pueden usar
conjuntos de baterías para lograr el voltaje o capacidad necesarios en nuestra aplicación.
 Sentamos las bases para que el usuario sea capaz de elegir la fuente de energía que
mejor convenga para su proyecto
Termómetro con Arduino y DS18B20

by Admin | Ago 1, 2017 | Proyectos, Tutoriales Arduino | 0 comments
En este artículo te presentamos la construcción de un Termómetro con Arduino
y DS18B20. El termómetro tiene la capacidad de medir 4 zonas o canales
independientes. El proyecto está principalmente orientado para usarse en
un acuario (por eso proponemos el uso de sensores de temperatura a prueba de
agua), pero puede utilizarse en muchas otras situaciones donde es necesario
monitorear 4 sondas de temperatura. Por ejemplo, podemos utilizarlo para
medir la temperatura en distintas zonas dentro de nuestra PC (procesador,
fuente de alimentación, disco duro, etc.) lo que convierte a este proyecto en un
desarrollo muy versátil aplicable en muchas situaciones. El cerebro del proyecto
es un Arduino Nano que se encarga de gobernar toda la funcionalidad del equipo.
En la foto de portada observamos nuestro termómetro con arduino
nano elaborado dentro de un gabinete realizado en corte láser.
Materiales necesarios
Puedes adquirir la mayoría de los materiales requeridos en nuestra tienda virtual:
 Arduino Nano Genérico (con headers desoldados)
 Pantalla LCD de 16 x 2 (azul o verde)
 Adaptador para pantalla LCD a I2C
 Sensores de temperatura DS18B20 sumergibles
 Resistencias de 4.7 KOhms
 Módulo Convertidor DC-DC ajustable
 Cables Dupont Hembra-Hembra
 Cable o alambre para conexiones (podemos usar tramitos de los dupont)
 4 x Jacks de audio de 3.5 mm
 4 x Pugs de audio de 3.5 mm
 Jack de alimentación (jack para plug invertido)
 Gabinete plástico / madera
Construcción del Termómetro con Arduino y
DS18B20
Vamos a comenzar la construcción de nuestro termómetro con Arduino y
DS18B20. Recomendamos tener el cautín encendido y nuestro maletín de
herramientas a la mano. Comencemos…
1 – Soldamos los cables al convertidor DC-DC Buck para la entrada y salida de
voltaje. Es necesario soldar dos cables en cada polo de la salida, es decir, dos al
positivo y dos al negativo. Un par va al microcontrolador y otro a los sensores de
temperatura.
2 – Una vez soldados los cables, es necesario conectar los cables de entrada de
el módulo regulador de voltaje a una fuente de 12 volts y ajustar la salida de
voltaje a 5 volts (utilizamos el trimpot para lograr el ajuste). Muy importante este
paso, pues si se omite, se pueden quemar muy fácilmente los circuitos que
estaremos alimentando (arduino y sensores).
3 – Soldar el Jack de alimentación en los cables de entrada del módulo convertidor
DC-DC. En este jack conectaremos un eliminador de 9-12 volts para alimentar
nuestro termómetro digital con Arduino y DS18B20.
4 – Colocar los headers al Arduino Nano, los soldaremos del lado de componentes
como se muestra en la foto para poder pegar el arduino al interior del gabinete con
cinta doble cara o cinchos sujeta cables.
5 – Soldar un par de cables de alimentación hacia el arduino nano desde la fuente
de alimentación: Soldamos el negativo que viene desde el convertidor DC-DC a un
pin de GND y el positivo al pin 5Vin del arduino nano. Soldaremos por la parte
de atrás, ya que utilizaremos los headers macho para la alimentación de la
pantalla LCD.
6 – Instalar los 4 jacks de audio en su posición y soldar la alimentación a los
sensores (hacemos puentes entre todos los jacks) tanto para el polo positivo como
el negativo. La posición de cada señal la determinamos a nuestro gusto en
este paso. Colocamos la resistencia pull-up de 4.7K entre el pin de datos y el
voltaje positivo. Soldamos un tramo de dupont hembra en los pines de datos.
Preparar y conectar la pantalla LCD del
termómetro con arduino y DS18B20
7 – Soldar el adaptador I2C a la pantalla. Lo vamos a conectar con el arduino nano
a través de un par de cables Dupont hembra hembra. Esto nos ahorra muchos
pines y además el potenciómetro del contraste viene incluido en el módulo
adaptador I2C. Debe quedarnos similar a la siguiente foto:
8 – Conectar los pines SDA y SCL del adaptador de pantalla a los pines A4 y
A5 del Arduino (en ese orden) mediante cables Dupont Hembra-Hembra,
conectar el cable VCC al pin de 5V de arduino nano y el pin GND a GND del
nano.
9 – Conectar los pines de datos de los Jacks para conectar los sensores a los
pines D2, D3, D4 y D5 de arduino mediante cables dupont Hembra-Hembra:
10 – Colocar la electrónica dentro del gabinete que hayamos elegido apoyándonos
de cinta adhesiva de doble cara.
Programa para un Termómetro con Arduino y
DS18B20
El código a cargar en nuestro termómetro se muestra a continuación. Para que
compile correctamente es necesario tener instalada la librería de control del LCD a
través de I2C y la librería para comunicarse con sensores one-wire. Hemos
procurado comentar muy bien el código, de forma que sea entendible para todos.
1 /**
2 GeekFactory - "Construye tu propia tecnologia"
5
6 Firmware para el termometro multicanal de proposito general. Este sketch permite la lectura
7 de 4 sondas de temperatura a prueba de agua o normales con el DS18B20 y muestra la temperatura
8 en una pantalla LCD de 16x2 caracteres.
9 */
10
11 #include <OneWire.h>
12 #include <Wire.h>
13 #include <LiquidCrystal_I2C.h>
14
15 /**
16 Objeto para manejar la pantalla LCD a traves de I2C
17 */
18 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
19
20 /**
21 Objetos para el bus One Wire, se indica en cada uno el pin a utilizar
22 */
23 OneWire bus1(2);
24 OneWire bus2(3);
25 OneWire bus3(4);
26 OneWire bus4(5);
27
28 /**
29 Arreglo que contiene los valores de temperatura en grados centigrados
30 */
31 float temperature[4];
32
33 /**
34 Configuracion inicial y operaciones de arranque
35 */
36 void setup()
37 {
38 // Prepare LCD Display
39 lcd.begin(16, 2);
40 lcd.backlight();
41 lcd.clear();
42 lcd.print(" Digital ");
43 lcd.setCursor(0, 1);
44 lcd.print(" Thermometer ");
45 delay(500);
46 }
47
48 /**
49 Ciclo principal del programa
50 */
51 void loop()
52 {
53 for (int i = 0; i < 4; i++)
54 {
55 // Leer datos desde el sensor
56 thermometer_read(i, &temperature[i]);
57
58 // Imprimir a la pantalla
59 thermometer_print_temperature(i, temperature[i]);
60 }
61 }
62
63 /**
64 Retorna una referencia a un objeto OneWire de acuerdo al indice pasado como parametro
65 */
66 OneWire& thermometer_get_bus(uint8_t busid)
67 {
68 // Retornar la referencia al bus I2C apropiado para el canal seleccionado
69 switch (busid) {
70 case 0:
71 return bus1;
72 case 1:
73 return bus2;
74 case 2:
75 return bus3;
76 case 3:
77 return bus4;
78 default:
79 return bus1;
80 }
81 }
82
83 /**
84 Lee un sensor de temperatura DS18B20 en la instancia del bus seleccionada mendiante
85 el parametro busid. El codigo NO esta pensado para que cooexistan varios dispositivos
86 one Wire en el mismo bus, pues envia los comandos como "broadcast" en vez de usar
87 una direccion de dispositivo especifica.
88 */
89 bool thermometer_read(uint8_t busid, float * result)
90 {
91 uint8_t present;
92 uint8_t data[12];
93 int i;
94
95 // Retornar una lectura invalida si falla la comunicacion con el sensor
96 *result = - 100.0;
97
98 // Obtiene la instancia del bus a usar para la comunicacion con el sensor
99 OneWire onewire = thermometer_get_bus(busid);
100
101 // Enviar comando de iniciar la conversion de temperatura
102 onewire.reset();
103 onewire.skip();
104 onewire.write(0x44);
105
106 // Esperar el termino de conversion AD en el sensor
107 delay(1000);
108
109 // Enviar comando de lectura de scratchpad
110 if (!onewire.reset())
111 return false;
112 onewire.skip();
113 onewire.write(0xBE);
114
115 // Comenzar lectura de datos
116 for (i = 0; i < 9; i++)
117 data[i] = onewire.read();
118
119 // Alinear los datos recibidos
120 int16_t temp = (((int16_t) data[1]) << 11) | (((int16_t) data[0]) << 3);
121
122 // Convertir a grados centigrados
123 * result = (float)temp * 0.0078125;
124 return true;
125 }
126
127 /**
128 Imprime la temperatura con el simbolo de grados centigrados en la posicion
129 adecuada del display LCD
130 */
131 void thermometer_print_temperature(int probe, float temp)
132 {
133
134 // Posicionar el cursor de la LCD en la posicion adecuada
135 switch (probe)
136 {
137 case 0:
139 break;
140
141 case 1:
143 break;
144
145 case 2:
147 break;
148
149 case 3:
151 break;
152 }
153
154 // Imprimir el numero de sonda
155 lcd.print(probe + 1);
156 lcd.write((uint8_t) ':');
157
158 // Imprimer temperatura o errores
159 if (temp <= -100.0) {
160 lcd.print("Err!");
161 } else if (temp < 0) {
162 lcd.print("Low!");
163 } else if (temp >= 100) {
164 lcd.print("Hig!");
165 }
166 else if (temp < 10) {
167 lcd.print(0);
168 lcd.print(temp, 1);
169 }
170 else {
171 lcd.print(temp, 1);
172 }
173 // Imprimir simbolo de grados
174 lcd.print((char)223);
175 }
Los enlaces para la descarga de las librerías se proporcionan a continuación:

 Descarga la librería para el control del LCD por I2C (sitio del autor)
 Descarga la librería para dispositivos one wire (sitio del autor)
Hay que aclarar que nuestro programa NO contempla conectar varias sondas de
temperatura por cada pin, aunque es posible hacerlo según la especificación del
bus one-wire.
Puesta en Marcha del proyecto
Para poner en marcha el termómetro con Arduino y DS18B20, solamente
debemos conectar los sensores y aplicar la alimentación. En la pantalla se deben
visualizar las 4 temperaturas medidas por cada uno de los sensores.
Antes de aplicar la alimentación hay que verificar que hayamos realizado el ajuste
del voltaje de salida del convertidor DC-DC, ya que si saltamos este paso,
podemos dañar permanentemente el arduino, los sensores y todos los equipos
conectados a éste por un alto voltaje presente en la salida del módulo DC-DC.
Conclusión
El termómetro con Arduino y DS18B20 que presentamos es un desarrollo bastante
útil que nos puede servir como base para otros proyectos más complejos, ya que
podemos, por ejemplo, desarrollar un termómetro con alarmas o que realice
alguna acción correctiva en caso de detectar temperaturas anormales en alguno
de los sensores. Por ejemplo, aplicándolo en un acuario, podemos hacer que se
desactive el calentador si se detecta una temperatura muy alta. Al tratarse de la
plataforma arduino, siempre podemos acceder a una cantidad suficientemente
grande de aditamentos y agregar prácticamente cualquier funcionalidad con
mínimo esfuerzo, convirtiendo este proyecto en algo muy versátil.
DHT11 con Arduino sensor temperatura y

humedad
by Admin | Ene 10, 2017 | Tutoriales Arduino | 0 comments
En este artículo te enseñamos como utilizar el sensor DHT11 con
Arduino; Trataremos su conexión con el arduino UNO, profundizaremos en el
protocolo de comunicación y la instalación de la librería necesaria para entablar la
comunicación.
Los sensores DHT11 y DHT22 son capaces de realizar
mediciones simultáneas de humedad relativa y temperatura, entregándonos
su lectura de forma digital. Podemos encontrar aplicaciones para el DHT11 o el
DHT22 en el control de invernaderos, monitoreo de centros de datos, climatización
de casas y edificios, etc.
Materiales necesarios para las prácticas
Para esta experiencia requerimos los siguientes materiales, los cuales puedes
adquirir en nuestra tienda virtual:
 Sensor DHT11 de Temperatura y Humedad
 Arduino UNO R3
 Protoboard de 800 puntos
 Resistencia de 10 KOhms
Protocolo de comunicación del DHT22 o DHT11

con Arduino
El DHT11 no utiliza una interfaz serial estándar como I2C, SPI o 1Wire (es similar
a este ultimo). En cambio requiere su propio protocolo para comunicarse a través
de un solo hilo. Afortunadamente el protocolo de comunicación del DHT11 es
simple y puede implementarse tranquilamente usando los pines de I/O en un
Arduino.
El arduino debe iniciar la comunicación con el DHT11 manteniendo la linea de
datos en estado bajo durante al menos 18 ms. Luego el DHT11 envía una
respuesta con un pulso a nivel bajo (para indicar su presencia) de 80 uS y luego
deja “flotar” la linea de datos por otros 80 uS. En la figura de abajo, el pulso de
inicio enviado por el microcontrolador esta coloreado en rojo, mientras que la
respuesta desde el sensor esta coloreada en azul.
Codificación de bits
La codificación de datos esta basada en un esquema de ancho de pulso (se toma
en cuenta el ancho del estado alto): Un pulso ancho representa un 1 lógico, un
pulso corto representa un 0 lógico.
Todos los bits comienzan con un pulso bajo de 50 uS. Las librerías de
comunicación con el DHT11 aprovechan este pulso para la sincronización. Luego
viene un pulso alto que varía según el estado lógico o el valor del bit que el DHT11
desea transmitir:
 Se utilizan pulsos de 26-28 microsegundos para un “0”
 Se utilizan pulsos de 70 microsegundos para un “1”
Significado de los bits transmitidos por DHT11 o

DHT22.
En la siguiente ilustración observamos el inicio de una comunicación con el DHT11
o DHT22, resumiendo lo que hemos hablado con anterioridad:
Una transmisión completa comienza como ya describimos y se compone de 40

bits (5 bytes) que incluyen todos los datos que el sensor puede proporcionar. En
cuanto a los datos que se transmiten, su interpretación es como sigue:
 El primer byte que recibimos es la parte entera de la humedad relativa (RH).
 El segundo byte es la parte decimal de la humedad relativa (no se utiliza en el DHT11,
siempre es 0).
 El tercer byte es la parte entera de la temperatura.
 El cuarto byte es la parte decimal de la temperatura (no se utiliza en el DHT11, siempre es
0).
 El ultimo byte es la suma de comprobación (checksum), resultante de sumar todos los
bytes anteriores.
Diagrama de conexión para DHT11 con Arduino

El siguiente esquema ilustra como debe realizarse la conexión del sensor DHT11
o DHT22 con Arduino. Como podemos ver la conexión es bastante simple y se
realiza de la misma forma para el DHT11 y DHT22. Solamente se requiere de un
componente externo para la comunicación y es una simple resistencia de 10K.
También podemos agregar un cerámico de 100nF cerca de los pines de
alimentación del DHT11 para ayudar a reducir los ruidos que puedan filtrarse en la
alimentación.
Descarga de librería para DHT11 con Arduino
El programa que encontramos a continuación requiere la instalación de la librería
de Adafruit para sensores de la serie DHTXX. Podemos encontrarla en el
repositorio GitHub de adafruit o podemos descargarla directamente:
 Descargar librería
 Repositorio en GitHub
Esta librería implementa el protocolo para la comunicación con el DHT11 y DHT22
del que hablamos con anterioridad, por lo tanto, nos evita tener que entrar en
detalles de bajo nivel para comunicarnos con el DHT11.
Código de ejemplo básico DHT11 con Arduino

El siguiente sketch permite poner a funcionar el sensor DHT22 y DHT11 con
Arduino. Incluimos bastantes comentarios en el código de forma que se pueda
entender fácilmente.
1 /**
5
6 EJEMPLO SENSOR DHT11 1

7
8 EJEMPLO PARA EL SENSOR DHT11 QUE PERMITE MEDIR HUMEDAD Y TEMPERATURA. ESTE
SENSOR
9
ES MUY ECONÓMICO Y PODEMOS USARLO PARA DETECTAR LA HUMEDAD EN EL
10
AMBIENTE EN ZONAS
11
COMO INVERNADEROS, LAVANDERIAS, FABRICAS Y BAÑOS. USAMOS LA LIBRERIA DHT DE
12 ADAFRUIT
13 PARA COMUNICARSE CON EL DHT11 Y DHT22
14
15 */
16 #include "DHT.h"
17
18 // CONSTRUCTOR DEL OBJETO DHT RECIBE EL PIN EN EL QUE SE CONECTA EL SENSOR
19 // Y TAMBIEN RECIBE EL TIPO DE SENSOR QUE VAMOS A CONECTAR
20 DHT dht(2, DHT11);

21
22 void setup() {
23 // PREPARAR LA COMUNICACION SERIAL
25 Serial.println("Prueba del sensor DHT11");
26
27 // PREPARAR LA LIBRERIA PARA COMUNICARSE CON EL SENSOR
28 dht.begin();
29 }
30
31 void loop() {
32 // ESPERAR ENTRE MEDICIONES, NECESARIO PARA EL BUEN FUNCIONAMIENTO
33 delay(2000);
34
35 // LEER LA HUMEDAD USANDO EL METRODO READHUMIDITY
36 float h = dht.readHumidity();
37 // LEER LA TEMPERATURA USANDO EL METRODO READTEMPERATURE
38 float t = dht.readTemperature();
39
40 // REVISAR QUE LOS RESULTADOS SEAN VALORES NUMERICOS VALIDOS, INDICANDO QUE
LA COMUNICACION ES CORRECTA
41
if (isnan(h) || isnan(t)) {
42
Serial.println("Falla al leer el sensor DHT11!");
43
return;
44
}
45
46
// IMPRIMIR RESULTADO AL MONITOR SERIAL
47
Serial.print("Humedad: ");
48
Serial.print(h);
49
Serial.print(" % ");
50
Serial.print("Temperatura: ");
51
Serial.print(t);
Serial.println(" *C");
}
El resultado de la ejecución del programa debe ser como se muestra a

continuación, si se imprime el mensaje de error habrá que revisar las conexiones y
verificar que nuestro sensor no este dañado.
Conclusión
 En este articulo exploramos los detalles del protocolo utilizado por el sensor DHT11 y
DHT22 para comunicarse con arduino.
 Aprendimos sobre la conexión física entre arduino y el sensor.
 Descargamos e instalamos una librería para comunicarnos con el DHT11 y DHT22 con el
mínimo esfuerzo.
 Realizamos un programa básico que muestra las lecturas del sensor en el monitor serial.
 Vimos que ambos sensores (DHT11 y DHT22) son muy similares y pueden usarse con las
mismas librerías y las mismas conexiones.
 Se dejan las bases para proyectos más complejos con el DHT11 y DHT22.
Diagrama de pines Arduino (pinout arduino)
by Admin | May 4, 2016 | Tutoriales Arduino | 1 comment
¿Cuantas veces no te ha pasado que la serigrafía en la placa de arduino no

explica lo suficiente sobre las funciones de cada pin? Bueno, sabemos lo
incómodo que puede resultar y mientras navegábamos por el foro de arduino
encontramos la solución a este problema. Notamos que un usuario hizo un
excelente trabajo realizando el diagrama de pines Arduino. En esta entrada del
blog, compartimos con ustedes este excelente trabajo que vale la pena imprimir y
tener a la mano como referencia en nuestro banco de trabajo.
Diagrama de Pines Arduino Uno R3 (mapa de
pines)
El arduino uno es por mucho la placa arduino más popular, este es el diagrama de
las funciones asociadas a cada uno de los pines. Conviene tenerlo impreso y
siempre cerca de nuestro arduino favorito.
Diagrama de Pines Arduino Mega 2560 R3 (mapa

de pines)
El arduino mega es el siguiente paso cuando hemos dominado el Arduino UNO
R3, dispone de muchos más pines de I/O y mucha más memoria RAM y Flash.
Aquí tienes el diagrama de pines correspondiente.
Diagrama de Pines Arduino Nano (mapa de
pines)
El arduino nano dispone del mismo microcontrolador que el arduino UNO, pero
viene en un paquete mucho más pequeño y es amigable con el protoboard. La
distribución de sus pines es la siguiente:
Diagrama de Pines Arduino Leonardo (mapa de

pines)
El arduino leonardo se caracteriza por integrar en un solo chip la interfaz USB y el
microcontrolador (ATMEGA32U4). Puede funcionar como ratón, memoria USB y
virtualmente cualquier otro periférico USB que se nos ocurra.
Diagrama de Pines Arduino Micro (mapa de pines)
El arduino micro es la versión miniatura del arduino Leonardo, al igual que este
incluye un ATMEGA32U4 que es ideal para aplicaciones con conectividad USB.
Su diseño favorece el uso del protoboard.
Diagrama de Pines Arduino Yun (mapa de pines)
El arduino Yun integra un procesador que corre linux y un microcontrolador
ATMEGA32U4. Es ideal para aplicaciones que requieren conectividad a internet
y/o servicios web.
Descargar todos los diagramas en formato PDF y
enlaces
Controlar tu arduino desde la PC mediante

comandos de texto
by Admin | Jul 20, 2015 | Tutoriales Arduino | 6 comments
En muchas ocasiones durante el desarrollo de proyectos con arduino te habrás
topado con la necesidad de controlar tu arduino desde la PC. Ya sea desde una
aplicación realizada a la medida o simplemente desde el monitor serial de arduino.
Por ejemplo podemos realizar acciones tan sencillas como encender un led y
llegar a cosas más complejas como cambiar la dirección IP de nuestro ethernet
shield sin necesidad de reprogramar el sketch o cambiar los parámetros de un
algoritmo de control en tiempo de ejecución, etc.
Existen varios enfoques para controlar tu arduino desde la PC, sin embargo en
esta entrada presentamos un método que permite la mayor flexibilidad desde
nuestro punto de vista. Te presentamos una librería que hemos desarrollado
y que nos permite emular la experiencia de la “consola” o “terminal” de un
sistema operativo en un PC de escritorio, pero esta vez ejecutandose dentro de
cualquier microcontrolador que disponga de un compilador de C. Esto permite
cambiar parámetros, solicitar la ejecución de programas (funciones) y cambiar
configuraciones y parámetros del programa mientras este se ejecuta. Para
comprobar y entender el funcionamiento básico de esta librería controlaremos un
led RGB desde el puerto serie de la PC.
En la foto de portada vemos el circuito de prueba de un led RGB conectado
al arduino. Podemos controlar arduino desde la PC mediante comandos de
texto y cambiar el color mostrado en el LED RGB a voluntad.
Conceptos básicos
Un LED RGB es un dispositivo que en un solo encapsulado contiene 3 diodos
emisores de luz. Cada uno de estos emisores de luz corresponde a uno de los
colores básicos (Rojo, Verde y Azul). Por lo que podemos representar
prácticamente todos los colores conocidos.
Este tipo de led se encuentran en varias configuraciones. Nosotros vamos a

requerir un led RGB con cátodo común, es decir que la tierra o negativo de cada
led esta conectado a un único pin. Por lo tanto debemos aplicar un voltaje positivo
a cada uno de los otros pines para encender cada led individual. Existe la
configuración opuesta, en la que el ánodo es común y por lo tanto debemos
conectar a tierra los otros pines para encender cada diodo.
La librería “shell” para arduino
Esta librería permite controlar nuestros programas y dispositivos con simples
comandos de texto de manera similar a la terminal en Mac OSX o linux y la linea
de comandos de Windows. Los comandos pueden transmitirse al microcontrolador
mediante un puerto serie, un socket TCP/IP o una conexión USB CDC.
La librería puede descargarse desde github en el enlace que se muestra a
continuación. Si deseas saber como se realiza la instalación de una librería de
arduino puedes consultar este otro tutoríal.
Descarga de la librería Shell
Uso de la librería “Shell” para controlar tu arduino

desde la PC
Para utilizar la librería debemos llamar al principio de nuestro programa o
sketch a la función de inicialización shell_init() que le dice a la librería que
funciones debe usar para leer y escribir sobre el medio (serial, TCP/IP, etc.) Estas
funciones deben ser provistas por el usuario (programador). En el caso de arduino,
creamos unas funciones (wrappers ) que “envuelven” a los
métodos write() y read() de la clase Serial y simplemente redirigen los datos desde
y hacia nuestra librería. El ultimo parámetro (nulo o 0 en este caso) permite definir
un mensaje personalizado de bienvenida, que aparece al principio de la terminal,
antes de que se solicite cualquier comando.
1 // Initialize command line interface (CLI)
2 // We pass the function pointers to the read and write functions that we implement below
3 // We can also pass a char pointer to display a custom start message
4 shell_init(shell_reader, shell_writer, 0);
Luego, el usuario debe asociar los comandos y las funciones, es decir,

indicamos una cadena que al recibirse en el puerto serie causará que la librería
invoque a la función correspondiente. Esto se hace llamando a la
función shell_register() que acepta por una parte un apuntador a función y la
cadena correspondiente al comando. Se hace de la siguiente forma:
1 // Add commands to the shell
2 shell_register(command_mycommand, "mycommand");
3 shell_register(command_othercommand, "othercommand");
Finalmente, dentro del ciclo principal de cada aplicación, el programador debe

asegurarse de llamar a la función shell_task(), ya que dentro de esta se
procesan los caracteres recibidos y es la encargada de ejecutar las funciones que
asociamos a cada cadena.
1 // This should always be called to process user input
2 shell_task();
Los programas (funciones) que implementan cada uno de los comandos se

deben escribir con el prototipo estándar de C para una utilidad de linea de
comandos y reciben los parámetros para realizar su función de manera análoga.
Por ejemplo esta es la función que ejecutaríamos al escribir “mycommand” y
presionar la tecla enter:
1 int command_mycommand(int argc, char** argv)
2 {
3 shell_println("Running \"mycommand\" now");
4 shell_println("Exit...");
5 return SHELL_RET_SUCCESS;
6 }
Como podemos ver la función solamente imprime la cadena “Ejecutando
mycommand” y luego retorna, sin embargo, podemos crear funciones que afecten
prácticamente cualquier aspecto del funcionamiento del programa o que realicen
cualquier acción. El resultado del ejemplo mostrado aquí es el siguiente:
Este ejemplo lo podemos encontrar listo para compilarse y probarse en la carpeta

“Ejemplos>Shell>Shell_Basic” una vez que hemos instalado nuestra librería.
Por ejemplo podemos crear comandos para prender/apagar un led, mover un
motor, o leer un sensor. A continuación estudiaremos un ejemplo que
nos permite controlar un led RGB con la PC.
Materiales necesarios.
 Arduino UNO R3
 Cable USB para Arduino
 Cables para conexión en el protoboard
 Protoboard Miniatura
 Resistencias 330 Ohms
 Led RGB cátodo común
Diagrama de conexiones Controlar LED RGB
desde la PC
La siguiente ilustración muestra como debemos efectuar las conexiones para el
ejemplo que vamos a cargar en nuestro arduino a continuación. Utilizamos un LED
RGB de cátodo común con sus respectivas resistencias de 330 ohms.
La vista detallada de las conexiones y el circuito armado es la siguiente:

Considera lo siguiente al armar el circuito:
 El pin más largo del led es el común.
 El pin más largo se conecta a tierra (pin GND de Arduino).
 Se utilizan los pines de conexión 3, 5 y 6 por que son salidas PWM de la tarjeta Arduino
UNO
Ejemplo: Controlar led RGB desde la PC
Este sketch de ejemplo controla un led RGB para cambiar el color y brillo del led
enviamos el comando:
rgbled 100 100 100
Al finalizar de escribir el comando debemos enviar los caracteres CR y LF (ASCII).
Con esto controlamos las componentes RGB del led. El primer número es el
componente rojo, el segundo el verde y el tercero el azul. El sketch que
implementa el control del led RGB mediante comandos de texto es el siguiente:
1 /**
2 * GeekFactory - "Construye tu propia tecnologia"
3 * Distribucion de materiales para el desarrollo e innovacion tecnologica
4 * www.geekfactory.mx
5 *
6 * Ejemplo de libreria Shell. Este ejemplo permite controlar el color mostrado
7 * en un led RGB conectado a los pines PWM mediante comandos de texto. El programa
8 * admite 3 parametros de 0 a 255 que representan la intensidad de cada led (RGB).
9 *
10 * Example for Shell library. This example controls the color displayed on the RGB
11 * led connected to PWM pins using text commands. The program accepts 3 parameters
12 * in a range from 0 to 255 that represent the intensity of each led.
13 */
14
15 #include <Shell.h>
16
17 void setup()
18 {
19 // Prepare serial communication
21 // Wait after reset or power on...
22 delay(1000);
23
24 // Pins to connect RGB led (PWM outputs)
25 pinMode(3,OUTPUT);
28
29 // Initialize command line interface (CLI)
30 // We pass the function pointers to the read and write functions that we implement below
31 // We can also pass a char pointer to display a custom start message
32 shell_init(shell_reader, shell_writer, 0);
33
34 // Add commands to the shell
35 shell_register(command_rgbled, "rgbled");
36 }
37
38 void loop()
39 {
40 // This should always be called to process user input
41 shell_task();
42 }
43
44 /**
45 * This function implements the rgbled command and parses the required args
46 * Type: rgbled 255 255 255 to set led to maximum brigtness
47 * Type: rgbled 0 0 0 to set led to minimum brightess
48 */
49 int command_rgbled(int argc, char** argv)
50 {
51 // Variables that store parameter values
52 uint8_t val_R, val_G, val_B;
53
54 // Parse RGB values and write to PWM pins
55 val_R = strtol(argv[1],NULL,0);
56 analogWrite(3, val_R);
57
58 val_G = strtol(argv[2],NULL,0);
59 analogWrite(5, val_G);
60
61 val_B = strtol(argv[3],NULL,0);
62 analogWrite(6, val_B);
63
64 // Print the received falues to the terminal screen
65 shell_printf("#RGB-COMPONENTS:%d,%d,%d\r\n", val_R, val_G, val_B);
66
67 // Return success code
68 return SHELL_RET_SUCCESS;
69 }
70
71 /**
72 * Function to read data from serial port
73 * Functions to read from physical media should use this prototype:
74 * int my_reader_function(char * data)
75 */
76 int shell_reader(char * data)
77 {
78 // Wrapper for Serial.read() method
79 if (Serial.available()) {
80 *data = Serial.read();
81 return 1;
82 }
83 return 0;
84 }
85
86 /**
87 * Function to write data to serial port

88 * Functions to write to physical media should use this prototype:
89 * void my_writer_function(char data)
90 */
91 void shell_writer(char data)
92 {
93 // Wrapper for Serial.write() method
94 Serial.write(data);
95 }
Nótese que hemos omitido todas las comprobaciones sobre los datos recibidos,
incluso si se han proporcionado las 3 componentes de color, todo esto en favor de
la simplicidad. Sin embargo, si hemos mostrado algunas características de la
librería “Shell” como la capacidad de imprimir texto con formato usando la función
shell_printf(). Hemos destacado esto en color amarillo en el código más arriba.
El resultado del ejemplo anterior es el siguiente visto en el monitor serial de
arduino:
Conclusiones
La librería shell.h permite controlar tu arduino desde la PC mediante el puerto
serial o ethernet fácilmente. En esta entrada hemos realizado un proyecto básico
que nos permite saber como funciona la librería y los pasos necesarios para
asociar comandos con las cadenas de texto. También pudimos observar que los
parámetros pasados a las funciones invocadas por la librería, son exactamente
iguales que el estándar para una utilidad de linea de comandos en C o C++. Por lo
que para muchos programadores más experimentados será fácil acostumbrarse a
escribir programas para la plataforma arduino y microcontroladores.
Tutorial Arduino con Fotoresistencia LDR

by Admin | Nov 3, 2014 | Tutoriales Arduino | 30 comments
En este artículo vamos a realizar un sencillo medidor de luz con nuestro arduino,
utilizaremos un arduino con fotoresistencia LDR y mostraremos el resultado en
la computadora así como como en un grupo de leds. El objetivo de este tutorial es
aprender como conectar sensores que varían su resistencia dependiendo de una
magnitud física. Un ejemplo de este tipo de sensores es el LDR o
fotoresistor, estudiaremos el funcionamiento de este componente y su conexión
con la tarjeta Arduino UNO R3 mediante un divisor resistivo en el resto de
este texto.
En nuestra foto de portada se observa el circuito de prueba para el Arduino
con Fotoresistencia LDR montado sobre el protoboard.
Conceptos básicos
Para entender como funciona este circuito y el programa que corre en la tarjeta
Arduino debemos conocer 3 conceptos clave:
 Fotoresistencia LDR: Componente cuya resistencia varía sensiblemente con la
cantidad de luz percibida. La relación entre la intensidad lumínica y el valor de la
resistencia no es lineal. Se utiliza ampliamente para medir la iluminación en
dispositivos electrónicos que requieren un precio agresivo. Su comportamiento es
el siguiente:
 Mas luz = menor resistencia eléctrica
 Menos luz = mayor resistencia eléctrica
 Divisor de voltaje: Mediante un par de resistencias en serie, es posible repartir la
tensión suministrada por la fuente entre las terminales de estas, en nuestro caso,
el divisor se utiliza con el LDR para obtener un voltaje variable de acuerdo a la
cantidad de luz percibida.

 Conversión Analógico-Digital (ADC): Es el proceso mediante el cual se
convierte una magnitud física como un voltaje, corriente, temperatura, etc. en un
número binario (o señal digital) con el propósito de facilitar su manejo por circuitos
digitales como un CPU. El Arduino realiza este proceso para conocer la cantidad
de luz percibida por el LDR y poder procesarla numericamente.
Recomendamos estudiar estos conceptos a profundiad para desarrollar las
habilidades necesarias para aplicarlos en otras situaciones distintas, ya que
serán de gran utilidad al conectar cualquier otro sensor analógico al arduino.
Podemos estudiar los conceptos más a detalle en los enlaces provistos. Estos
temas podrían ser objeto de un artículo individual para cada uno, pero creemos
que ya otras personas han hecho un buen trabajo explicándolos, por lo que queda
como tarea para el lector investigarlos más a fondo.
Materiales necesarios
 1 Arduino UNO R3
 1 Fotoresistor (LDR)
 1 Resistencia de 10 Kohm 1/4 W
 3 Resistencias de 220 o 330 ohm 1/4 W
 3 Leds 5mm
 Cables para protoboard
 Protoboard
Diagrama para utilizar Arduino con Fotoresistencia
LDR
Debemos armar el circuito como se muestra en el siguiente diagrama pictórico.
Recordar que los LED tienen polaridad y hay que respetarla. El pin más largo va
conectado a la tarjeta arduino, mientras que el pin más corto va con una
resistencia a tierra, la resistencia también puede colocarse sin problema entre el
ánodo del led y el arduino (del lado positivo del led):
El circuito armado sobre el protoboard y las conexiones con el arduino quedan de

la siguiente manera:
Código (sketch) para Arduino con Fotoresistencia
LDR.
La explicación para el código es la siguiente: Primero se preparan los pines de
salida donde estan conectados los leds, el pin de entrada donde se conecta el
divisor resistivo y el puerto serie para la comunicación. A continuación se ejecuta
un cíclo infinito en el que se lee el valor del voltaje en el pin del LDR y se accionan
los leds segun correspondan. También transmitimos el valor leido por el ADC del
ATMEGA328 a la PC a través del puerto serie de nuestra tarjeta arduino. Hemos
comentado el código de manera que sea fácil de entender.
1 /*
2 * http://www.geekfactory.mx
3 *
4 * Ejemplo de medidor de luz con Arduino utilizando una fotoresistencia LDR y
5 * un grupo de leds para mostrar el resultado de las lecturas. Este sketch puede
6 * servir como base para otros proyectos que requieren medicion de la intensidad
7 * de luz con una fotoresistencia.
8 *
9 * Mas detalles y la conexion completa para este sketch en:
10 * http://www.geekfactory.mx/tutoriales/tutoriales-arduino/tutorial-arduino-con-fotoresistencia-ldr/
11 *
12 */
13
14 // Pin donde se conectan los leds
15 int pinLed1 = 2;
16 int pinLed2 = 3;
17 int pinLed3 = 4;
18 // Pin analogico de entrada para el LDR
19 int pinLDR = 0;
20
21 // Variable donde se almacena el valor del LDR
22 int valorLDR = 0;
23
24 void setup()
25 {
26 // Configuramos como salidas los pines donde se conectan los led
27 pinMode(pinLed1, OUTPUT);
30
31 // Configurar el puerto serial
33 }
34
35 void loop()
36 {
37 // Apagar todos los leds siempre que se inicia el ciclo
38 digitalWrite(pinLed1, LOW);
41
42 // Guardamos el valor leido del ADC en una variable
43 // El valor leido por el ADC (voltaje) aumenta de manera directamente proporcional
44 // con respecto a la luz percibida por el LDR
45 valorLDR= analogRead(pinLDR);
46
47 // Devolver el valor leido a nuestro monitor serial en el IDE de Arduino
48 Serial.println(valorLDR);
49
50 // Encender los leds apropiados de acuerdo al valor de ADC
51 if(valorLDR > 256)
52 {
53 digitalWrite(pinLed1, HIGH);
54 }
56 {
58 }
60 {
62 }
63 // Esperar unos milisegundos antes de actualizar
64 delay(200);
65 }
Para probar nuestro flamante medidor de luz, solamente debemos colocarlo sobre
una fuente de luz y verificar que los led se encienden conforme aumenta la
cantidad de luz. En la terminal, también podremos ver como va cambiando el valor
de la conversión analógico a digital.
Sensor ultrasónico HC-SR04 y Arduino
by Admin | May 16, 2014 | Tutoriales Arduino | 62 comments
En este tutorial explicaremos como utilizar un sensor ultrasónico HC-SR04 y

arduino para la medición de distancia y detección de obstáculos.
El sensor HC-SR04 es un módulo que incorpora un par de transductores de
ultrasonido que se utilizan de manera conjunta para determinar la distancia del
sensor con un objeto colocado enfrente de este. Quizá la característica más
destacada del HC-SR04 es que puede ser adquirido por una baja suma de dinero
y esto mismo lo ha hecho muy popular. Sin embargo, la baja cantidad de dinero
que invertimos en el sensor, no demerita demasiado en la exactitud del sensor ni
en su facilidad de uso, por lo que su relación costo / beneficio es muy buena.
En la foto principal de este artículo, observamos el sensor ultrasónico HC-SR04
montado en un protoboard y el Arduino Uno que usamos para desarrollar los
programas.
Materiales necesarios para las prácticas.

Para completar los ejercicios propuestos en esta página recomendamos adquirir
los siguiente materiales:
 Tarjeta Arduino UNO R3
 HC-SR04 Módulo sensor ultrasónico
 Cables tipo dupont para conexiones
 Protoboard (opcional)
En la foto del artículo vemos los materiales que hemos utilizado y que tenemos
disponibles en nuestra tienda virtual. Nosotros utilizamos nuestro protoboard, pero
vale cualquier otra forma de montar y conectar los componentes, incluso un simple
juego de cables dupont funciona perfecto, con la ventaja de resultar mucho más
compacto.
¿Cómo funciona el sensor HC-SR04?

El sensor HC-SR04 es un módulo que incorpora un par de transductores de
ultrasonido que se utilizan de manera conjunta para determinar la distancia del
sensor con un objeto colocado enfrente de este. Un transductor emite una “ráfaga”
de ultrasonido y el otro capta el rebote de dicha onda. El tiempo que tarda la
onda sonora en ir y regresar a un objeto puede utilizarse para conocer la
distancia que existe entre el origen del sonido y el objeto.
En el mercado existen 2 tipos de módulos para medición de distancia por
ultrasonido que se utilizan en robótica y aplicaciones similares:
 Interfaz mediante pulso de eco: Este tipo de sensores poseen un pin de disparo
y otro de eco, algunos incluso combinan ambas funcionalidades en un solo pin. El
microcontrolador que desea realizar una medición debe medir el tiempo en alto de
un pulso digital.
 Interfaz serial (I2C o UART): Este tipo de módulos entregan su medición en
formato digital a través de una interfaz serial (I2C o UART). Habitualmente se
acceden como si se tratara de una memoria serial I2C y podemos leer los registros
donde se encuentran las mediciones de distancia.
El HC-SR04 es un sensor que funciona a través de la medición del pulso de
echo y solamente explicaremos este tipo de sensores en este tutorial.
A continuación puedes descargar la hoja de datos del sensor para conocerlo más
a fondo.
 Descarga hoja de datos del sensor HC-SR04
¿Cómo se comunica con Arduino el sensor HC-

SR04?
La interfaz del sensor HC-SR04 y arduino se logra mediante 2 pines digitales: el
pin de disparo (trigger) y eco (echo). La función de cada uno de estos pines es la
siguiente:
 El pin trigger recibe un pulso de habilitación de parte del microcontrolador,
mediante el cual se le indica al módulo que comience a realizar la medición de
distancia.
 En el pin echo el sensor devuelve al microcontrolador un puso cuyo ancho es
proporcional al tiempo que tarda el sonido en viajar del transductor al obstáculo y
luego de vuelta al módulo.
Mediante una sencilla formula puede estimarse entonces la distancia entre el
sensor y el obstáculo si se conoce el tiempo de viaje del sonido así como la
velocidad de propagación de la onda sonora. La siguiente imagen muestra los
pulsos recibidos y enviados por el sensor, de acuerdo a la hoja de datos del
sensor que colocamos más arriba para su descarga.
Como se puede observar, el HC-SR04 genera un pulso en el pin marcado como

“echo” cuya duración es proporcional a la distancia medida por el sensor. Para
obtener la distancia en centímetros, solamente debemos dividir el tiempo en
microsegundos entre 58 o para obtener la distancia en centímetros (148 para
pulgadas).
¿Cómo se conecta un sensor HC-SR04 con

arduino?
La conexión del sensor con Arduino es muy sencilla. Podemos realizarla utilizando
un protoboard, o directamente con alambres. Para lograr que el sensor funcione,
son necesarias 4 señales:
 Alimentación de 5 volts.
 Tierra o común del circuito.
 Señal de disparo (trig).
 Señal de eco (echo).
La siguiente imagen muestra como queda conectado el sensor utilizando
solamente cables:
Cabe aclarar que nosotros hemos utilizado los pines 11 y 12, pero vale cualquier
otra combinación de pines. No hay mucho más que decir, ya que es bastante fácil
de conectar, solamente tener cuidado con la polaridad y posición de las señales.
Programación para sensor ultrasónico HC-SR04 y

arduino utilizando librería.
El primer paso es descargar e instalar la librería newPing desde el playground de
Arduino. El proceso de instalación de una librería ya lo hemos cubierto en un
tutorial anterior y no lo expondremos nuevamente en esta entrada. El enlace de
descarga de la librería y su documentación se encuentran en esta web:
 http://playground.arduino.cc/Code/NewPing
Ya que tengamos la librería NewPing instalada, copiamos el siguiente código para
probar su funcionamiento. Hay que recordar que si cambiamos los pines de
conexión con el sensor, es necesario retocar las primeras lineas para que las
señales puedan llegar a los pines correspondientes.
Los pines de conexión deben coincidir perfectamente para que el sensor HC-SR04
y Arduino puedan funcionar en conjunto, de lo contrario, podemos causar daños y
sobrecalentamiento a cualquiera de las dos placas: Arduino o sensor.
1 #include <NewPing.h>
2
3 /*Aqui se configuran los pines donde debemos conectar el sensor*/
4 #define TRIGGER_PIN 12
5 #define ECHO_PIN 11
6 #define MAX_DISTANCE 200
7
8 /*Crear el objeto de la clase NewPing*/
9 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
10
11 void setup() {
13 }
14
15 void loop() {
16 // Esperar 1 segundo entre mediciones
17 delay(1000);
18 // Obtener medicion de tiempo de viaje del sonido y guardar en variable uS
19 int uS = sonar.ping_median();
20 // Imprimir la distancia medida a la consola serial
21 Serial.print("Distancia: ");
22 // Calcular la distancia con base en una constante
23 Serial.print(uS / US_ROUNDTRIP_CM);
24 Serial.println("cm");
25 }
El código realizado con la librería NewPing queda bastante sencillo y además de

aceptar el sensor ultrasónico HC-SR04 permite utilizar la gran mayoría de los
sensores que utilizan interfaz del tipo Interfaz “con medición de pulsos” con 3 y 4
pines.
Programación para sensor ultrasónico sin usar

librería
Puede resultarnos útil, al menos para satisfacer la curiosidad, poner a funcionar el
sensor HC-SR04 sin la necesidad de usar una librería. El programa que
mostramos a continuación permite hacer justamente eso:
1 /**
5
6 EJEMPLO SENSOR ULTRASONICO 1
7
8 REALIZA LA MEDICION DE DISTANCIA CON UN SENSOR ULTRASÓNICO HC-SR04
9 CONECTADO
10 AL ARDUINO. ESTE EJEMPLO NO UTILIZA LIBRERIAS ESPECIALES PARA EL SENSOR,
11 SOLAMENTE
12 SE UTILIZA LA FUNCION "PULSEIN" PARA MEDIR LA LONGITUD DEL PULSO DE ECO.
13
14 */
15 // DECLARACION DE VARIABLES PARA PINES
16 const int pinecho = 8;
17 const int pintrigger = 9;
19
20 // VARIABLES PARA CALCULOS
21 unsigned int tiempo, distancia;
22
23 void setup() {
24 // PREPARAR LA COMUNICACION SERIAL
26 // CONFIGURAR PINES DE ENTRADA Y SALIDA
27 pinMode(pinecho, INPUT);
28 pinMode(pintrigger, OUTPUT);
30 }
31
32 void loop() {
33 // ENVIAR PULSO DE DISPARO EN EL PIN "TRIGGER"
34 digitalWrite(pintrigger, LOW);
35 delayMicroseconds(2);
36 digitalWrite(pintrigger, HIGH);
37 // EL PULSO DURA AL MENOS 10 uS EN ESTADO ALTO
38 delayMicroseconds(10);
39 digitalWrite(pintrigger, LOW);
40
41 // MEDIR EL TIEMPO EN ESTADO ALTO DEL PIN "ECHO" EL PULSO ES PROPORCIONAL A LA
42 DISTANCIA MEDIDA
43 tiempo = pulseIn(pinecho, HIGH);
44
45 // LA VELOCIDAD DEL SONIDO ES DE 340 M/S O 29 MICROSEGUNDOS POR CENTIMETRO
46 // DIVIDIMOS EL TIEMPO DEL PULSO ENTRE 58, TIEMPO QUE TARDA RECORRER IDA Y
47 VUELTA UN CENTIMETRO LA ONDA SONORA
48 distancia = tiempo / 58;
49
50 // ENVIAR EL RESULTADO AL MONITOR SERIAL
51 Serial.print(distancia);
52 Serial.println(" cm");
53 delay(200);
54
55 // ENCENDER EL LED CUANDO SE CUMPLA CON CIERTA DISTANCIA
56 if (distancia <= 15) {
58 delay(500);
} else {
digitalWrite(13, LOW);
}
}
Como instalar una librería de Arduino
by Admin | Ene 3, 2014 | Tutoriales Arduino | 1 comment
Si ya llevamos un rato jugando con nuestro arduino y poco a poco vamos tomando
confianza para enfrentar proyectos cada vez más ambiciosos, seguramente nos
encontraremos muy pronto en el siguiente escenario: Acabamos de adquirir un
shield de arduino o un flamante nuevo sensor que requiere una librería especial
para poder ser utilizado y no sabemos como instalar el software necesario para
hacerlo funcionar. En este tutorial te explicamos como instalar una librería de
Arduino tanto en Windows como en Mac para que puedas seguir con tu
proyecto lo más rápido posible.
En este ejemplo estaremos viendo la instalación de la librería NewPing para
sensores ultrasónicos y veremos las 3 formas que existen de realizar la
instalación de una librería de Arduino. Hemos actualizado (en septiembre de
2018) este tutorial para que refleje los pasos a seguir en las nuevas versiones del
IDE Arduino.
¿Qué es una librería de arduino?

Las librerías son colecciones de código que facilitan la interconexión de sensores,
pantallas, módulos electrónicos, etc. Habitualmente las librerías se distribuyen en
formato ZIP.
El entorno de arduino ya incluye algunas librerías de manera que se facilite, por
ejemplo, mostrar texto en pantallas LCD. Existen miles de librerías desarrolladas
por terceros en internet, que nos ayudarán a conectar prácticamente cualquier
dispositivo a nuestras tarjetas con arduino. Para saber como utilizar una librería,
es necesario consultar la referencia oficial de arduino o el sitio web desde el cual
descargamos la librería, también podemos consultar los ejemplos que vienen con
las propias librerías si es que no encontramos más documentación.
Las librerías normalmente incluyen los siguientes archivos comprimidos en un
archivo ZIP:
 Un archivo .cpp (código fuente de C++).
 Un archivo .h o encabezado de C.
 Un archivo Keywords.txt.
 Muy posiblemente la librería incluye un archivo readme con información adicional sobre la
librería para el desarrollador.
 Directorio de sketch de ejemplo (opcional).
 Archivo de metadatos library.properties
En la siguiente imagen vemos el contenido de la librería NewPing (que maneja
varios sensores ultrasónicos) y como están organizados sus archivos:
El equipo que desarrolla Arduino ha hecho público un documento en el que se
detallan las especificaciones y estructura que debe tener una librería de arduino.
Puedes encontrar dicho documento en la siguiente URL, aunque solamente será
útil para aquellos usuarios que quieran desarrollar sus propias librerías:
Especificación de librerías para el IDE 1.5 o superior
¿Cómo instalar una librería de Arduino?

Existen 3 formas de instalar una librería en el IDE de Arduino, dependiendo de
la librería y de como la obtengamos, debemos elegir alguna de ellas:
1. Instalar una librería desde el “gestor de librerías”: la forma más sencilla si la librería
se encuentra dada de alta en el IDE de arduino, esto debe hacerlo el autor de la librería.
2. Importar una librería desde archivo ZIP: Otra forma sencilla de agregar librerías, ideal
cuando descargamos un archivo ZIP. Posiblemente debamos usar este método si la
librería que buscamos NO está dada de alta en el “gestor de librerías”.
3. Instalar manualmente la librería en las carpetas destinadas a almacenar librerías.
Instalar una librería de arduino mediante el gestor de

librerías (método recomendado).
El gestor de librerías es una característica recién implementada en versiones
recientes del IDE Arduino. Permite instalar y actualizar las librerías de forma
totalmente transparente para el usuario. Para instalar una librería, solamente
debemos seleccionarla de una lista y pulsar el botón “instalar”.
Tomemos como ejemplo la librería “NewPing”. Para instalar la librería
usando el gestor de librerías debemos hacer lo siguiente:
1.- Abrir el “gestor de librerías” haciendo click en Programa > Incluir librería >
Gestionar Librerías.
2.- En la pantalla que se despliega, debemos ingresar el nombre de la librería que

deseamos instalar en el campo de búsqueda que resaltamos en la imagen.
3.- Finalmente pulsamos en el botón “instalar”.
Al instalar una librería por este método, tenemos la ventaja de que el IDE podrá
ubicar y descargar actualizaciones de la librería de forma
automática. Además podremos instalar la versión de la librería de nuestro interés:
ya sea la más nueva o una más antigua por razones de compatibilidad con
nuestros programas.
Importar librería de arduino desde archivo ZIP

1.- Ubicar y descargar la librería de arduino que requerimos. Es común en estos
días encontrar las librerías alojadas en repositorios GIT con proveedores
como Bitbucket y Github. Normalmente estos sitios, además del acceso mediante
GIT, también brindan un enlace de descarga para los archivos en formato ZIP
2.- Abrir el IDE de Arduino y hacer click en Programa > Incluir librería… >
Añadir librería .ZIP en la barra de menú.
3.- Se mostrará la pantalla donde debemos indicar la ruta del archivo .ZIP que
contiene la librería de arduino. Elegimos el archivo ZIP que acabamos de
descargar y damos click en “Seleccionar”.
Una vez realizados los pasos anteriores, ya debemos tener nuestra libraría lista
para funcionar.
Instalación manual de una librería

Si los métodos anteriores para instalar una librería de arduino no funcionan o
queremos instalar manualmente la librería para “un mayor control”. Podemos
hacerlo de la siguiente forma:
 Descomprimimos el archivo .ZIP
 En Windows copiamos la carpeta de la librería a la siguiente
ruta: Documents\Arduino\libraries
 En MAC copiamos la carpeta de la librería a la siguiente
ruta: Documents/Arduino/libraries
Al final deberíamos tener en nuestro directorio los siguientes archivos (Windows):
1 My Documents\Arduino\libraries\NewPing\src\NewPing.cpp
2 My Documents\Arduino\libraries\NewPing\src\NewPing.h
3 My Documents\Arduino\libraries\NewPing\examples
En MAC quedaría algo así:
1 Documents/Arduino/libraries/NewPing/src/NewPing.cpp
2 Documents/Arduino/libraries/NewPing/src/NewPing.h
3 Documents/Arduino/libraries/NewPing/src/examples
Incluir la librería recién instalada en un programa

Para poder usar nuestra librería en un programa, hará falta incluirla dentro del
código fuente. Para hacer esto, hacemos click en Programa > Incluir Librería >
NombreDeLaLibreria. El procedimiento se ve en la siguiente imagen.
Al realizar lo anterior, debemos ver la librería incluida al inicio de nuestro programa
de la siguiente forma:
1 #include <NewPing.h>
También podemos escribir nosotros esta misma linea en todos los programas que
utilizarán la librería NewPing. No hará falta realizar el procedimiento de
instalación para cada programa que deseemos realizar, pues la librería ya se
encontrará instalada para todos nuestros programas. Bastará con insertar la
directiva “include” en cada uno de nuestros programas que usen la librería.
Conclusión
Llegamos al final de este tutorial para instalar una librería en el IDE Arduino. Ahora
solo queda aprender a usar las nuevas funciones que nos proporciona nuestra
librería ya instalada. Si tienes alguna sugerencia o conoces algún tip para la
instalación de librerías, por favor usa la sección de comentarios para
compartir con nosotros.
1 Comment
1.
Justo on 15 enero, 2018 at 16:38
Buenas tardes
Tengo esta falla al grabar a la targeta fisica de arduino uno (atmega328) y por
que? alguien me puede ayudar por fa.
El Sketch usa 2042 bytes (6%) del espacio de almacenamiento de programa. El
máximo es 32256 bytes.
Las variables Globales usan 186 bytes (9%) de la memoria dinámica, dejando
1862 bytes para las variables locales. El máximo es 2048 bytes.
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\damellis-
PCM-ae3f463: C:\Program Files (x86)\Arduino\libraries\damellis-PCM-ae3f463
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\DS1307:
C:\Program Files (x86)\Arduino\libraries\DS1307
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\MAX6675-
library-master: C:\Program Files (x86)\Arduino\libraries\MAX6675-library-master
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\PCM-
master: C:\Program Files (x86)\Arduino\libraries\PCM-master
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\RS485:
C:\Program Files (x86)\Arduino\libraries\RS485
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\damellis-
PCM-ae3f463: C:\Program Files (x86)\Arduino\libraries\damellis-PCM-ae3f463
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\DS1307:
C:\Program Files (x86)\Arduino\libraries\DS1307
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\MAX6675-
library-master: C:\Program Files (x86)\Arduino\libraries\MAX6675-library-master
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\PCM-
master: C:\Program Files (x86)\Arduino\libraries\PCM-master
Librería inválida encontrada en C:\Program Files (x86)\Arduino\libraries\RS485:
C:\Program Files (x86)\Arduino\libraries\RS485
Reply
Trackbacks/Pingbacks
1. Termómetro con Arduino y DS18B20 - Geek Factory - […] en nuestro termómetro se
muestra a continuación. Para que compile correctamente es necesario tener instalada la
librería de control…
2. LCD 16x2 por I2C con Arduino usando solo dos pines - Geek Factory - […] explicamos en
alguna ocasión como cargar una librería y comenzar a utilizarla, si tienes dudas te
recomendamos revisar el…
3. Shield o Módulo GPS con Arduino Introducción - Geek Factory - […] Como se puede ver
en el ejemplo anterior sobre sentencias NMEA, sacar la información de navegación puede
ser una…
4. Tutorial Sensor Ultrasónico HC-SR04 y Arduino - Geek Factory - […] ultrasónico HC-
SR04 y Arduino para la medición de distancia. Ya hemos explicado con anterioridad como
se realiza la instalación de…
5. Controlar tu arduino desde la PC mediante comandos de texto - Geek Factory - […] La
librería puede descargarse desde github en el enlace que se muestra a continuación. Si
deseas saber como se…
Mitos de Arduino: Las baterias duran poco

para alimentar un arduino.
by Admin | May 28, 2013 | Tutoriales Arduino | 13 comments
Muchas personas que han intentado alimentar una

tarjeta arduino con baterías pueden encontrarse con la situación de que la carga
de la batería dura poco: solo un par de días. La solución puede ser aumentar el
tamaño o número de las baterías, pocas veces llegando al resultado deseado, aún
cuando la batería llega a ser bastante grande (en tamaño físico y en capacidad de
almacenamiento de energía). Otras veces la reacción inmediata podría ser buscar
un microcontrolador que sea considerado “de bajo consumo” ya que la primera
impresión es que el chip ATMega328 es bastante “comelon” en cuanto a baterías.
En este post intentamos aclarar porqué sucede esto y como podemos
diseñar aplicaciones con Arduino basadas en el ATMega328 que utilicen
la energía de forma eficiente.
Hay que aclarar que NO estamos hablando de usar baterías durante 5
minutos para enseñarle al profesor un programa, o para mostrarle a tus amigos
como funciona tu último Gadget hecho en casa. Estamos hablando de utilizar un
grupo de pilas (AA, por ejemplo) para alimentar permanentemente una tarjeta
durante el mayor tiempo posible. En estos casos, el uso de la energía durante
periodos de inactividad y cualquier fuga de energía debe considerarse como
importante.
Comenzaremos por explicar algunos puntos que hacen que la batería se
desperdicie al utilizar un arduino, de manera que podamos hallar soluciones
para optimizar el uso de la energía.
1. La mayoría de las tarjetas Arduino (y compatibles) usan un regulador
lineal basado en alguna variante del LM1117. Un regulador lineal tiene la
desventaja de ser poco eficiente, ya que transforma la energía que no llega a la
carga en calor.
El regulador del Arduino es similar al LM7805. Estos reguladores se calientan por que la diferencia de voltaje
entrada-salida se transforma en calor.
Imaginemos por un momento que utilizamos una batería de plomo-acido de 12
volts para alimentar un Arduino UNO que consume 50mA, y cuyo voltaje regulado
de operación es de 5 volts. Entonces la energía disipada en forma de calor en el
regulador es de P = (12 – 5 ) * 0.05A = 0.35 W mientras que la energía usada por
el microcontrolador es de P = 5V * 0.05A = 0.25W. Como podemos observar, la
mayoría de la energía (58%) se va como calor en el regulador en vez de
realizar un trabajo útil.
2. Los reguladores lineales siempre utilizan corriente, aunque no tengan
carga conectada. Esta es una acaracterística del dispositivo y podemos encontrar
información sobre este parámetro en la hoja de datos del regulador bajo el nombre
de “Quiescent Current”. Esto es una medida necesaria para la operación y
polarización de los circuitos internos del regulador y aunque generalmente es una
corriente bastante pequeña, es importante mencionarla. Existen reguladores
de ultra baja corrienteen espera que ayudan a mitigar este problema, pero
siempre se va a requerir de una pequeña corriente para el funcionamiento del
regulador.
3. El voltaje de operación de la mayoría de las tarjetas Arduino es de 5
Volts. El rango de operación del microcontrolador ATMEGA328 va de los 1.8
Volts a los 3.3 Volts. Mientras que la mayorría de microcontroladores de “bajo
poder” están en el rángo de 1.8 a 3.3 Volts.
Gráfica de la corriente requerida por el ATMEGA328 a diferentes voltajes y frecuencias de operación
Se puede apreciar que el ATMEGA328 corriendo a 8 Mhz es capaz de funcionar
a 2.7 volts con menos de 2 mA mientas que a 5 volts demanda una corriente
de 4 mA. Esto implica ahorros de cerca del 50% de energía.
4. La mayoría de los osciladores funcionan a 16 Mhz. A mayor frecuencia de
reloj, mayor consumo de energía. Esto es claramente visible en el gráfico anterior.
Para muchos escenarios de “bajo poder” el uso del micro a 16 Mhz es exagerado.
Podemos aumentar la vida útil de las baterías usando cristales de 8 Mhz o bien
utilizar el oscilador interno del ATMEGA328.
El arduino utiliza un cristal de 16 Mhz que esta bastante sobrado para aplicaciones de bajo consumo de
energía.
5. Uso desmesurado de delays y programas que nunca pasan a modo de
bajo consumo (sleep).El problema que debe resolver un ingeniero para lograr un
producto de bajísimo consumo de energía va más alla del hardware. El software
también desempeña un papel importante en el consumo de energía de un
producto, y caso de que pensemos utilizar un programa con arduino durante un
periodo de tiempo considerable utilizando baterías, conviene evitar al máximo
el tiempo de pasamos en rutinas de retardos.
Con estos 5 factores cubrimos aspectos que uno puede pasar por alto fácilmente y
que pueden consumir bastante energía. Como podrás ver, se trata de factores que
caen predominantemente en el terreno del hardware, aunque el uso de energía
también podría verse afectado por cuestiones de software que por ahora
reservaremos para otra entrada.
De momento no me queda mas que invitarte a que nos hagas llegar tus
comentarios más abajo… ¿Como has hecho para exprimir el máximo de esos
mili-amperes hora en tus baterías?
Utiliza un relé con tu placa Arduino
28/11/2016
 Hardware
 Software
me gusta
13+
Dificultad media



¿Qué es un relé?
Cuando estamos desarrollando nuestros “inventos” a menudo sentimos la
necesidad de poder encender y apagar aparatos eléctricos de nuestro entorno.
Por ejemplo, imaginemos que queremos bajar o subir las persianas utilizando un
motor eléctrico, necesitaríamos activar o desactivar dicho motor, que
habitualmente funciona a 220V. También podríamos querer hacer que
nuestra lámpara nocturna fuera de verdad una lámpara y poder encender y pagar la
lámpara de nuestra mesilla.
Para poder realizar esto necesitaríamos un interruptor que pudiéramos activar y
desactivar desde nuestra placa Zum. Pues bien, ese interruptor se llama relé.
Si buscamos en Wikipedia leemos:
El relé (en francés, relais, “relevo”) o relevador es un dispositivo electromagnético.

Funciona como un interruptor controlado por un circuito eléctrico en el que, por
medio de una bobina y un electroimán, se acciona un juego de uno o varios
contactos que permiten abrir o cerrar otros circuitos eléctricos independientes. Fue
inventado por Joseph Henry en 1835.
¿Qué quiere decir esto? Quiere decir que si activamos el relé, poniendo a 5 Voltios
el pin de control dejará pasar la corriente (se cierra el circuito interruptor), mientras
que si la tensión es 0 Voltios se interrumpirá la corriente.
Cuando compremos un relé deberemos tener en cuenta el voltaje del aparato
eléctrico que deseemos controlar ya que existen relés para 12 Voltios, 24 V, 110
V, 220 V, etc. Es importante que también tengas en cuenta de que lo que estás
haciendo es peligroso, y por lo tanto hay que realizarlo con las medidas de seguridad
adecuadas y nunca por niños que no estén acompañados por adultos.
¿Cómo se conecta?
Veamos cómo conectar el relé a nuestra placa y al aparato eléctrico que queramos
controlar. En este caso, estamos utilizando un componente que tiene dos relés,
pero sólo utilizaremos uno de ellos.
Como podemos observar, el relé tiene tres pines:
 Tierra o GND, que deberá conectarse a uno de los pines marcados como GND.
 Tensión, o VCC, que deberá conectarse a uno de los pines marcados como 5 Voltios.
 Señal, o Sgn, que es un pin digital a través del cuál indicamos si el relé estará abierto
o cerrado. Lo conectamos a cualquiera de los pines digitales.
Por otro lado conectaremos el cable del aparato eléctrico que queramos controlar.
Habitualmente los aparatos eléctricos tienen 2 o 3 cables:
 Un cable de color negro o fase L (es por donde llega la energía)
 Otro azul o neutro N (por donde la energía regresa a la fuente)
 Hay aparatos eléctricos que además incluyen un cable de color amarillo/verde o toma
a tierra TT
Pues bien, nosotros debemos conectar al relé el cable de fase. Entonces el relé
funcionará igual que si estuviéramos usando un interruptor, sólo que en lugar de
encenderlo y apagarlo con la mano lo haremos a través de la placa controladora.
A continuación incluimos el esquemático. Como puedes ver, dado que sólo

conectamos un relé, sólo aparece el que estamos utilizando. Esperamos que os
ayude a realizar las conexiones entre componentes.
¿Cómo controlamos el relé?

Para abrir o cerrar el circuito del relé simplemente tendremos que poner el pin de
señal a 5 o a 0 Voltios.
Programándolo en Bitbloq
Seguimos los siguientes pasos:
Para la programación en Bitbloq no debemos conectar nada en la pestaña de

Hardware, ya que el componente relé no está incluido entre los componentes
disponibles.
A la hora de programarlo debemos ir a Componentes>>Avanzados
Escogemos el bloque Escribir en el pin digital … el valor digital … Supongamos que
hemos conectado la señal del relé al pin digital 2. Entonces, para activarlo
pondríamos el bloque del siguiente modo:
En el caso de querer desactivarlo modificaremos el bloque del siguiente modo:
Por ejemplo, si tuviéramos conectado al relé una lámpara de mesilla que

queremos encender cuando hay poca luz podríamos hacer un programa como el
siguiente:
Programándolo con código Arduino

La programación en Arduino es igualmente sencilla. Si por ejemplo queremos
activar el relé lo haremos del siguiente modo:
1 const int rele = 2;

2
3 /*** Setup ***/
4 void setup() {
5 pinMode(rele,OUTPUT);
6 }
7
8 /*** Loop ***/
9 void loop() {
10 digitalWrite(rele, HIGH);
11 }
Ya estás listo para controlar los electrodomésticos de tu casa. Con precaución
puedes hacer cosas realmente interesantes. Por ejemplo, te proponemos que
realices un montaje para controlar de manera independiente dos luminarias en
casa. Para ayudarte aquí tienes el esquemático. ¡Mucha suerte!
Curso de introducción a MIT App
Inventor
22/04/2015
 Hardware
 Software
me gusta
30+
Dificultad media



En este curso aprenderás a utilizar App Inventor para crear tus propias
aplicaciones, que podrás distribuir fácilmente e incluso subir a la tienda de
aplicaciones Play Store.
Video Player
00:00
00:17
App Inventor es una herramienta desarrollada por Massachusetts Institute of Technology

(MIT) para facilitar el proceso de crear aplicaciones para Android, en comparación con la
programación tradicional de aplicaciones Android. Se basa en una interfaz web en la que
desarrollaremos la aplicación, mediante programación por bloques, y una Companion App,
o aplicación “compañera”, en la que se visualizarán en tiempo real las modificaciones que
se realicen en la interfaz web y donde podremos ir probando nuestra aplicación a medida
que la desarrollemos.
Estos son los contenidos que se verán durante el curso.
Fundamentos de uso y programación en App Inventor

En la primera parte del curso aprenderás como instalar y utilizar App Inventor,
además de conocimientos básicos sobre bucles de control, variables y como crear
una interfaz de usuario que se adapte a tus necesidades.
 Instalando App Inventor, primeros pasos y “¡hola mundo!”
 ¿Como funciona una aplicación en App Inventor?
 Bucles de control, variables y bloques de App Inventor
 Creando interfaces de usuario (UI)
Interacciones con la interfaz

En la segunda parte del curso aprenderás a incluir objetos dentro de la pantalla e
interactuar con ellos. Además aprenderemos a utilizar los sensores para, después,
controlar un printbot mediante los programas que generemos.
 Moviendo imágenes con botones
 Acciones basadas en el tiempo
 Usando los sensores del terminal: Acelerómetro y sensor de orientación
 Detectando gestos
 Moviendo imágenes con gestos
 Reconocimiento de voz
Interactuando con Arduino

En la parte final del curso, aprenderás como comunicar App Inventor con Arduino
a través de bluetooth y aplicaremos los conocimientos adquiridos para controlar
printbots mediante las aplicaciones que generemos.
 Comunicación bluetooth con Arduino
 Controlando un printbot con botones en App Inventor
 Controlando un printbot con gestos en App Inventor
En este curso no se explicará la programación de las placas Arduino, solo se
explicará el código relativo a la parte final del curso. Si quieres conocer más sobre
la programación de Arduino puedes seguir el Curso de programación para makers con
Arduino y Protocoder donde se explica con mayor detalle.
Puedes encontrar las descargas de este curso en GitHub:
Las lecciones de este curso de publicaran de forma periódica los viernes,
comenzando el día 24 de Abril de 2015. Nosotros utilizaremos un bq Aquaris y una
placa ZUM BT 328, pero podrás utilizar cualquier teléfono o tablet con Android y
cualquier placa Arduino. Si quieres conocer las ventajas de utilizar una placa ZUM
BT 328, como por ejemplo, integración de bluetooth, puedes ver las especificaciones
de la placa.
Instalando App Inventor, primeros

pasos y “¡hola mundo!”
24/04/2015
 Software
me gusta
12+
Dificultad media



Para comenzar a trabajar con App Inventor, en primer lugar, tenemos que acceder
a su página web. Una vez ahí, nos darán instrucciones de como configurar
un dispositivo Android conectado a la misma red wifi o un emulador. Considero que la
mejor forma de realizar este curso, y utilizar App Inventor, es mediante un
dispositivo Android conectado mediante Wifi, por lo que se va a explicar este
proceso.
Instalación y registro
En primer lugar tenemos que instalar la App Companion, es decir, la aplicación que
App Inventor utilizará como soporte para mostrar nuestros proyectos. Para ello hay
dos formas, instalando manualmente un apk o a través de Google Play Store.
Conviene instalar a través de Play Store, ya que cada vez que se produzca una
actualización en la App Companion se descargará automáticamente, por lo que
siempre estará actualizado.
Para instalar la aplicación, puedes escanear el código QR de la imagen, o pulsar
sobre este link.
A continuación, desde la interfaz web de App Inventor, tendremos que iniciar sesión
con nuestra cuenta de Google (Gmail) y aceptar los términos de servicio. Una vez
aceptados, entraremos en la interfaz de App Inventor, donde en primer lugar
configuramos el idioma para que la interfaz se muestre en Español. Para ello, en
el menú situado en la esquina superior derecha, pulsa sobre English y, dentro del
menú desplegable, escoge Español. Puedes ver una imagen de dicho menú a
continuación:
Creando un nuevo proyecto y conectado con nuestro

terminal
Después crearemos nuestro primer proyecto para comenzar con el proceso de
conexión. Para ello, pulsamos sobre “Comenzar un proyecto nuevo…” o bien
sobre “Proyectos/ Comenzar un proyecto nuevo…” donde nos pedirán introducir el
nombre de nuestro proyecto, que en este caso sera: hola_mundo.
Si se ha creado correctamente el proyecto, aparecerá la interfaz de desarrollo de

aplicación de App Inventor, que se divide en Diseñador y bloques. En diseñador
realizaremos la interfaz gráfica de usuario, o UI, y en bloques programaremos las
acciones que realizará nuestra aplicación.
Una vez que tengas la App companion instalada en tu terminal, abre dicha
aplicación y en la página web de App Inventor pulsa sobre conectar y después en
AI Companion. Aparecerá un código QR y un código alfanumérico. Dentro de la
App puedes escribir el código alfanumérico dentro del cuadro de texto o bien
escanear el código QR. Si se produce correctamente la conexión, aparecerá la
pantalla de nuestro proyecto que irá actualizándose automáticamente cada vez
que incluyamos un nuevo elemento en la interfaz gráfica.
Creando el Hola Mundo

Para crear el Hola mundo, un programa típico en los inicios de todo curso de
programación en el que se muestra un mensaje, utilizaremos una etiqueta.
App Inventor se basa en dos “modos” de trabajo, el modo “diseñador” y el modo
“bloques”. En el modo diseñador crearemos la interfaz gráfica, donde podremos
cambiar nombres, textos, etc. Por el contrario, en el modo “bloques” utilizaremos la
interfaz gráfica que hemos generado en el modo “diseñador” para realizar
acciones.
Para incluir dicha etiqueta en nuestra interfaz gráfica, busca Etiqueta en el menú
Interfaz de Usuario, que se encuentra dentro de Paleta, un “contenedor” donde se
almacenan todos los elementos que podemos utilizar.
Cuando hayas localizado Etiqueta, pulsa sobre Etiqueta y arrastralo hasta la

interfaz gráfica. Ya estará lista para modificar.
Verás que el menú Componentes ahora muestra Etiqueta1, que es el elemento que
acabamos de crear. Según vayamos creando elementos se irán agrupando en
este menú. Dentro del menú Propiedades podremos modificar diferentes aspectos
relativos a cada elemento creado. En este caso, vamos a modificar el texto por
“hola mundo” y la posición del texto la modificamos a centro.
Exportando la aplicación a nuestro terminal

El último paso es exportar la aplicación a nuestro terminal, para ello, en el menú
superior pulsamos sobre Generar y después sobre App (Generar código QR para el
archivo apk). Después se compilará nuestra aplicación y podremos instalarlo a
través de nuestro terminal. Dentro de la App Companion pulsamos sobre scan QR
code, o escanear código QR, y automáticamente nos aparecerá un dialogo para
instalar la aplicación.
En caso de que no hayas instalado un apk con anterioridad, aparecerá un mensaje
indicando que no se pueden instalar aplicaciones obtenidas de fuentes
desconocidas. Para solucionar este problema hay que activar dentro de los ajustes
del terminal la opción “Permitir la instalación de aplicaciones de origen
desconocido”. Una vez activado, podemos repetir el proceso e instalar la
aplicación.

Termopar

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Termopar

Diunggah oleh

Hak Cipta:

Format Tersedia

Termopar con Arduino y MAX6675 medición

Materiales necesarios para las prácticas del

Teoría de funcionamiento del termopar

Cómo conectar un termopar con Arduino usando

Termopar con Arduino y monitor serial

Termopar con Arduino y pantalla LCD.

Termómetro arduino con termopar y alarma de

Botón o pulsador con Arduino: Todo lo que

¿Cómo conectar un botón a arduino?

Botón con resistencia pull-up Botón con resistencia pull-down

¿Para que sirve una resistencia pull-up o pull-

Armado del circuito para las prácticas con botón o

Realizar la programación del botón o pulsador con

Eliminar rebotes y el ruido de un botón en arduino

El ruido eléctrico es otro de los problemas que debemos considerar al

Programación de botón con eliminación de rebotes

Programación avanzada de botones con arduino

Detección de pulsaciones largas en un botón

Detección de doble y triple clic en un botón usando

Alimentar el Arduino: La guía definitiva

Mecanismos de alimentación para el arduino

Como ya mencionamos, es la forma más sencilla de alimentar el arduino. A través

La tarjeta arduino viene diseñada para aceptar alimentación mediante el jack

Limitantes del regulador de voltaje (sobrecalientamiento del

Alimentar el Arduino a través del pin VIN

El pin VIN, que se localiza en el grupo de pines de alimentación y tierras cumple

Alimentación de arduino con baterías

En caso de que se requiera obtener un voltaje mayor, se pueden utilizar baterías

Termómetro con Arduino y DS18B20

Los enlaces para la descarga de las librerías se proporcionan a continuación:

DHT11 con Arduino sensor temperatura y

Protocolo de comunicación del DHT22 o DHT11

Significado de los bits transmitidos por DHT11 o

Una transmisión completa comienza como ya describimos y se compone de 40

Diagrama de conexión para DHT11 con Arduino

Código de ejemplo básico DHT11 con Arduino

6 EJEMPLO SENSOR DHT11 1

13 PARA COMUNICARSE CON EL DHT11 Y DHT22

18 // CONSTRUCTOR DEL OBJETO DHT RECIBE EL PIN EN EL QUE SE CONECTA EL SENSOR

19 // Y TAMBIEN RECIBE EL TIPO DE SENSOR QUE VAMOS A CONECTAR

20 DHT dht(2, DHT11);

23 // PREPARAR LA COMUNICACION SERIAL

25 Serial.println("Prueba del sensor DHT11");

27 // PREPARAR LA LIBRERIA PARA COMUNICARSE CON EL SENSOR

32 // ESPERAR ENTRE MEDICIONES, NECESARIO PARA EL BUEN FUNCIONAMIENTO

35 // LEER LA HUMEDAD USANDO EL METRODO READHUMIDITY

37 // LEER LA TEMPERATURA USANDO EL METRODO READTEMPERATURE

El resultado de la ejecución del programa debe ser como se muestra a

¿Cuantas veces no te ha pasado que la serigrafía en la placa de arduino no

Diagrama de Pines Arduino Mega 2560 R3 (mapa

Diagrama de Pines Arduino Leonardo (mapa de

Controlar tu arduino desde la PC mediante

Este tipo de led se encuentran en varias configuraciones. Nosotros vamos a

Uso de la librería “Shell” para controlar tu arduino

1 // Initialize command line interface (CLI)

3 // We can also pass a char pointer to display a custom start message

4 shell_init(shell_reader, shell_writer, 0);

Luego, el usuario debe asociar los comandos y las funciones, es decir,

Finalmente, dentro del ciclo principal de cada aplicación, el programador debe

1 // This should always be called to process user input

Los programas (funciones) que implementan cada uno de los comandos se

1 int command_mycommand(int argc, char** argv)

3 shell_println("Running \"mycommand\" now");