domingo, 18 de marzo de 2018

Sensor de presión barométrica y temperatura BMP280

Existe el sensor BMP180 que mide únicamente la presión atmosférica, y luego sacaron el BMP280 que además de medir la presión barométrica mide también la temperatura.


El BMP280 en amazon.es está ahora (marzo 2018) en 6,99 €. En aliexpress.com está en 1,12 €.

Disponemos de un PDF con las características y otra información de interés.

Adafruit BMP280 Barometric Pressure + Temperature Sensor

Características


  • Tamaño: 15,5 x 12 mm
  • Voltaje de entrada: 1,8 - 3,6 V control sobre I2 C
  • Rango de presión: 300 ~ 1100 hPaRango de temperatura: -40 ~ 85ºC
  • Precisión absoluta de la presión del aire: ± 1 hPa
  • Precisión absoluta de la temperatura: ± 1.0ºC
  • Nivel Lógico: 3.3V
  • Consumo: 2.7μA
  • Interfaz de comunicación: I2C, SPI
Algunos proyectos incluyen resistencias. Por ejemplo el siguiente.


Algunas versiones de este sensor soportan 5V. En nuestro caso disponemos de un módulo que funciona a 3.3V, por lo que no se debe conectar directamente al bus del Arduino. Lo mejor es utilizar un adaptador de niveles, o bien si no disponemos de él se pueden usar un par de resistencias pull-up de 4.7K para conectar directamente Arduino con un componente que usa el bus I2C a 3.3V. Puede mirar el siguiente link.


Otros proyectos que usan este componente toman directamente del Arduino los 3.3V sin añadir ninguna resistencia. Por ejemplo, el siguiente proyecto.


sábado, 17 de marzo de 2018

Nivel de luminosidad con TSL2561

La TSL2561 es una pequeña plaquita que incorpora un sensor de luminosidad. Es bastante más sensible que una resistencia LDR normal, y por tanto adecuado para la mayoría de los proyectos donde pretendemos capturar si llegan más o menos lux hasta el sensor.


Características


  • es sensible a la luz visible y a luz infrarroja (IR)
  • es un sensor muy preciso que se puede usar también en proyectos profesionales exigentes
  • mide en el rango 0,1 hasta 40.000 lux
  • usa una tecnología de doble diodo, uno infrarrojo y otro de amplio esprecto
  • la placa puede alimentarse a 3.3V o a 5V




Existía una versión anterior que ya no se comercializa, pero sobre la que podemos encontrar algunas páginas con información valiosa. Por ejemplo:


Un precio muy económico.



CONEXIONES

  • VCC --> Se conecta a los 5V del Arduino.
  • GND --> Se conceta al GND del Arduino.
  • SCL --> Se conecta la pin analógico A5.
  • SDA --> Se conecta al pin analógico A4.
  • INT --> Se deja sin conectar.

LIBRERÍAS

sensorapi.ino

Referencias

Un PDF con la información técnica y enlace a la libreria.



Veamos una página recomendable.

Capturas en el monitor serie

Podemos ver cómo varía la luminosidad al hacer sombra con la mano.


Analytics

Este proyecto se podría complementar haciendo un registro de los valores que se pudiera estudiar con funciones estadísticas y gráficos. Para ello disponemos de varias plataformas que nos ayudan a tratar los datos que se obtienen con el IoT (Internet of Thing). Algunas de estas plataformas son las siguientes.


Un enlace a un podcast que habla del tema:

domingo, 11 de marzo de 2018

Encender un led con un botón en Arduino y que quede encendido

Queremos que al presionar un botón esto provoque que un led se encienda y quede encendido hasta que volvamos a presionar el botón, en entonces se apagará, permaneciendo apagado. Lo que estamos haciendo es simular, con un pulsador, el comportamiento de un interruptor de encendido apagado (on off). O dicho de otra forma, lo que queremos es que el pulsador se comporte como el interruptor de la luz que tenemos en una habitación.

Veamos el proyecto.

Material necesario

  1. Arduino UNO
  2. cable USB para conectar el Arduino al ordenador
  3. cables variados para las conexiones
  4. un pulsador de 4 patillas
  5. un led
  6. una resistencia de 220 ohomios para proteger el led
  7. una resistencia de 100 KΩ para el pull down
  8. el IDE de Arduino instalado en un PC

Esquema eléctrico


El botón de cuatro patillas se tiene que conectar en la posición correcta ya que girado 90º no funcionará. Las cuatro patillas están conectadas electricamente dos a dos antes de pulsar.

