CursoIntermedioArduino 2 PDF

Curso de Intermedio de Arduin
Objetivo:
Tras finalizar el curso, los alumnos contarán con las habilidades, recursos y conocimientos
necesarios para poder planificar, diseñar, prototipar y construir por su propia cuenta
circuitos con Arduino de una complejidad intermedia.
1. Práctica 1: Módulo HL-69: Un sensor de humedad de suelo.

2. Práctica 2: DHT11: Sensor de humedad/temperatura para Arduino.
3. Práctica 3: Módulo YL-83: Un detector de lluvia.
4. Práctica 4:Sensor PIR: Detección de Movimiento Mediante Sensor Piroeléctrico
5. Práctica 5: Sensor MQ-3; un detector de Alcohol.
6. Práctica 6: Arduino y pantalla LCD 16 x 2.
7. Práctica 7:Módulo Bluetooth HC-05.
8. Práctica 8:Detección de Gas LP con el Módulo MQ-2.
9. Práctica 9:Estación Meteorológica básica (DHT11: Sensor de humedad/temperatura
y Sensor BMP-180 Sensor de Presión Barométrica).
10. Práctica 10:Guardado datos en una tarjeta Micro SD con el módulo Micro SD Card
Adapter.
Práctica 1: Módulo HL-69: Un sensor de humedad del

suelo
El módulo HL-69, un sensor de humedad de suelo utiliza la conductividad entre dos

terminales para determinar ciertos parámetros relacionados a agua, líquidos y humedad
Materiales:
1 Sensor HL-69
1 Arduino Mega o un Arduino Uno
El principio de funcionamiento de este dispositivo es prácticamente el mismo que el que

utiliza el YL-83, el detector de lluvia.
Consiste en dos placas separadas entre sí por una distancia determinada. Ambas placas
están recubiertas de una capa de material conductor. Si existe humedad en el suelo se creará
un puente entre una punta y otra, lo que será detectado por un circuito de control con un
amplificador operacional que será el encargado de transformar la conductividad registrada a
un valor analógico que podrá ser leído por Arduino. De hecho, el circuito de control es el
mismo que utiliza el módulo YL-83.
Características
Posee dos tipos de salidas, una analógica y una digital. La salida digital entregará un pulso
bajo cuando haya conductividad suficiente entre cada una de las puntas. El umbral de
disparo se puede establecer moviendo el potenciómetro del circuito de control. En la salida
analógica el nivel de voltaje dependerá directamente de cuanta humedad haya en el suelo.
Es decir, dependiendo de cuanta conductividad (producto del agua en el suelo) haya entre
las puntas del módulo, así variará el valor entregado por Arduino (entre 0 y 1023).
Nosotros en este ejemplo, solo hemos conectado a la salida analógica, ya que queremos
saber si el suelo está seco, húmedo o muy mojado:
0 - 300 muy mojado