Código


 const int LED =13;  
 const int BOTON = 7;  
 int estadoBoton = 0;  
 int estadoLed = 0;  
 int oldBoton = 0;   
 void setup(){  
  Serial.begin(9600);  
  pinMode(LED,OUTPUT);   
  pinMode(BOTON,INPUT);  
 }  
 void loop() {  
  estadoBoton= digitalRead(BOTON);  
  if ((estadoBoton == 1) && (oldBoton == 0)){  
   estadoLed=1-estadoLed;  
   delay(10);  
  }  
  oldBoton = estadoBoton;  
  digitalWrite(LED, estadoLed);  
  Serial.println(estadoLed);  
 }  


En el código podemos ver porqué este proyecto se llama "Botón con memoria". Hemos tenido que crear una variable denominada oldBoton para guardar el estado anterior del botón.

Proyecto funcionando



Método 2

Una variante del proyecto está disponible en le siguiente enlace.

https://www.tinkercad.com/things/8xNexPpws9c

El código de este segundo método es el siguiente.


 int BOTON = 7;  
 int LED=13;  
 int estadoLed=LOW;  
 void setup (){  
  pinMode(BOTON,INPUT);  
  pinMode(LED,OUTPUT);  
  digitalWrite(LED,LOW);  
 }  
 void loop(){  
  while(digitalRead(BOTON)==LOW);  
  estadoLed = digitalRead(LED);  
  digitalWrite(LED,!estadoLed);  
  while(digitalRead(BOTON)==HIGH);  
 }  


En el void setup hemos añadido una línea que dice:

digitalWrite(LED,LOW); 

Esta línea, en teoría no sería necesaria ya que el led inicialmente se supone que estará apagado. Con ella forzamos a que comience estando apagado.

En el void loop tenemos una primera línea que dice:

while(digitalRead(BOTON)==LOW); 

Lo que hace la línea anterior es esperar mientras el botón no se pulse. El punto y coma al final cierra el bucle, que no hace nada más que repetirse continuamente hasta que se pulse el botón, en cuyo caso ya se salta a la siguiente línea.

La segunda línea del void loop nos dice lo siguiente.

estadoLed = digitalRead(LED); 

Esta línea toma en la variable estadoLed si el LED está encendido (1 o HIGH) o apagado (0 o LOW). Puede resultar un tanto extraño que usemos un digitalRead con el led que hemos declarado previamente como de salida (OUTPUT). Lo que se hace con ello es conseguir leer el estado (LOW o HIGH) que previamente le hemos enviado al led por el pin digital.

La tercera línea del voice loop es la siguiente.

digitalWrite(LED,!estadoLed); 

Con la línea anterior lo que hacemos es cambiar el estado del led. El símbolo de admiración (!) es una negación. Cambia 0 por 1 y 1 por 0.

En teoría el voice loop ya estaría resuelto y debería funcionar, pero en la práctica a este código le falta una línea más que solucione el problema de los rebotes. Un rebote al presionar un pulsador surge cuando el contacto que hace la parte metálica no es tan ideal como imaginamos. Al pulsar no se pasa instantáneamente del estado LOW al HIGH, o viceversa. Lo que sucede es que el contacto no es perfecto y se pueden generan ceros y unos hasta que quede bien pulsado el botón. Por ello, hemos añadido la última linea.

while(digitalRead(BOTON)==HIGH); 

La línea anterior lo que hace es esperar mientras la lectura del botón continúe arrojando unos.

Esto se puede aprecia al conectar el monitor serie y ver que los ceros y unos tardan un poco en estabilizarse al presionar el pulsador. En el método 1 si se añadió el código necesario para poder ver el monitor serial. En este segundo método no lo hemos añadido pero se podría hacer de forma análoga.

lunes, 5 de marzo de 2018

Raspberry Pi para encender y apagar un LED con los GPIO

El miniordenador Raspberry Pi dispone de los puertos GPIO que de permiten interactuar con el mundo físico y con el que podemos introducirnos en el IoT (Internet of Things) el Internet de las cosas.

En este caso vamos a ver lo más básico que consiste en encender y apagar un LED utilizando código Python.


  • Conectaremos GND, a uno de los GPIO de tierra mediante cable negro. En nuestro caso usaremos el GPIO 6.
  • Conectaremos el cable rojo, al GPIO 18.
  • Incluiremos una resistencia de 200 ohomios, da igual que la pongamos por una patilla o por la otra del led.
  • Un par de cables, hembra-macho
  • Una pequeña placa protoboard
  • La Raspberry Pi versión 1. Tener en cuenta que los pines GPIO de las versiones 2 y 3 son iguales pero difieren de los de la versión 1. Aunque, en este caso los GPIO usados el 6 y el 18 coinciden en las tres versiones.
  • Cable RJ45 para conectar al router
  • Alimentación de la Raspberry Pi con un cargador de movil. Para la versión 1 con uno normalito de 0,5A es suficiente.
  • Tarjeta SD, con el sistema operativo Raspbian. En nuestro caso la versión 4.9 (RASPBIAN STRETCH).
  • Usaremos la versión Python 3, concretamente la versión 3.5.3.
El código en Python es el siguiente.

 import RPi.GPIO  
 import time  
 RPi.GPIO.setmode (RPi.GPIO.BCM)  
 RPi.GPIO.setup (18,RPi.GPIO.OUT)  
 while True:  
  RPi.GPIO.output (18, True)  
  time.sleep(1)  
  RPi.GPIO.output (18, False)  
  time.sleep(1)  

Esto lo que consigue es hacer un blink, esto es que el led se encienda y se apague ininterrumpidamente cada segundo.



Con un bucle infinito del tipo while True la Raspberry Pi se queda ejecutando el procedimiento Python de forma indefinida y se tiene que finalizar en algún momento pulsando Control+c. Al lanzar de nuevo el programa ledonoff.py surge un mensaje avisando de que el procedimiento está en uso.


Para evitar los mensaje podemos añadir la siguiente línea.

RPi.GPIO.setwarnings(False)

Por estos motivos, hemos optado por implementar una segunda versión, que mostramos seguidamente.

Blink de un led durante un tiempo

Ahora el led permanece encendido un décimo de segundo y permanece apagado otro décimo de segundo. Esto se repite 30 veces.


 import RPi.GPIO  
 import time  
 RPi.GPIO.setmode (RPi.GPIO.BCM)  
 RPi.GPIO.setup (18,RPi.GPIO.OUT)  
   
 for i in range(30):  
  RPi.GPIO.output (18, True)  
  time.sleep(.1)  
  RPi.GPIO.output (18, False)  
  time.sleep(.1)  
 RPi.GPIO.cleanup(18)  

En esta segunda versión del código hemos sustituido el bucle while por un for que hace que la duración total del procedimiento sea aproximadamente de 6 segundos.

La última línea de código lo que hace es limpiar el uso del GPIO 18 que es el que hemos usado, por si luego se desea emplear en otros menesteres.


Con una función de Python

Esta es otra variante del programa anterior donde hemos creado la función parpadea.

 import RPi.GPIO as GPIO  
 import time  
 GPIO.setmode(GPIO.BCM)  
 GPIO.setup(18,GPIO.OUT)  
   
 def parpadea():  
  print("Comienza a parpadear el led ...")  
  for i in range(30):  
   GPIO.output(18,True)  
   print("|",end="",flush=True)  
   time.sleep(.1)  
   GPIO.output(18,False)  
   time.sleep(.1)  
  print("")  
  print("Fin")  
  GPIO.cleanup()  
   
 parpadea()  


miércoles, 25 de octubre de 2017

Hola mundo con Arduino en una LCD con bus I2C

Material utilizado

  • Arduino UNO
  • LCD 16x2
  • I2C
  • cables

Conexiones

El bus I2C se conecta al LCD por la parte de atrás de la pantalla. Luego el I2C utiliza cuatro cables para conectarse al Arduino, con esto ahorramos cables. Este es un bus muy utilizado desde hace muchos años.
  • GND --> GND
  • VCC  --> 5V
  • SDA  --> A4 pin analógico del Arduino
  • SCL  --> A5 pin analógico del Arduino

SDA es la señal de datos y SCL es la señal de reloj que usa el I2C.

Código

También se puede utilizar en una pantalla LCD 20x4.

 //Objetivo de este código: saludar en un LCD 16x2 con I2C en un arduino UNO  
 //El I2C del LCD tiene cuatro cables que van al arduino así:  
 // GND --> GND  
 // VCC --> 5V  
 // SDA --> A4  
 // SCL --> A5  
 #include <Wire.h>  
 #include <LiquidCrystal_I2C.h>  
 //Crear el objeto lcd dirección 0x3F y 16 columnas x 2 filas  
 LiquidCrystal_I2C lcd(0x3F,16,2); //  
 void setup() {  
  lcd.init();        // Inicializar el LCD  
  lcd.backlight();     //Encender la luz de fondo  
  lcd.print("Hola Mundo"); // Escribimos el Mensaje en el LCD  
 }  
 void loop() {  
  // Ubicamos el cursor en la primera posición(columna:0) de la segunda línea(fila:1)  
  lcd.setCursor(0, 1);  
  // Escribimos el número de segundos trascurridos  
  lcd.print(millis()/1000);  
  lcd.print(" Segundos");  
  delay(1000);  
 }  

Fecha y hora con el RTC DS1302 y una LCD 16x2 con I2C

Vamos a ver cómo se muestra la fecha y hora dada por un reloj de tiempo real (RTC) en una pantalla LCD de 16 caracteres por 2 filas.

Material utilizado:
  • Arduino UNO
  • pantalla LCD 16x2
  • el bus I2C para comunicarnos con la pantalla LCD
  • RTC modelo DS1302