300-700 húmedo
700-1023 seco
Estos valores dependen de la planta
Una anotación muy importante es que depende el módulo que tengamos, posiblementelos
valores cercanos a 0 es porque la planta está seca y los cercanos a 1023 es porque está muy
humedad. Les recomiendo que al cargar el programa prueben como actúa el sensor
metiéndolo en un vaso de agua.
Código:
// Sensor de Humedad
// Conectamos el sensor de la siguiente forma:
// GND -> GND
// VCC -> 5V
// DAT -> A0
int Valor;
void setup() {
Serial.begin(9600);
}
voidloop(){
Serial.print("Sensor de Humedad valor:");
Valor = analogRead(0);
Serial.print(Valor);
if (Valor <= 300)

{
Serial.println(" Encharcado");
}
if ((Valor > 300) and (Valor <= 700))
{
Serial.println(" Humedo, no regar");
}
if (Valor > 700)
{
Serial.println(" Seco, necesitas regar");
}
delay(1000);
Práctica 2:DHT11: Sensor de humedad/temperatura

para Arduino
El DHT11 es un sensor de humedad/temperatura de bajo costo y de media precisión, muy
útil para los principiantes en el mundo de Arduino
Nota: Si se desea utilizar un sensor de humedad/temperatura de alta precisión recomiendo

consultar el DHT22, parecido al DHT11 pero mucho más preciso.
En esta ocasión escribiré acerca del DHT11 que es un sensor de temperatura muy
económico y muy utilizado por los amantes de la electrónica y los microcontroladorescomo
Arduino.
El DHT11 es un sensor que proporciona una salida de datos digital. Entre sus ventajas
podemos mencionar el bajo coste y el despliegue de datos digitales. Esto supone una gran
ventaja frente a los sensores del tipo análogo, como el LM335 por ejemplo, en los cuales
las fluctuaciones en el voltaje alteran la lectura de datos.
Entre las desventajas pues, el DHT11 solo lee enteros, no podemos leer temperaturas con
decimales por lo que tenemos que pensarlo muy bien a la hora de utilizar este sensor para
trabajos en los que se requieran lecturas precisas de temperatura y/o humedad. En fin,
vamos a lo que vamos. Para poder leer datos desde este sensor de una forma sencilla
necesitamos descargar una librería que ha sido escrita para este propósito.
Hay tutoriales que explican cómo leer este sensor sin dicha librería, sin embargo el tema es
bastante complicado para alguien que no esté acostumbrado a programar. Se necesita leer
una onda cuadrada en la cual se envían los bits con separaciones de unos cuantos
microsegundos. La verdad prefiero usar la librería DHT11.
Primero descargamos los archivos que conforman esta librería. Los podemos encontrar en:
https://docs.google.com/folderview?usp=sharing&id=0B0hsUkhqWH97dHFBeTNZd2ZyR
jQ. Ahora que hemos descargado, nos vamos a la carpeta de nuestro Arduino IDE,
buscamos una carpeta llamada “libraries” y ahí descomprimimos el archivo *.rar. Nos
debe quedar así:
Ahora abrimos Arduino IDE y pegamos el siguiente código:

#include "DHT.h" //cargamos la librería DHT
#define DHTPIN 2 //Seleccionamos el pin en el que se //conectará el sensor
#define DHTTYPE DHT11 //Se selecciona el DHT11 (hay //otros DHT)
DHT dht(DHTPIN, DHTTYPE); //Se inicia una variable que será usada por Arduino para
comunicarse con el sensor
voidsetup() {
Serial.begin(9600); //Se inicia la comunicación serial
dht.begin(); //Se inicia el sensor
voidloop() {
float h = dht.readHumidity(); //Se lee la humedad
float t = dht.readTemperature(); //Se lee la temperatura
//Se imprimen las variables
Serial.println("Humedad: ");
Serial.println(h);
Serial.println("Temperatura: ");
Serial.println(t);
delay(2000); //Se espera 2 segundos para seguir leyendo //datos
Como podemos observar, no es difícil obtener lecturas de humedad y temperatura con este
sensor. Ahora solo necesitamos conectarlo a Arduino e iniciar la lectura de datos.
El GND y el VCC del sensor se conectan en sus correspondientes pines en Arduino (GND y
+5V, respectivamente). El pin “data” se conecta al pin 2, que ya declaramos en el código.
Cuando subamos el código al micro, vamos al Monitor Serial y obtenemos el siguiente

resultado:
Cada 2 segundos obtendremos una nueva lectura.
Práctica 3: Módulo YL-83: Un detector de lluvia

El módulo YL-83 es capaz de detectar gotas de agua lluvia, por lo que puede ser utilizados
para sistemas de detección que requieran realizar funciones cuando empieza a llover.
Entre los múltiples módulos que se puede encontrar en el mercado para Arduino está el YL-
83, un módulo de detección de lluvia.
Este módulo consiste en una serie de pistas conductoras impresas sobre una placa de
baquelita. La separación entre las pistas es muy pequeña. Lo que este módulo hace es crear
un corto circuito cada vez que las pistas se mojan. El agua hace que se cree un camino de
baja resistencia entre las pistas con polaridad positiva y las pistas conectadas al GND. La
corriente que fluye a través de estas pistas se ve limitada por resistencias de 10K en cada
conductor, lo que impide que el corto circuito que se genera cuando se moja la placa vaya a
estropear el micro controlador.
Este módulo consta de dos partes, la placa que se muestra en la imagen de arriba y un
pequeño circuito de control.
El circuito de control es el que posee las resistencias limitadoras de corriente y es el

encargado de alimentar el módulo YL-83. Posee un amplificador operacional,
específicamente el circuito integrado LM392. Este es el encargado de amplificar el pequeño
diferencial de voltaje que se general cuando una gota de agua cae sobre las pistas del
módulo. Aquí es donde se genera la señal de salida que puede ser del tipo analógica o
digital. La señal digital oscilará entre los valores HIGH y LOW dependiendo de si hay agua
o no sobre las pistas de la placa YL-83.
La salida analógica entregará un nivel de voltaje que variará dependiendo de la cantidad de

agua que haya sobre el módulo.
Para utilizar el módulo basta con conectar el circuito de control a los pines que se indican
en la imagen de arriba (la salida analógica a A0 y la salida digital al pin 10). El código a
utilizar es muy sencillo.
void setup() {
Serial.begin(9600);
pinMode(10, INPUT);
Voidloop() {
Serial.println(analogRead(A0)); //lectura analógica
Serial.println(digitalRead(10)); //lectura digital
delay(100);
Cuando caigan gotas de agua sobre las pistas de la placa YL-83 se mostrarán resultados en
el Monitor Serial de Arduino.
Práctica 4: Sensor PIR: Detección de Movimiento Mediante

Sensor Piroeléctrico
Con bastante frecuencia necesitamos algún sistema para detectar la presencia de personas o
animales en movimiento en un área dada. Es la base de cualquier sistema de detección de
intrusos pero también se usan mucho en las escaleras comunitarias o aseos públicos para
encender la luz en cuanto detecta el movimiento.
Todos los seres vivos desprenden calor y lo mismo ocurre con los automóviles y cualquier
otra maquinaria, y ese calor se emite en forma de radiación infrarroja que podemos detectar
con los dispositivos adecuados, como los sensores PIR.
En esta sesión nos vamos a centrar en los sensores PIR, que son elementos que detectan
cambios en la radiación infrarroja que reciben y que disparan una alarma al percibirlo.
Materiales:
1 Una Protoboard
1 Led
1 PIR HC-SR501
1 Resistencia de 330 Ω
El propio sensor PIR se puede comprar independientemente:

Sensor PIR
Pero naturalmente siempre es más cómodo de manejar con un pequeño circuito de
estabilización y control, que nos permita usarlo como un sensor digital directo.
Lo normal además es que estos sensores se recubran con pequeñas lentes de plástico
que mejoren su ángulo de detección
La imagen que se anexa, nos muestra el sensor HC-SR501 con la lente puesta y
quitada para que veamos el sensor montado (Podemos sacarla nosotros mismos, va
a presión)
HC-SR501 Sin lente
Antes de buscar nuestro Arduino, debemos saber que estos sensores PIR pueden disparar
directamente una alarma con una señal de 3.3V y son capaces de excitar pequeños relés, de
modo que no necesitamos micro controladores, si lo único que queremos es encender una
luz o dispara una alarma.
Por eso vamos a hacer, en primer lugar, un pequeño circuito de prueba como este, de modo
que nos sirva para probar el sensor, y veamos que se puede usar directamente.
Vamos a montar un circuito sencillo de detección de movimiento que encienda una LED
cuando perciba algo:
Debemos fijarnos que hay 3 pines en el lateral, que usaremos para pinchar el sensor PIR
HC-SR501 a nuestra protoboard, y aquí debajo pongo el esquema de conexiones:
Diagrama de pines
Como podemos ver enseguida, hay un par de potenciómetros que podemos usar para
ajustarlo además de un jumper para elegir modo. Vamos con ello.
Diagrama:
Código:
// Declaración de variables para los pines

constint pinLed = 6 ;
constint pinPIR = 7 ;
// Inicializa pines de entrada y salida

void setup()
{
pinMode(pinLed , OUTPUT) ;
pinMode(pinPIR , INPUT);
}
// Ciclo del estado los sensores

void loop()
{
if (digitalRead(pinPIR))
digitalWrite(pinLed , HIGH);
else
digitalWrite(pinLed , LOW);
delay(500);
}
Práctica 5: Sensor MQ-3; un detector de Alcohol

Este sensor detecta la concentración de alcohol en aire. Simplemente se conecta a una
entrada analógica de un microcontrolador como Arduino y podremos medir la
concentración de alcohol.
Características
 Alimentación: 5Vdc
 Integrado amplificador LM393 con ganancia variable mediante potenciómetro.
 2 pines de salida (salida analógica y salida de nivel TTL).
 Salida de nivel TTL válida de bajo nivel, se puede conectar directamente al

microcontrolador.
 Salida analógica de 0 ~ 5 V , el voltaje más alto equivale a una concentración más

alta.
 Condiciones de trabajo: Temperatura ambiente:-10℃ to 65℃, Humedad:≤95% RH
Materiales:
1 Una Protoboard
1 Sensor MQ-3
Diagrama:
Int lectura=0;
void setup()
{
Serial.begin(9600);
}
void loop(){
lectura=analogRead(A0);
Serial.println(lectura);
delay(100);
}
Práctica 6: Arduino y pantalla LCD 16 x 2

En este proyecto Arduino vamos a aprender a enviar información a una pantalla LCD.
Materiales:
 Arduino Mega o Arduino Uno
 Un Potenciómetro
 Un display LCD, de 16×2 o 16×4.
 Una protoboard
Diagrama:
Los Displays LCD
LCD viene del inglés LiquidCrystalDisplay, o sea Pantalla de cristal liquido. Son faciles de
encontrar en diversos formatos: 16×2 (16 caracteres x 2 líneas) o LCD 16×4 (16 caracteres
x4 líneas).
Son una opción muy sencilla de usar, y además, dan un toque muy pro a nuestros proyectos,
y por eso, en los últimos años los displays LCD han ganado mucha aceptación en productos
comerciales de todo tipo.
Básicamente porque:
 Son baratos.
 Están disponibles en varios tamaños y configuraciones.

 Son de bajo consumo.
 Muy prácticos si te basta con mostrar solo texto (y algunos caracteres especiales)..
Aunque, últimamente, estos displays suelen venir con los pines soldados, todavía hay
muchos sitios que cuando compras uno de estos, te lo envían en kit, con los pines aparte
para que los sueldes.
Lo primero que tienes que saber, es que tienes que soldarlos, y que no vale sujetar los pines
de algún modo más o menos extravagante. Las sueldas y punto. Hazte a la idea. Cualquier
otra solución acabara funcionando mal, o directamente con el display quemado.
Cuando lo tengas listo, pincha el display en la protoboard, dejando sitio para el resto de
componentes y cables, recuerda que habrá muchos, así que se generoso con el espacio que
dejas.
La conexión no es complicada, pero requiere ser cuidadoso. Así que vamos a ir paso a paso
con los diferentes cables. Empieza conectando tensión y GND a la protoboard.
Vamos ahora a a conectar la alimentación el panel LCD. Conecta el pin16 del LCD a Ground y
el 15 a 5V:
Si conectas ahora el cable USB a tu Arduino, el LCD debería iluminarse, si no, revisa tus
cables antes de seguir.
Vamos a conectar ahora, el potenciómetro de ajuste. Para ello conecta uno de los extremos
del potenciómetro a GND y el otro a 5V. El centro al pin 3 del LCD.
Aprovechemos también para dar tensión al panel LCD, El pin 1 va a GND y el 2 a tensión:
Si todo ha ido bien, ya podemos encender el dispay y probarlo. Conecta el USB a tu Arduino y
veamos. Si vas girando el potenciómetro, en algún momento tienes que ver unos cuadraditos
en la pantalla, en caso contrario revisa las conexiones. No sigas, si no ves esto.
Si ya veis las matrices de puntos en la pantalla, podemos seguir.
Vamos a conectar ya los pines de datos y control. Sin entrar en muchos detallas, no vamos a
usar todos los pines disponibles, porque no los necesitamos. Solo usaremos dos pines de
control, RS y EN y los 4 pines de datos D7, D6, D5, y D4 . No necesitamos más por ahora.
Vamos con las conexiones de control del display:
RW, LCD pin 5 GND

RS, LCD pin 4 Arduino pin 7
EN, LCD pin 6 Arduino pin 8
Y ya solo nos quedan los 4 cables de datos.

DB7, LCD pin 14 Arduino pin 12

Vamos a usar una librería de control del panel LCD, que viene incluida en nuestro Arduino.
Lo primero es que al importar la librería nos ha escrito esto:
#include<LiquidCrystal.h>
Después, hay que inicializar la librería. Creamos una instancia llamada lcd, de la clase
LiquidCrystal y le pasamos como parámetros los pines que hemos usado:
LiquidCrystallcd(7, 8, 9, 10, 11, 12); // ( RS, EN, d4, d5, d6, d7)
Debemos tener cuidado porque los pines que hemos usado, no corresponden a los ejemplos
de Arduino, así que podremos cargarlos, pero asegurarse de cambiar la línea de definición
de los pines, o no correrán.
El resto es sencillo
void setup()
{
lcd.begin(16, 2); // Fijar el numero de caracteres y de filas
lcd.print("Prometec.net"); // Enviar el mensaje
}
void loop()
{
lcd.setCursor(0, 8); // set the cursor to column 0, line 1
lcd.print(millis() / 1000); // print the number of seconds since reset:
}
Estos display son muy pesados de cablear, pero muy sencillos de utilizar.
Vamos a probar sacando un reloj (muy sencillo de momento). Si recordamos las funciones
que usamos en las últimas sesiones, podemos recuperar alguna para presentar el valor de
millis() como un reloj
#include <LiquidCrystal.h>
LiquidCrystallcd(7, 8, 9, 10, 11, 12);
void setup()
{
lcd.begin(16, 2); // Fijamos el numero de caracteres y filas
lcd.print("ITRoque"); // Aqi va el mensaje
}
void loop()
{
lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6
String s = reloj() ;
lcd.print(s) ;
}
String reloj()
{
int n = millis() / 1000 ; // Lo pasamos a segundos
int segundos = n % 60 ;
int minutos = n / 60 ;
String S = String(minutos) + ":" + String(segundos);

return (S);
}
Merece la pena, comentar algunas cosas de este código. En primer lugar en la función reloj,
calculamos los minutos y segundos a partir del reloj interno de Arduino en milisegundos,
no hay nada nuevo en esto. Pero observe que hemos definido reloj como String:
String reloj()
Eso significa que vamos a devolver un parámetro tipo String a quien nos haya llamado. En
algún punto de la función habrá que hacer un return(String).
Observe que definimos dentro de la función un string llamado s:
String S = String(minutos) + ":" + String(segundos);
En esta línea no hay que confundir (aunque se escriben exactamente igual), el tipo String
para definir S, con la función String(n) que convierte un numero n en un string de texto
para que pueda mezclar el número de los minutos y los segundos separados por un símbolo
de “:”.
Al final le añadimos un par de espacios en blanco, para evitar arrastrar fantasmas en la

pantalla.
Quita los espacios y miro lo que pasa en el cambio de minuto. ¿Cómo lo arreglarías, sin el
truco de poner esos espacios al final? Piensalo.
En la función loop, hemos usado
lcd.print(s) ;
Para sacar el mensaje de texto. Todo lo que ya sabemos de Serial.print() se usa exactamente
igual con esta instrucción. Y por último, tenemos una línea como esta:
lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6
Que lo que hace es posicionar el cursor del panel, en la posición 6 de la segunda línea, para
escribir la hora centrada.
La librería LCD, viene con varios ejemplos muy interesantes, que nos conviene probar.
Recuerda, simplemente, que tenemos que cambiar las definiciones de los pines para que
corra.
Un ejemplo particularmente interesante, es el de CustomCharacter, en el que define una

serie de símbolos especiales y los mueve por la pantalla en función de los valores que lee
de un potenciómetro.
Sin llegar a tanta sofisticación, es muy interesante que veamos cómo definir algunos
caracteres especiales, porque en la tabla base del LCD, no están incluidas ñ, acentos,
grados, o €. Así que dependiendo del uso que le deis pude seros de interés saber cómo
definir tus propios símbolos.
Definiendo tus propios caracteres
Vamos a definir un carácter propio, para digamos, el símbolo de grados centígrados, por
ejemplo.
Lo primero que tenemos que saber, es que los caracteres se definen con un array( si, de
nuevo) de 8×8, como si los dibujarais en una cuadricula de ese tamaño, y rellenando el
cuadradito completo.
Así por ejemplo para el símbolo del grado seria:

byte grado[8] =
{
0b00001100, // Los definimos como binarios 0bxxxxxxx
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};
Para montar los caracteres definidos usamos:
lcd.createChar(0, euro);
lcd.createChar(1, grado);
Y ahora ya están disponibles. Debemos tener en cuenta que solo podemos definir 8
caracteres especiales en un momento dado (Aunque podemos definir 30 arrays, de caracteres
y crearlos y meterlos sobre la marcha).
Aquí tenemos un ejemplo del programa:
#include<LiquidCrystal.h>
LiquidCrystallcd(7, 8, 9, 10, 11, 12);
byte grado[8] =
{
0b00001100,
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};
void setup()
{
lcd.begin(16, 2); // Hay que inicializar el LCD
lcd.createChar(1, grado);
lcd.setCursor(0, 0);
lcd.print("Estamos a 25");
lcd.write(1);
}
voidloop()
{
}
Y aquiteneis una foto del resultado

Estación Meteorológica básica (DHT11: Sensor de

humedad/temperatura y Sensor BMP-180 Sensor de
Presión Barométrica).
El sensor BMP180 es un sensor de presión atmosférica de alta precisión.
Se utiliza la interfaz I2C para comunicación. Las conexiones de este sensor son muy sencillas:
Para el uso de este sensor existe una librería llamada BMP180, la cual podemos descargar aquí.
Vamos a probar nuestro sensor. Primero hacemos las conexiones siguiendo la tabla de la parte
superior.
El sensor BMP180 es capaz de leer presión barométrica (absoluta) y temperatura. Por medio de
cálculos matemáticos es capaz de detectar diferencias de alturas. ¿Cómo? Pues como ya
mencionamos la Presión Atmosférica o Barométrica es inversamente proporcional a la altura sobre
el nivel del mar, es decir, a medida que nos elevamos decrece la presión. Por eso es que cuando
viajamos por carreteras que atraviesan colinas o montañas sentimos que nuestros oídos se tapan al
descender. Esto se debe a que la presión atmosférica aumenta y sentimos el efecto del aumento en
la presión. En el código que presentaré se hará una lectura inicial de la presión barométrica,
expresada en milibares. A medida que nos desplacemos hacia un punto más alto o más bajo el
sensor medirá la diferencia en la presión y la expresará como una variación en la altitud a la cual se
encuentra el sensor con respecto a la medición inicial que será considerada como 0.
Código
// Se importan las librerías
#include <SFE_BMP180.h>
#include <Wire.h>
//Se declara una instancia de la librería
SFE_BMP180 pressure;
//Se declaran las variables. Es necesario tomar en cuenta una presión inicial
//esta será la presión que se tome en cuenta en el cálculo de la diferencia de altura
double PresionBase;
//Leeremos presión y temperatura. Calcularemos la diferencia de altura
double Presion = 0;
double Altura = 0;
double Temperatura = 0;
char status;
void setup() {
Serial.begin(9600);
//Se inicia el sensor y se hace una lectura inicial
SensorStart();
void loop() {
//Se hace lectura del sensor
ReadSensor();
//Se imprimen las variables

Serial.println(" ////// ");
Serial.print("Temperatura: ");
Serial.print(Temperatura);
Serial.println(" grados C");
Serial.print("Presion: ");
Serial.print(Presion);
Serial.println(" milibares");
Serial.print("Altura relativa: ");
Serial.print(Altura);
Serial.println(" metros");
delay(2000);
void SensorStart() {
//Secuencia de inicio del sensor
if (pressure.begin())
Serial.println("BMP180 init success");
else
Serial.println("BMP180 init fail (disconnected?)\n\n");
while (1);
//Se inicia la lectura de temperatura

status = pressure.startTemperature();
if (status != 0) {
delay(status);
//Se lee una temperatura inicial
status = pressure.getTemperature(Temperatura);
if (status != 0) {
//Se inicia la lectura de presiones
status = pressure.startPressure(3);
if (status != 0) {
delay(status);
//Se lee la presión inicial incidente sobre el sensor en la primera ejecución
status = pressure.getPressure(PresionBase, Temperatura);
void ReadSensor() {
//En este método se hacen las lecturas de presión y temperatura y se calcula la altura
//Se inicia la lectura de temperatura
status = pressure.startTemperature();
if (status != 0)
delay(status);
//Se realiza la lectura de temperatura
status = pressure.getTemperature(Temperatura);
if (status != 0)
//Se inicia la lectura de presión
status = pressure.startPressure(3);
if (status != 0)
delay(status);
//Se lleva a cabo la lectura de presión,
//considerando la temperatura que afecta el desempeño del sensor
status = pressure.getPressure(Presion, Temperatura);
if (status != 0)
//Se hace el cálculo de la altura en base a la presión leída en el Setup
Altura = pressure.altitude(Presion, PresionBase);
else Serial.println("error en la lectura de presion\n");
else Serial.println("error iniciando la lectura de presion\n");
else Serial.println("error en la lectura de temperatura\n");
else Serial.println("error iniciando la lectura de temperatura\n");
El resultado que obtendremos en el Monitor Serial, cada 2 segundos es el siguiente.

Práctica 10:Guardado datos en una tarjeta Micro

SD con el módulo Micro SD Card Adapter.
Este adaptador funciona directamente con las bibliotecas incluidas en el Arduino para tarjetas SD .
Incluye un regulador de tensión y cambio a nivel local, por lo que puede operar a partir de 3 - 5
voltios de forma segura.
Dependiendo del módulo y el modelo de Arduino que vayamos a usar tendremos que realizar unas
conexiones u otras:
· Para el módulo ethernet solo es necesario encajarlo correctamente sobre la placa Arduino y
conectar el potenciómetro al Pin analógico 0.
· En el caso del módulo MICRO SD CARD Adapter es necesario hacer las siguientes conexiones:
- MOSI –> Pin 11 (La mayoría de las placas Arduino), para Arduino Mega: 51
– MISO –> Pin 12 (La mayoría de las placas Arduino), para Arduino Mega: 50
– CLK —-> Pin 13 (La mayoría de las placas Arduino), para Arduino Mega: 52
– CS ——> Pin 4
– 5V ——> 5V
– GND –> GND
– Potenciómetro conectado al Pin analógico 0
Más información en http://arduino.cc/en/Reference/SPI

El programa con sus correspondientes explicaciones (Comentarios en el código) es el siguiente:
// Escribir datos en una tarjeta SD con Arduino - Datalogger http://zygzax.com/
//Incluimos la libreria SD.
#include <SD.h>
// Guardamos en que entrada de Arduino esta conectado el pin CS del modulo.
const int chipSelect = 4;
void setup(){
// Configuramos el puerto serie para informar de fallos a traves de el.
Serial.begin(9600);
// El pin CS por defecto de la placa arduino debe ser configurado como salida
// aunque no se use (10 en la mayoria de las placas, 53 en Arduino Mega).
pinMode(10, OUTPUT);
// Si ha habido error al leer la tarjeta informamos por el puerto serie.
if (!SD.begin(chipSelect)){
Serial.println("Error al leer la tarjeta.");
return;
void loop(){
// Creamos las variable donde vamos a guardar el valor del potenciometro.
int pot=0;
// Leemos los datos del potenciometro.
pot=analogRead(0);
// Abrimos el fichero donde vamos a guardar los datos (Si no existe se crea automaticamente).
File dataFile = SD.open("valorpot.txt", FILE_WRITE);
// Si el fichero es correcto escribimos en el.
if (dataFile) {
// Escribimos en el fichero "POT: "
dataFile.print("POT: ");
// A continuacion escribimos el valor de la variable pot y saltamos a la linea siguiente.
dataFile.println(pot);
dataFile.println("-----5s-----");
// Cerramos el archivo.
dataFile.close();
// Avisamos de que se ha podido escribir correctamente.
Serial.println("impresion correcta");
// Si no pudimos escribir en el fichero avisamos por el puerto serie.

}else{
Serial.println("Error al escribir en valorpot.txt");
// Esperamos 5s para tomar la siguiente medida.
delay(5000);

CursoIntermedioArduino 2 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

CursoIntermedioArduino 2 PDF

Cargado por

Copyright:

Formatos disponibles

Curso de Intermedio de Arduin

Curso de Intermedio de Arduin

1. Práctica 1: Módulo HL-69: Un sensor de humedad de suelo.

Práctica 1: Módulo HL-69: Un sensor de humedad del

El módulo HL-69, un sensor de humedad de suelo utiliza la conductividad entre dos

El principio de funcionamiento de este dispositivo es prácticamente el mismo que el que

0 - 300 muy mojado

Estos valores dependen de la planta

if (Valor <= 300)

Práctica 2:DHT11: Sensor de humedad/temperatura

Nota: Si se desea utilizar un sensor de humedad/temperatura de alta precisión recomiendo

Ahora abrimos Arduino IDE y pegamos el siguiente código:

#include "DHT.h" //cargamos la librería DHT

#define DHTPIN 2 //Seleccionamos el pin en el que se //conectará el sensor

#define DHTTYPE DHT11 //Se selecciona el DHT11 (hay //otros DHT)

Serial.begin(9600); //Se inicia la comunicación serial

dht.begin(); //Se inicia el sensor

float h = dht.readHumidity(); //Se lee la humedad

float t = dht.readTemperature(); //Se lee la temperatura

//Se imprimen las variables

delay(2000); //Se espera 2 segundos para seguir leyendo //datos

Cuando subamos el código al micro, vamos al Monitor Serial y obtenemos el siguiente

Cada 2 segundos obtendremos una nueva lectura.

Práctica 3: Módulo YL-83: Un detector de lluvia

El circuito de control es el que posee las resistencias limitadoras de corriente y es el

La salida analógica entregará un nivel de voltaje que variará dependiendo de la cantidad de

Serial.println(analogRead(A0)); //lectura analógica

Serial.println(digitalRead(10)); //lectura digital

Práctica 4: Sensor PIR: Detección de Movimiento Mediante

El propio sensor PIR se puede comprar independientemente:

HC-SR501 Sin lente

// Declaración de variables para los pines

// Inicializa pines de entrada y salida

// Ciclo del estado los sensores

Práctica 5: Sensor MQ-3; un detector de Alcohol

 Integrado amplificador LM393 con ganancia variable mediante potenciómetro.

 2 pines de salida (salida analógica y salida de nivel TTL).

 Salida de nivel TTL válida de bajo nivel, se puede conectar directamente al

 Salida analógica de 0 ~ 5 V , el voltaje más alto equivale a una concentración más

 Condiciones de trabajo: Temperatura ambiente:-10℃ to 65℃, Humedad:≤95% RH

Práctica 6: Arduino y pantalla LCD 16 x 2

Los Displays LCD

 Están disponibles en varios tamaños y configuraciones.

Si ya veis las matrices de puntos en la pantalla, podemos seguir.

Vamos con las conexiones de control del display:

RW, LCD pin 5 GND

Y ya solo nos quedan los 4 cables de datos.

DB5, LCD pin 12 Arduino pin 10

Lo primero es que al importar la librería nos ha escrito esto:

String S = String(minutos) + ":" + String(segundos);

Observe que definimos dentro de la función un string llamado s:

String S = String(minutos) + ":" + String(segundos);

Al final le añadimos un par de espacios en blanco, para evitar arrastrar fantasmas en la

En la función loop, hemos usado

lcd.setCursor(6, 1); // Ponte en la line 1, posicion 6

Un ejemplo particularmente interesante, es el de CustomCharacter, en el que define una

Definiendo tus propios caracteres

Así por ejemplo para el símbolo del grado seria:

Para montar los caracteres definidos usamos:

Aquí tenemos un ejemplo del programa:

Y aquiteneis una foto del resultado

Estación Meteorológica básica (DHT11: Sensor de

El sensor BMP180 es un sensor de presión atmosférica de alta precisión.