Existen otros relojes de tiempo real (RTC) como son los modelos: DS1305, DS331. En nuestro caso el que teníamos disponible en este momento es el DS1302. Se diferencias en ciertas características técnicas y en especial en las librerías disponibles. En nuestro caso usaremos la librería DS1302.

Este es el enlace a la librería.

Las conexiones del DS1302 al Arduino UNO son las siguientes.
  • VCC pin  -> Arduino 5V
  • GND pin  -> Arduino GND
  • CLK pin  -> Arduino Digital
  • DAT pin  -> Arduino Digital 3
  • RST pin  -> Arduino Digital 2

El bus I2C nos ahorra cables para conectar la pantalla LCD. Se conecta el bus I2C a la pantalla por la parte de atrás de ésta, y luego los cuatro cables del I2C van al Arduino UNO de la siguiente manera.
  • GND --> GND
  • VCC  --> 5V
  • SDA  --> A4 pin analógico del Arduino
  • SCL  --> A5 pin analógico del Arduino
SDA es la señal de datos y SCL es la señal de reloj que usa el I2C.


El reloj de tiempo real DS1302 utiliza una pila botón grande de 3 voltios para memorizar la hora en caso de desconexión. La pila puede durar 2 o 3 años.



El código es el siguiente.

 // DS1302: RST pin -> Arduino Digital 2  
 //     DAT pin -> Arduino Digital 3  
 //     CLK pin -> Arduino Digital 4  
 //     GND pin -> Arduino GND  
 //     VCC pin -> Arduino 5V  
 #include <Wire.h>  
 #include <LiquidCrystal_I2C.h>  
 #include <DS1302.h>  
 LiquidCrystal_I2C lcd(0x3F,16,2);// if your LCD does not display,change it to 0x27 or other address  
 //to detect correct LCD i2c address, read http://osoyoo.com/2014/12/07/16x2-i2c-liquidcrystal-displaylcd/  
 DS1302 rtc(2, 3, 4);  
 void clockdate()   
 {  
     lcd.clear();   
     lcd.setCursor(0,0);  
     lcd.print(rtc.getDateStr(FORMAT_LONG,FORMAT_LITTLEENDIAN, '/'));// check 1302 library and see FORMAT_BIGENDIAN:2010-01-01;FORMAT_LITTLEENDIAN:01-01-2010  
     lcd.setCursor(11,0);  
     lcd.print(rtc.getDOWStr());  
     lcd.setCursor(14,0);  
     lcd.print("  ");  
     lcd.setCursor(0, 1) ;  
     lcd.print(rtc.getTimeStr());  
 }  
 void setup()  
 {  
  lcd.init();           // initialize the lcd  
  lcd.backlight();   
  rtc.halt(false);  
  rtc.writeProtect(false);  
  rtc.setDOW(WEDNESDAY);    //Estas tres líneas con set se han de subir la primera vez y luego  
  rtc.setTime(20,59,00);    //se han de subir una segunda vez convertidas en comentarios  
  rtc.setDate(25,10,2017);  //para que la fecha y hora no se reinicien siempre al mismo valor.  
  rtc.writeProtect(true);  
  }  
 void loop()  
 {   
  clockdate();  
  delay(1000);  
 }  


En el código existen tres líneas que utilizamos para que la placa Arduino obtenga la fecha y hora actuales. Estas son las que yo he utilizado:

  • rtc.setDOW(WEDNESDAY); 
  • rtc.setTime(20,59,00);
  • rtc.setDate(25,10,2017);

Si se desconecta de la alimentación el Arduino y luego se vuelve a conectar él ejecuta nuevamente su código aprendido y volverá a iniciarse en la fecha y hora de la programación que conserva en memoria, por lo que los datos que ofrezca ya estarán desactualizados.

Para solucionar este problema debemos convertir estas tres líneas en comentarios y cargar nuevamente el código en la placa Arduino. Cuando desconectemos la placa de la alimentación y luego volvamos a conectarla se tomará la fecha y hora del reloj de tiempo real. De esta forma conseguiremos estar en la fecha y hora correctas.

jueves, 14 de mayo de 2015

Majarduino: Reto 2. Ultrasonidos

Reto 2


Ultrasonidos

  1. Comprender funcionamiento de los sensores de ultrasonidos y darles aplicación
  2. La detección
    • Mostrar por puerto serie como varia la distancia de obstáculos delante del sensor
    • Mostrar como se acerca o aleja un objeto del sensor en un conjunto de 5 leds de tal forma que si está muy lejos el objeto todos los leds estén apagados y a medida que se acerca el objeto se van encendiendo progresivamente.
    • Marcar la proximidad de un objeto con el pitido de un zumbador.
Materiales

  • Arduino 1
  • Protoboard
  • Sensor de ultrasonidos (HC-SR04) x 1
  • Leds de color al gusto x 5
  • Mazo de diferentes cables