¿Qué es un DHT11/DHT22?

El DHT11 y el DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad.

Estos sensores disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino.

Ambos sensores presentan un encapsulado de plástico similar. Podemos distinguir ambos modelos por el color del mismo. El DHT11 presenta una carcasa azul, mientras que en el caso del sensor DHT22 el exterior es blanco.

De ambos modelos, el DHT11 es el hermano pequeño de la familia, y cuenta peores características técnicas. El DHT22 es el modelo superior pero, por contra, tiene un precio superior.

Las características del DHT11 son realmente escasas, especialmente en rango de medición y precisión.

• Medición de temperatura entre 0 a 50, con una precisión de 2ºC
• Medición de humedad entre 20 a 80%, con precisión del 5%.
• Frecuencia de muestreo de 1 muestras por segundo (1 Hz)

El DHT11 es un sensor muy limitado que podemos usar con fines de formación, pruebas, o en proyectos que realmente no requieran una medición precisa.

Por el contrario, el modelo DHT22 tiene unas características mucho más aceptables.

• Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
• Medición de humedad entre 0 a 100%, con precisión del 2-5%.
• Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

EL DHT22 (sin llegar a ser en absoluto un sensor de alta precisión) tiene unas características aceptables para que sea posible emplearlo en proyectos reales de monitorización o registro, que requieran una precisión media.

Esquema de montaje

La conexión del DH11 y el DHT22 son idénticas, ya que como hemos comentado la única diferencia entres modelos son sus prestaciones. En ambos casos, disponemos de 4 patillas, de las cuales usaremos 3, Vcc, Output y GND.

Conectar el sensor es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El esquema eléctrico queda como la siguiente imagen

Mientras que el montaje en una protoboard sería el siguiente.

Código de ejemplo

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único conductor, empleando señales temporizadas.

En cada envío de medición el sensor envía un total de 40bits, en 4ms. Estos 40 bits corresponden con 2 Bytes para la medición de humedad, 2 Bytes para la medición de temperatura, más un Byte final para la comprobación de errores (8bit integral RH data + 8bit decimal RH data + 8bit integral T data + 8bit decimal T data + 8bit check sum)

Podemos leer los datos del sensor directamente generando y leyendo las señales temporizadas según el protocolo del DHTXX. En general, lo normal es que empleemos una librería existente para simplificar el proceso.

Existen varias librerías disponibles. Por ejemplo, podemos usar la Librería de Adafruit.

Descargamos e instalamos la librería y cargamos el código de ejemplo, o la siguiente versión simplificada

#include "DHT.h"
 
// Descomentar el que sera usado, en este caso el DHT22.
//#define DHTTYPE DHT11		// DHT 11
#define DHTTYPE DHT22   	// DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21		// DHT 21 (AM2301)
 
// Conectar el pin 1 (en la izquierda) del sensor a +5V.

// NOTA: Si estas usando una placa con lógica 3.3V
// como la de Arduino Due, conectar el pin 1 a 3.3V en vez de 5v.

// Conectar el pin 2 del sensor a cualquiera que sea tu DHTPIN.
// Conectar el pin 4 (en la derecha) del sensor a GROUND.

// Conectar el una resistencia de 10K desde el pin 2 (data)
// al pin 1 (power) del sensor.
 
const int DHTPin = 5;		// A qué pin digital estamos conectados.
 
DHT dht(DHTPin, DHTTYPE);
 
void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
 
   dht.begin();
}
 
void loop() {
   // Esperar un par de segundos entre mediciones.
   delay(2000);
 
   // Leer temperatura o humedad toma aproximadamente 250ms.
   float h = dht.readHumidity();
   float t = dht.readTemperature();
 
   if (isnan(h) || isnan(t)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
 
 
   Serial.print("Humidity: ");
   Serial.print(h);
   Serial.print(" %\t");
   Serial.print("Temperature: ");
   Serial.print(t);
   Serial.print(" *C ");
}

Cargamos el programa en Arduino, y empezaremos a recibir por el puerto serie los valores de temperatura y humedad.

¿Qué es un Detector de obstáculos IR?

Un detector de obstáculos infrarrojo es un dispositivo que detecta la presencia de un objeto mediante la reflexión que produce en la luz. El uso de luz infrarroja (IR) es simplemente para que esta no sea visible para los humanos.

Constitutivamente son sensores sencillos. Se dispone de un LED emisor de luz infrarroja y de un fotodiodo (tipo BPV10NF o similar) que recibe la luz reflejada por un posible obstáculo.

Los detectores de obstáculo suelen proporcionarse con una placa de medición estándar con el comparador LM393, que permite obtener la lectura como un valor digital cuando se supera un cierto umbral, que se regula a través de un potenciómetro ubicado en la placa.

Este tipo de sensores actúan a distancias cortas, típicamente de 5 a 20mm. Además la cantidad de luz infrarroja recibida depende del color, material, forma y posición del obstáculo, por lo que no disponen de una precisión suficiente para proporcionar una estimación de la distancia al obstáculo.

Pese a esta limitación son ampliamente utilizados para la detección de obstáculos en pequeños vehículos o robots. Su bajo coste hace que sea frecuente ubicarlos en el perímetro, de forma que detectemos obstáculos en varias direcciones.

También son útiles en otro tipo de aplicaciones como, por ejemplo, detectar la presencia de un objeto en una determinada zona, determinar una puerta está abierta o cerrada, o si una máquina ha alcanzado un cierto punto en su desplazamiento.

Esquema de montaje

El montaje es sencillo. Alimentamos el módulo a través de Vcc y GND conectándolos, respectivamente, a la salida de 5V y GND en Arduino.

Finalmente, conectamos la salida digital del sensor a una entrada digital para leer el estado del sensor.

Opcionalmente, calibramos el umbral de disparo acercando un objeto al detector de obstáculos y regulando la salida digital con el potenciómetro. Si quieren omitir este paso, dejen el potenciómetro en un valor medio.

Código de ejemplo

El código es igualmente sencillo. Simplemente leemos el estado de la entrada digital, tal y como vimos en la entrada Entradas digitales en Arduino.

Si el sensor se dispara, ejecutamos las acciones necesarias.

const int sensorPin = 9;
 
void setup() {
  Serial.begin(9600);   			//iniciar puerto serie
  pinMode(sensorPin , INPUT);		//definir pin como entrada
}
 
void loop(){
  int value = 0;
  value = digitalRead(sensorPin );	//lectura digital de pin
 
  if (value == HIGH) {
      Serial.println("Detectado obstaculo");
  }
  delay(1000);
}

Introducción

La familia SCT-013 son sensores de corrientes no invasivos que permiten medir la intensidad que atraviesa un conductor sin necesidad de cortar o modificar el conductor.

La serie SCT-013 son sensores que trabajan como transformadores, la corriente que circula por el cable que deseamos medir actúa como el devanado primario (1 espira) e internamente tiene un devanado secundario que dependiendo del modelo pueden tener hasta más de 2000 espiras.

La cantidad de espiras representa la relación entre corriente que circula por el cable y la que el sensor nos entrega, esta relación o proporción es la que diferencia entre los diferentes modelos de sensores SCT-013, adicionalmente pueden tener una resistencia de carga en la salida de esta forma en lugar de corriente se trabaja con una salida voltaje.

A este tipo de sensores se los conoce como Sensores CT (Current transformers), que como se explicó son transformadores, Por el núcleo solo debe de atravesar una sola línea, si pasamos por ejemplo los dos cables de una conexión monofásica, nuestra lectura será 0, puesto que los cables tienen corrientes opuestas.

Una ventaja de SCT-013 es que no necesitamos interrumpir (cortar) el cable que vamos a medir, esto porque al igual que una pinza amperométrica tiene el núcleo partido.

¿Qué hace el "Sensor Sharp GP2Y0A02YK0F"?

El Sharp GP2Y0A02YK0F es un sensor de distancia óptico. Está compuesto por un LED infrarrojo junto con dispositivo detector de posición (PSD) y un procesador integrado encargado de realizar el cálculo de la distancia.

El sensor escanea de forma continua los objetos ubicados en frente suyo y proporciona la salida mediante una referencia de tensión analógica, por lo que podemos emplear las entradas analógicas de Arduino para leer el valor de la distancia.

El rango de medición es de 20 a 150 cm, manteniendo un grado de precisión elevado en todo el intervalo. La tensión de alimentación es de 4.5 a 5.5V y el consumo de corriente de 33mA. El intervalo de refresco entre mediciones es de unos 80ms.

El GP2Y0A02YK0F es un dispositivo sencillo de conectar y usar. Sin embargo hay que tener en cuenta que incorpora un conector JST (Japanese Solderless Terminal) para su conexión, por lo que tendremos que emplear un conector de este tipo o soldar directamente los terminales en la placa.

El sensor Sharp es más preciso que los sensores de ultrasonidos como el HC-SR04, especialmente en distancias medias y largas, donde los sensores de ultrasonidos ven afectadas sus mediciones por los rebotes y ecos que producen las geometrías del entorno.

Sin embargo no puede operar en distancias cortas (<20cm) donde el HC-SR04, aunque con baja precisión, al menos puede realizar mediciones.

Por otro lado, el sensor Sharp tiene una zona de medición más estrecho que el HC-SR04, lo cual permite obtener mayores para mediciones en frente del objeto. Por contra, ignorar objetos que el HC-SR04 si detectaría por su mayor ángulo de medición (por ejemplo, las patas de una mesa).

Podemos usar el GP2Y0A02YK0F en nuestros robots para medición de distancias en rangos medios y largos en un haz estrecho. Dadas sus diferentes características, podemos combinarlos con sensores ultrasonido tipo HC-SR04 para rangos cortos o amplios, o sensores de detección de obstáculos para distancias muy cortas.

El sensor Sharp también tiene puede ser empleado en otro tipo de aplicaciones como, por ejemplo, sistemas Touch-Less, control de iluminación, sensores de posición, fines de carrera o detección de objetos en un determinada zona.

¿Cómo funciona un Sensor Sharp GP2Y0A02YK0F?

El emisor LED infrarrojo emite un haz de luz pulsada infrarroja con una longitud de onda de 850nm +/-70nm. Se envía una luz pulsada para minimizar la influencia de la luz ambiente y del color del objeto en la medición.

El detector de posición PSD (position sensitive detection) es en realidad es un pequeño sensor CCD lineal que recibe la luz reflejada en cualquier objeto en la trayectoria del rayo. El sensor emplea triangulación para determinar la distancia del sensor a los objetos ubicados frente al rayo.

La salida analógica tienen un valor de 2.5V a 20 cm, y de 0.4 a 150cm. Sin embargo, como hemos mencionado, la respuesta es no lineal por lo que es necesario interpolar el valor para obtener un nivel de precisión adecuado.

Esquema de montaje

El esquema de montaje es sencillo. Por un lado, alimentamos el sensor mediante Vcc y GND conectándolos, respectivamente, a 5V y GND de Arduino.

Finalmente, conectamos el pin de señal a una de las entradas analógicas de Arduino.

Código de ejemplo

El siguiente código realiza la medición de la salida del sensor empleando las entradas analógicas de Arduino. A continuación, realiza la interpolación para obtener la distancia en centímetros.

Finalmente, muestra los valores por pantalla empleando el puerto serie. En un montaje real, usaríamos esta zona para hacer las acciones necesarias, como detener un robot o activar un mecanismo.

const int sensorPin = A0;
const long referenceMv = 5000;
 
void setup() {
   Serial.begin(9600);
   pinMode(ledPin, OUTPUT);
}
 
void loop() {
   //lectura de la tensión
   int val = analogRead(sensorPin);
   int mV = (val * referenceMv) / 1023;
   int cm = getDistance(mV);
 
   
   //mostrar valores por pantalla
   Serial.print(mV);
   Serial.print(",");
   Serial.println(cm);
 
   delay(1000);
}
 
//interpolación de la distancia a intervalos de 250mV
const int TABLE_ENTRIES = 12;
const int INTERVAL  = 250;
static int distance[TABLE_ENTRIES] = {150,140,130,100,60,50,40,35,30,25,20,15};
 
int getDistance(int mV) {
   if (mV > INTERVAL * TABLE_ENTRIES - 1)      return distance[TABLE_ENTRIES - 1];
   else {
      int index = mV / INTERVAL;
      float frac = (mV % 250) / (float)INTERVAL;
      return distance[index] - ((distance[index] - distance[index + 1]) * frac);
   }
}

Introducción

En esta guía, usted aprenderá cómo utilizar un sensor de agua para detectar si está lloviendo. También se puede utilizar para detectar el nivel de agua en un depósito.

¿Qué es un sensor de humedad del suelo?

Es un sensor que mide la humedad del suelo por la variación de su conductividad. No tiene la precisión suficiente para realizar una medición absoluta de la humedad del suelo, pero tampoco es necesario para controlar un sistema de riego.

¿Para qué se utiliza?

Son ampliamente empleados en sistemas automáticos de riego para detectar cuando es necesario activar el sistema de bombeo.

¿Cómo funciona?

Se distribuye con una placa de medición estándar que permite obtener la medición como valor analógico o como una salida digital, activada cuando la humedad supera un cierto umbral.

Los valores obtenidos van desde 0 sumergido en agua, a 1023 en el aire (o en un suelo muy seco). Un suelo ligeramente húmero daría valores típicos de 600-700. Un suelo seco tendrá valores de 800-1023.

La salida digital dispara cuando el valor de humedad supera un cierto umbral, que ajustamos mediante el potenciómetro. Por tanto, obtendremos una señal LOW cuando el suelo no está húmedo, y HIGH cuando la humedad supera el valor de consigna.

El valor concreto dependerá del tipo de suelo y la presencia de elementos químicos, como fertilizantes. Además, no todas las plantas requieren la misma humedad, por lo que lo mejor es que hagáis una pequeña calibración en el terreno real.

DS18B20: Sensor de Temperatura para Líquidos

Introducción

Con esta guía rápida, usted aprenderá como configurar un sensor de temperatura para líquidos DS18B20 con Arduino.

¿Qué es un sensor de temperatura de líquidos?

El DS18B20 es un sensor digital de temperatura que utiliza el protocolo 1-Wire para comunicarse. El encapsulado de fabrica es tipo TO-92 similar al empleado en transistores pequeños.

Es fabricado por Maxim Integrated y la presentación comercial más utilizada por conveniencia y robustez es la del sensor dentro de un tubo de acero inoxidable resistente al agua.

¿Para qué se utiliza?

• Control de temperatura de piletas, acuarios o termotanques
• Automatización de temperatura en fluidos de alta densidad (esmaltes, comestibles, grasas, etc).

¿Cómo funciona?

El sensor de temperatura DS18B20 se comunica de forma digital. Cuenta con tres pines, dos de alimentación y uno de datos. Tiene con una precisión de 9 a 10 bits desde -55C a 125C y un margen de error de tan solo 0.5 grados.

¿Qué es un sensor TCRT5000L?

Un TCRT5000L es un tipo de sensor óptico reflectivo que detecta la diferencia de color en un objeto mediante la reflexión de la luz en el mismo.

El TCRT5000L es un sensor sencillo. Dispone de un LED emisor de luz infrarroja, y de un fototransitor que recibe la luz reflejada por un posible obstáculo. La cantidad de luz recibida depende del color y reflectividad del objeto, por lo que podemos distinguir entre zonas y oscuras de un objeto.

Estos sensores suelen proporcionarse con una placa de medición estándar con el comparador LM393, que permite obtener la lectura como un valor digital cuando se supera un cierto umbral, que se regula a través de un potenciómetro ubicado en la placa. Podemos capturar esta señal con las entradas digitales de Arduino.

El rango de medición del sensor varía entre 0.2 a 15mm, siendo la distancia óptima 2.5mm. Por tanto es un sensor de muy corta distancia.

La cantidad de luz infrarroja tiene una fuerte dependencia con el color, material, forma y posición del obstáculo, por lo que no disponen de precisión suficiente para proporcionar una estimación de la distancia a un objeto, simplemente es capaz de su detección.

Los sensores TCRT5000L son ampliamente utilizados para hacer robots seguidores de líneas, aunque también pueden emplearse para detectar cualquier otro tipo de objeto. Por ejemplo, son empleados en impresoras para saber cuando se ha agotado el papel.

Esquema de montaje

Si usan una placa comercial, que como hemos dicho en general es recomendable, el montaje de un TCRT5000L a Arduino es realmente sencillo. Alimentamos el módulo a través de Vcc y GND conectándolos, respectivamente, a la salida de 5V y GND en Arduino.

Por otro lado conectamos la salida digital del sensor (DO) a una entrada digital para leer el estado del sensor.

Si deciden hacer todo el montaje ustedes mismos el esquema eléctrico tampoco es complicado. Simplemente necesitamos alimentar el módulo correctamente a través de las resistencias adecuadas, respetando el esquema del componente.

Código de ejemplo

Para detectar cuando el TCRT5000L pasa por encima de una zona oscura simplemente leemos el estado de la entrada digital, tal y como vimos en la entrada Entradas digitales en Arduino.

Cuando el sensor se dispara tomaremos las acciones oportunas, como detener o variar la dirección de un robot.

const int sensorPin = 9;
 
void setup() {
  Serial.begin(9600);   		//iniciar puerto serie
  pinMode(sensorPin, INPUT);	//definir pin como entrada
}
 
void loop(){
  int value = 0;
  value = digitalRead(sensorPin );  //lectura digital de pin
 
  if (value == LOW) {
      Serial.println("TCRT5000L activado");  //zona oscura
  }
  delay(1000);
}

Otra forma de atender al TCRT5000L es emplear interrupciones, lo que nos simplificará el código. Sin embargo, en un robot seguidor de líneas frecuentemente usaremos de tres a cinco detectores de líneas, mientras que Arduino UNO y Nano solo tenemos dos interrupciones externas.

Introducción

En esta guía, usted aprenderá cómo utilizar un sensor de agua para detectar si está lloviendo. También se puede utilizar para detectar el nivel de agua en un depósito.

¿Qué es un sensor de lluvia?

Un sensor de lluvia es un sensor diseñado para la detección de agua, que puede ser ampliamente utilizado para detectar lluvia, nivel de agua e incluso fugas de líquidos. Es fácil de usar y muy económico

¿Para qué se utiliza?

Se puede utilizar en acuapónicos, hidropónicos o sistemas automáticos de cuidado de plantas en exterior, pero generalmente se utiliza para detectar si está lloviendo. También puede usarse para controlar la cantidad de agua que tenemos en un depósito.

¿Cómo funciona?

Uso como detector de lluvia

Para detectar si esta lloviendo con este sensor tendremos que posicionarlo horizontalmente de manera que lluvia caiga sobre el sensor, a medida que las gotas de lluvia caigan sobre el sensor se formará una película de agua sobre la superficie aumentando el valor del pin S, de esta forma podemos deducir si está lloviendo.

Uso como nivel en un deposito

Para usarlo como detector de nivel en un deposito tendremos que instalar el sensor en el interior de dicho deposito a la altura en la que queramos controlar el nivel de agua. El sensor se tiene que posicionar de manera que las líneas paralelas del sensor estén perpendiculares al nivel de agua del deposito. El pin S nos dará un valor mayor a medida que el sensor se sumerge.

¿Qué es un sensor DS18B20?

El DS18B20 es un sensor de temperaturas fabricado por la compañía Maxim Integrated. Proporciona la salida mediante un bus de comunicación digital que puede ser leído con las entradas digitales de Arduino.

El sensor DS18B20 es un sensor barato y, sin embargo, bastante avanzado. Dispone de un rango amplio de medición de -55ºC a +125ºC y una precisión superior a ±0.5°C en el rango –10°C de +85°C.

Una de las ventajas del DS18B20 es que se comercializa tanto en un integrado TO-92 como en forma de sonda impermeable, lo que permite realizar mediciones de temperatura en líquidos y gases.

El DS18B20 emplea un bus de comunicación denominado 1-Wire propietario de la empresa Maxim Integrated, aunque podemos usarlo sin tener que pagar por ninguna tasa (es parte del precio del dispositivo).

La principal ventaja del bus 1-Wire es que necesita un único conductor para realizar la comunicación (sin contar el conductor de tierra). Los dispositivos pueden ser alimentados directamente por la línea de datos, o mediante una línea adicional con una tensión de 3.0 a 5.5V.

Dentro del mismo bus 1-Wire podemos instalar tantos sensores como deseemos. Además, el bus 1-Wire permite emplear cables más largos que otros sistemas antes de que se deteriore la comunicación.

El DS18B20 también dispone de un sistema de alarma que permite grabar en la memoria no volátil del DS18B20 los limites inferiores y superiores. El bus 1-Wire permite consultar si algún dispositivo conectado ha activado una alarma.

El DS18B20 es un gran sensor para la medición de temperatura, tanto en ambientes domésticos como industriales. Sus características permiten crear redes con gran número de sensores para controlar, por ejemplo, la climatización o el sistema HVAC de un edificio comercial.

¿Cómo funciona el DS18B20?

Como hemos dicho, internamente el sensor DS18B20 es más complicado de lo que en principio podríamos creer. Está formado por un procesador con múltiples módulos, que se encargan de controlar la comunicación, medir la temperatura, y gestionar el sistema de alarmas.

Una de las principales ventajas de DS18B20 es su bus de comunicación 1-Wire que le permite realizar la transmisión empleando únicamente un cable de datos. Para ello, 1-Wire está basado en un complejo sistema de timings en la señal, entre el dispositivo emisor y el receptor.

La mayor desventaja del sistema 1-Wire es que requiere un código complejo, lo que a su vez supone una alta carga del procesador para consultar el estado de los sensores. El tiempo de adquisición total de una medición de 750ms.

El dispositivo 1-Wire permite que todos los dispositivos conectados al bus se alimenten a través de la línea de datos. Para ello, disponen de un condensador que almacena energía mientras la línea de datos está en HIGH. Este modo se denomina «modo parásito». En caso de no usar el modo parásito, los dispositivos deberán ser alimentados a una tensión entre 3.0V y 5.5V.

En cualquier caso, el bus 1-Wire requiere una resistencia de pull-up de 4k7 entre Vcc y Vq para que funcione correctamente.

Para poder dispone de múltiples dispositivos en un bus 1-Wire cada sensor dispone de una memoria ROM que es grabada de fábrica con un número de 64 bits. Los 8 primeros bits corresponden a la familia (0x28 para el DS18B20). Los siguiente 48 bits son el número de serie único. Los últimos 8 bits son un código CRC.

Esto significa que potencialmente podríamos llegar a tener 2^48 (más de 218 billones) de DS18B20 conectados en una misma red 1-Wire, además de otros tantos dispositivos de otras familias (2^28, unos 268 millones de familias de dispositivos posibles). A efectos prácticos, esto supone infinitos dispositivos.

La resolución del DS18B20 es configurable a 9, 10, 11 o 12 bits, siendo 12 bits el modo por defecto. Esto equivale a una resolución en temperatura de 0.5°C, 0.25°C, 0.125°C, o 0.0625°C, respectivamente.

Que el DS18B20 disponga de una resolución por defecto de 0.0625ºC, no significa que esa sea su precisión. Sin embargo, el DS18B20 es considerablemente preciso en todo el rango –10°C de +85°C. Pueden consultar las desviaciones medias a 3 sigma en la siguiente gráfica.

Esquema de montaje

Los dispositivos 1-Wire disponen de tres terminales

Vq, la línea de datos

• Vdd, línea de alimentación
• GND, línea de tierra
• En la siguiente imagen figura la posición de estos pines en ambos formatos del sensor, como integrado y como sonda impermeable.

Hemos comentado que el bus 1-Wire necesita una resistencia de pull-up de 4K7, y que podemos alimentar el sensor directamente a través del pin Vdd o usar el modo «parásito» y alimentarlo con la propia línea de datos.

Por tanto, el esquema más simple de conexión se muestra en la siguiente imagen, donde podemos conectar el sensor a cualquier entrada digital de Arduino.

Si representamos el mismo montaje, añadiendo la disposición que ocuparían los sensores adicionales (en caso de necesitarlos) observamos más claramente la estructura del bus 1-Wire.

Finalmente, si quisiéramos emplear el modo parásito, simplemente tenemos que conectar Vdd de todos los dispositivos a GND. De esta forma, los sensores tomarán su alimentación de la línea de datos Vq. El montaje con el modo parásito quedaría así.

Código de ejemplo

Para poder leer las temperaturas del DS18B20, necesitamos usar la librería 1-Wire y la librería Dallas Temperature.

En el primer ejemplo, leeremos un único sensor ubicado en el pin digital 5.

#include <OneWire.h>
#include <DallasTemperature.h>
 
const int oneWirePin = 5;
 
OneWire oneWireBus(oneWirePin);
DallasTemperature sensor(&oneWireBus);
 
void setup() {
   Serial.begin(9600);
   sensor.begin(); 
}
 
void loop() {
    Serial.println("Leyendo temperaturas: ");
   sensor.requestTemperatures();
 
   Serial.print("Temperatura en sensor 0: ");
   Serial.print(sensor.getTempCByIndex(0));
   Serial.println(" ºC");
 
   delay(1000); 
}

Al usar la función getTempCByIndex, el indice es el número del sensor. Con esta función podemos leer más de un sensor instalado en un bus, pero tendríamos problemas para saber qué sensor es qué índice.

Por tanto, en caso de tener múltiples sensores lo normal es que accedamos directamente por la dirección de 64 bits del dispositivo. Para saber esta dirección, tenemos que usar el siguiente sketch, que escanea el bus 1-Wire y muestra en la pantalla su dirección en hexadecimal (agrupada en 8 números de dos dígitos).

#include <OneWire.h>
 
const int oneWirePin = 5;
OneWire oneWireBus(oneWirePin);
 
void setup(void) {
  Serial.begin(9600);
  discoverOneWireDevices();
}
 
void discoverOneWireDevices(void) {
  byte i;
  byte present = 0;
  byte data[12];
  byte addr[8];
  
  Serial.println("Buscando dispositivos 1-Wire");
  while(oneWireBus.search(addr)) {
    Serial.println("Encontrado dispositivo 1-Wire en direccion");
    for( i = 0; i < 8; i++) {
      Serial.print("0x");
      if (addr[i] < 16) {
        Serial.print('0');
      }
      Serial.print(addr[i], HEX);
      if (i < 7) {
        Serial.print(", ");
      }
    }
    if ( OneWire::crc8( addr, 7) != addr[7]) {
        Serial.print("Error en dispositivo, CRC invalido!\n");
        return;
    }
  }
  Serial.println("Búsqueda finalizada");
  oneWireBus.reset_search();
  return;
}
 
void loop(void) {
  // nada que hacer aqui
}

Una vez que tengamos las direcciones de los dispositivos, podríamos realizar la lectura de múltiples sensores en el mismo bus 1-Wire.

En el siguiente ejemplo realizamos la lectura de dos sensores de los cuales ya hemos obtenido su dirección, uno en el interior y otro en el exterior de una vivienda, accediendo a través de su dirección.

#include <OneWire.h>
#include <DallasTemperature.h>
 
const int oneWirePin = 5;
 
OneWire oneWireBus(oneWirePin);
DallasTemperature sensors(&oneWireBus);
 
DeviceAddress insideThermometer = { 0x28, 0x94, 0xE2, 0xDF, 0x02, 0x00, 0x00, 0xFE };
DeviceAddress outsideThermometer = { 0x28, 0x6B, 0xDF, 0xDF, 0x02, 0x00, 0x00, 0xC0 };
 
void setup(void)
{
  Serial.begin(9600);
  sensors.begin();
  sensors.setResolution(insideThermometer, 10);
  sensors.setResolution(outsideThermometer, 10);
}
 
void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00) {
    Serial.print("Error getting temperature");
  } else {
    Serial.print(tempC);
   Serial.println(" ºC");
  }
}
 
void loop(void)
{ 
 
  Serial.println("Leyendo temperaturas");
  sensors.requestTemperatures();
  
  Serial.print("Temperatura interior: ");
  printTemperature(insideThermometer);
  Serial.print("Temperatura exterior: ");
  printTemperature(outsideThermometer);
  Serial.println("-------");
  
  delay(2000);
}

¿Qué es un joystick analógico?

Un joystick analógico es un sencillo controlador que podemos añadir a nuestros proyectos de electrónica y Arduino, que tiene la ventaja de proporcionar una cantidad de información superior a la que podríamos obtener simplemente con pulsadores.

Estos joystick son similares a las palancas de analógicas que tienen muchos mandos de videoconsolas u ordenadores, como el mando de Playstation 2, o Xbox, que se emplean cuando se necesita un control más suave y preciso del que es posible con los mandos digitales.

Internamente los joystick están formados por un sistema de balancín con dos ejes ortogonales acoplados a dos potenciómetros. Estos potenciómetros realizan la medición de la posición de la palanca en ambos ejes.

Por otro lado, uno de los ejes está apoyado en un microrruptor, lo que permite detectar la pulsación de la palanca.

Por tanto, los joystick facilitan una señal analógica para la posición de cada eje, más una señal digital para la detección de la pulsación del mando. Al disponer de la entrada en los ejes X e Y en forma analógica, podemos programar controles mucho más ricas y precisas de las que podríamos conseguir con un control digital todo/nada.

Por ejemplo, podemos aumentar la velocidad de movimiento de un brazo robótico cuanto mayor sea el valor de la medición, o hacer que un vehículo gire más o menos rápido. Si hiciéramos esto simplemente con pulsadores, sería imposible conseguir movimientos suaves, y el robot se movería «a saltos».

Este tipo de joystick son dispositivos sencillos y cómodos de usar, y nos permiten añadir un control a nuestros proyectos. Por ejemplo, podemos usarlo para controlar un servo, un brazo robótico, una torreta con un laser, o incluso vehículos y robots completos.

Esquema de montaje

El montaje de este tipo de dispositivos es sencillo. En primer lugar, alimentamos el módulo conectando Vcc y GND, respectivamente, a 5V y GND de Arduino.

Para la medida analógica en ambos ejes, conectamos las salidas VRx y VRy a dos entradas analógicas de Arduino.

Finalmente, si también queremos la señal digital del pulsador, conectamos la salida SW a una entrada digital de Arduino. Vamos a usas las resistencias de Pull-Up internas de Arduino, por lo que no es necesario resistencias adicionales.

El esquema de montaje del joystick quedaría de la siguiente forma

Mientras que el montaje, visto desde Arduino, sería el siguiente.

Código de ejemplo

El código para hacer funcionar el joystick es igualmente sencillo. Por un lado, leemos la posición de ambos potenciómetros mediante mediante las entradas analógicas.

Respecto al pulsador, usamos una entrada digital para leer el su estado.

Finalmente, mostramos la lectura por puerto serie. En un ejemplo real, en esta parte ejecutaríamos las acciones oportunas, como mover un servo, o un robot.

GND - GND
Vcc - 5v
VRx - A0
VRy - A1
SW -  D9
*/
 
const int pinLED = 13;
const int pinJoyX = A0;
const int pinJoyY = A1;
const int pinJoyButton = 9;
 
void setup() {
   pinMode(pinJoyButton , INPUT_PULLUP);   //activar resistencia pull up 
   Serial.begin(9600);
}
 
void loop() {
   int Xvalue = 0;
   int Yvalue = 0;
   bool buttonValue = false;
 
   //leer valores
   Xvalue = analogRead(pinJoyX);
   delay(100);                 //es necesaria una pequeña pausa entre lecturas analógicas
   Yvalue = analogRead(pinJoyY);
   buttonValue = digitalRead(pinJoyButton);
 
   //mostrar valores por serial
   Serial.print("X:" );
   Serial.print(Xvalue);
   Serial.print(" | Y: ");
   Serial.print(Yvalue);
   Serial.print(" | Pulsador: ");
   Serial.println(buttonValue);
   delay(1000);
}

FC-51: Sensor de Distancia Infrarrojo

Introducción

Armando un detector de obstáculos, con este ejemplo práctico te enseñamos para que sirve y como usar el sensor FC-51.

¿Qué es un detector de obstáculos IR?

Un detector de obstáculos infrarrojo es un dispositivo que detecta la presencia de un objeto mediante la reflexión que produce en la luz.

¿Para qué se utilizan?

Son ampliamente utilizados para la detección de obstáculos en pequeños vehículos o robots. Su bajo coste hace que sea frecuente ubicarlos en el perímetro, de forma que detectemos obstáculos en varias direcciones.

También son útiles en otro tipo de aplicaciones:

• Detectar la presencia de un objeto en una determinada zona
• Determinar si una puerta está abierta o cerrada
• Si una máquina ha alcanzado un cierto punto en su desplazamiento
• Etc

¿Cómo funcionan?

Constitutivamente son sensores sencillos, disponen de un LED emisor de luz infrarroja y de un fotoreceptor (tipo BPV10NF o similar) que recibe la luz reflejada por un posible obstáculo.

Los detectores de obstáculo suelen proporcionarse con una potenciómetro que permite ajustar la distancia de detección de obstáculos y un comparador LM393, un pequeño chip que se encarga de entregarnos una señal de tipo digital para el Arduino.

Este tipo de sensores actúan a distancias cortas, típicamente de 5 a 20mm. Además la cantidad de luz infrarroja recibida depende del color, material, forma y posición del obstáculo, por lo que no disponen de una precisión suficiente para proporcionar una estimación de la distancia al obstáculo.

El uso de luz infrarroja (IR) es simplemente para que esta no sea visible para los humanos y porque su respuesta es muy buena y estable incluso con luz ambiente o en completa oscuridad.

Si te interesa saber más, también podes leer:

Sensor Infrarrojo Básico

Sensores

Sensor Infrarrojo Básico

Introducción

Con esta guía usted aprenderá como construir un sensor infrarrojo básico y cómo configurarlo con Arduino.

El sensor infrarrojo es uno de los mas utilizados en el mundo Maker, los podemos encontrar en diversos proyectos desempeñando variedad de funciones:

• Barrera
• Interrupción
• Aproximación
• Etc

Tipos de sensores infrarrojos

Los sensores infrarrojos IR pueden ser pasivos o activos:

• Los sensores de infrarrojos pasivos son, básicamente, detectores de infrarrojos. Los sensores de infrarrojos pasivos no utilizan ninguna fuente de infrarrojos y detecta la energía emitida por los obstáculos en su campo de visión.
• Los sensores de infrarrojos activos consisten en dos elementos: las fuentes infrarrojas (LED infrarrojo) y los detectores de infrarrojos (fototransistor). Estos ultimos son los explicados en esta guia.

¿Cómo funcionan?

Los sensores infrarrojos activos prensentan el LED infrarrojo y el fototransistor colocados uno al lado del otro, de forma que el LED actúa como emisor y el fototransistor como receptor.

Algunos emisores los encontramos transparentes o con un ligero color en púrpura y los receptores en trasparentes o negros, estos últimos por un filtro UV que les permite trabajar mejor incluso expuesto a la luz solar.

El LED infrarrojo emite luz infrarroja, o sea, de mayor longitud de onda (o menor frecuencia) que la podemos ver los humanos, así que para nosotros es invisible.

• Si esta luz choca contra una superficie blanca se reflejará y llegará al fototransistor.
• Si por el contrario golpea en una superficie negra, el material absorberá la mayoría de la luz y no llegará al fotoreceptor.

¿Qué es un interruptor táctil?

Un sensor táctil capacitivo es un dispositivo que presenta un comportamiento similar a un pulsador, pero puede ser activado con poca o ninguna presión.

Este tipo de sensor táctil basa su funcionamiento en la medición de la variación de la capacitancia. La placa sensora y el cuerpo humano actúan como condensador y, por tanto, forman un sistema que almacena una carga electricidad.

Al reducir la distancia la capacitancia aumenta y el sistema almacena una carga superior. Esta acumulación de carga puede ser detectada en la placa sensora y generar una señal digital cuando supere un cierto valor. Esta señal de disparo puede a ser vez ser capturada con una entrada digital de Arduino.

La principal ventaja de este tipo de sensores es que no requieren de contacto físico para realizar el disparo, siendo suficiente acercar el dedo a 1-5mm del sensor. Por este motivo se les denomina dispositivos touchless.

De esta forma, es posible colocar el sensor táctil debajo de un vinilo, plástico, cartón, madera o cristal, siempre que el espesor no sea excesivo. Por contra no funcionarán debajo de materiales conductores, en particular debajo de metales.

Otra ventaja es que los sensores capacitivos es que carecen de partes móviles por lo que, en principio, tienen una durabilidad superior a la de un interruptor convencional.

Los sensores touchless son empleados a la hora de hacer interruptores eléctricos, por ejemplo, son frecuentes en baños y garajes. También pueden ser útiles, por ejemplo, para ubicar un pulsador táctil bajo un panel interactivo, de un vinilo con artes gráficas, o integrado bajo la madera de un mueble.

Esquema de montaje

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Finalmente, para realizar la lectura digital conectamos la salida SIG a una de las entradas digitales de Arduino.

Código de ejemplo

El código necesario es igualmente sencillo. Si estamos empleando la señal digital, empleamos una entrada digital para leer el estado. En el ejemplo mostramos un mensaje por la pantalla, pero en un caso real ejecutaríamos las acciones oportunas.

const int sensorPin = 9;
 
void setup()
{
   Serial.begin(9600);
   pinMode(sensorPin, INPUT);
}
 
void loop()
{
   int estado = digitalRead(sensorPin);
 
   //mandar mensaje a puerto serie en función del valor leido
   if (estado == HIGH)
   {
      Serial.println("Contacto detectado");   
      //aquí se ejecutarían las acciones
   }
   delay(1000);
}

HC-SR04: Sensor Ultrasónico

Introducción

El sensor HC-SR04 es un sensor de distancia de bajo costo, su uso es muy frecuente en la robótica, utiliza transductores de ultrasonido para detectar objetos.

Con esta guía, vamos a conocer de forma detallada sus características, como calibrarlo, como conectarlo y como utilizarlo con Arduino.

Para empezar a utilizar el sensor HC-SR04 solo necesitas una placa Arduino, en esta guía utilizaremos un Uno R3, pero puedes utilizar cualquier placa de Arduino, el procedimiento es el mismo.

¿Cómo funciona?

El sensor HC-SR04 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.

¿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.

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.

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.

¿Qué es un Encoder Rotativo?

Un encoder rotativo es un dispositivo genérico que permite determinar la posición y velocidad angular de un accionamiento, y registrar la medición desde un procesador o autómata como Arduino.

Existen múltiples tipos de encoders rotativos, pero en el ámbito de Arduino y los proyectos de electrónica caseros es muy frecuente encontrar encoders rotativos electromecanicos.

Externamente estos encoders pueden ser parecidos a ciertos tipos modelos de potenciómetros, lo cual puede ser una ventaja porque hace que ciertos accesorios sean similares, e incluso sea posible sustituir uno por otro.

Este tipo de encoder rotativo es un dispositivo incremental que proporciona un pulso digital cada vez que el encoder gira un determinado ángulo. El número de pulsos por vuelta depende del encoder empleado, siendo habitual 256 pulsos/vuelta.

Frecuentemente, también incorporan un pulsador que actual al apretar la palanca del encoder.

Curiosamente, este tipo de encoders no son demasiado útiles para actuar como encoders propiamente dichos, es decir, para registrar el giro de un elemento (por ejemplo, la rueda de un robot) de un debido a la dificultad de acoplarlo al eje y la baja resolución del encoder.

Su uso principal es como mando o dispositivo de control o en sustitución de potenciómetros. Por ejemplo, pueden emplearse para regular el brillo de una pantalla LCD, el volumen de un dispositivo, o el ángulo de un motor paso a paso o servo.

¿Cómo funciona un Encoder Rotativo?

Internamente el encoder está formado por dos escobillas que deslizan sobre una pista de metálica con divisiones. Al girar el eje, una pequeña bola metálica cierra el contacto, actuando como un pulsador.

Normalmente disponen de dos salidas formando un sistema equivalente a disponer dos pulsadores (Canal A y B). Estos pulsadores están desplazados uno respecto al otro, formando lo que se denomina un encoder en cuadratura.

En un encoder en cuadratura existe un desfase entre ambos sensores de forma que la señal que producen está desplazada 90º eléctricos. Gráficamente, la señal de ambos canales respecto al ángulo girado sería la siguiente.

La ventaja de los encoder en cuadratura es que, además de detectar la posición y la velocidad, permiten determinar el sentido de giro.

Para visualizarlo, consideremos que tomamos como origen de eventos los flancos de subida o bajada del Canal A. Si giramos en el sentido CW, se producirán los eventos t0, t1, t2, t3… tn.

Si en estos eventos miramos el Canal B, vemos que la señal A es siempre inversa al Canal B.

Si invertimos el sentido de giro, e igualmente tomamos como referencia los flancos de bajada o subida del Canal A, vemos que en los instantes (t0, t1, t2, t3… tn) la señal del Canal A y B son siempre idénticas.

En realidad, que el sentido de giro sea CW o CCW dependerá de la construcción interna del sensor, de la conexión, y del canal que tomemos como referencia.

Pero, en cualquier caso, vemos que es posible diferenciar el sentido de giro simplemente comparando las señales obtenidas en el encoder en cuadratura, y asignar un significado físico CW o CCW es inmediato, simplemente probando el montaje una vez.

Respecto a la precisión, tenemos más de una opción.

• Precisión simple: registrando un único flanco (subida o bajada) en un único canal.
• Precisión doble: registrando ambos flancos en un único canal.
• Precisión cuádruple: registrando ambos flancos en ambos canales.

Esquema de montaje

Para conectar el encoder a Arduino, necesitamos tres entradas digitales, dos para la detección del encoder y una adicional si queremos registrar la pulsación de la palanca.

Idealmente, deberíamos emplear interrupciones para registrar el movimiento del encoder. Lamentablemente, la mayoría de placas de Arduino sólo tienen dos pines asociados a interrupciones. En el caso de querer precisión cuádruple esto supone emplear los dos pines con interrupciones.

En este caso, la conexión del encoder sería la siguiente.

Mientras que la conexión vista desde Arduino sería la siguiente.

No obstante, es posible emplear el encoder sin emplear interrupciones, lo que permite emplear entradas digitales. Sin embargo, tendremos que preguntar por pool el estado de la entrada, lo que supone un peor rendimiento.

Código de ejemplo

Precisión simple o doble por pool

En este primer ejemplo realizamos la lectura del encoder por pool, sin emplear interrupciones. Para ello podemos usar dos entradas digitales cualquiera, en el ejemplo D9 y D10. La precisión puede ser doble o simple, para lo cuál tendréis que cambiar la linea comentada en el condicional (aunque no se me ocurre una razón para preferir precisión simple a doble)

const int channelPinA = 9;
const int channelPinB = 10;
 
unsigned char stateChannelA;
unsigned char stateChannelB;
unsigned char prevStateChannelA = 0;
 
const int maxSteps = 255;
int prevValue;
int value;
 
const int timeThreshold = 5; 
unsigned long currentTime;
unsigned long loopTime;
 
bool IsCW = true;
 
void setup() {
   Serial.begin(9600);
   pinMode(channelPinA, INPUT);
   pinMode(channelPinB, INPUT);
   currentTime = millis();
   loopTime = currentTime;
   value = 0;
   prevValue = 0;
}
 
void loop() {
   currentTime = millis();
   if (currentTime >= (loopTime + timeThreshold))
   {
      stateChannelA = digitalRead(channelPinA);
      stateChannelB = digitalRead(channelPinB);
      if (stateChannelA != prevStateChannelA)  // Para precision simple if((!stateChannelA) && (prevStateChannelA))
      {
         if (stateChannelB) // B es HIGH, es CW
         {
            bool IsCW = true;
            if (value + 1 <= maxSteps) value++; // Asegurar que no sobrepasamos maxSteps
         }
         else  // B es LOW, es CWW
         {
            bool IsCW = false;
            if (value - 1 >= 0) value = value--; // Asegurar que no tenemos negativos
         }
 
      }
      prevStateChannelA = stateChannelA;   // Guardar valores para siguiente
 
      // Si ha cambiado el valor, mostrarlo
      if (prevValue != value)
      {
         prevValue = value;
         Serial.print(value);
 
      }
 
      loopTime = currentTime;  // Actualizar tiempo
   }
   
   // Otras tareas
}

Precisión doble con una interrupción

En este ejemplo cambiamos una de las entradas digitales por una interrupción, registrando flancos de subida y bajada, por lo que tenemos precisión doble.

const int channelPinA = 2;
const int channelPinB = 10;
 
const int timeThreshold = 5;
long timeCounter = 0;
 
const int maxSteps = 255;
volatile int ISRCounter = 0;
int counter = 0;
 
bool IsCW = true;
 
void setup()
{
   pinMode(channelPinA, INPUT_PULLUP);
   Serial.begin(9600);
   attachInterrupt(digitalPinToInterrupt(channelPinA), doEncode, CHANGE);
}
 
void loop()
{
   if (counter != ISRCounter)
   {
      counter = ISRCounter;
      Serial.println(counter);
   }
   delay(100);
}
 
void doEncode()
{
   if (millis() > timeCounter + timeThreshold)
   {
      if (digitalRead(channelPinA) == digitalRead(channelPinB))
      {
         IsCW = true;
         if (ISRCounter + 1 <= maxSteps) ISRCounter++;
      }
      else
      {
         IsCW = false;
         if (ISRCounter - 1 > 0) ISRCounter--;
      }
      timeCounter = millis();
   }
}

Precisión cuádruple con dos interrupciones

En este último ejemplo, empleamos interrupciones para ambos canales, y en ambos flancos. Obtenemos precisión cuádruple, pero a cambio dejamos sin más pines con interrupciones a la mayoría de modelos de Arduino.

const int channelPinA = 2;
const int channelPinB = 3;
 
const int timeThreshold = 5;
long timeCounter = 0;
 
const int maxSteps = 255;
volatile int ISRCounter = 0;
int counter = 0;
 
bool IsCW = true;
 
void setup()
{
   pinMode(channelPinA, INPUT_PULLUP);
   pinMode(channelPinB, INPUT_PULLUP);
   Serial.begin(9600);
   attachInterrupt(digitalPinToInterrupt(channelPinA), doEncodeA, CHANGE);
   attachInterrupt(digitalPinToInterrupt(channelPinB), doEncodeB, CHANGE);
}
 
void loop()
{
   if (counter != ISRCounter)
   {
      counter = ISRCounter;
      Serial.println(counter);
   }
   delay(100);
}
 
void doEncodeA()
{
   if (millis() > timeCounter + timeThreshold)
   {
      if (digitalRead(channelPinA) == digitalRead(channelPinB))
      {
         IsCW = true;
         if (ISRCounter + 1 <= maxSteps) ISRCounter++;
      }
      else
      {
         IsCW = false;
         if (ISRCounter - 1 > 0) ISRCounter--;
      }
      timeCounter = millis();
   }
}
 
void doEncodeB()
{
   if (millis() > timeCounter + timeThreshold)
   {
      if (digitalRead(channelPinA) != digitalRead(channelPinB))
      {
         IsCW = true;
         if (ISRCounter + 1 <= maxSteps) ISRCounter++;
      }
      else
      {
         IsCW = false;
         if (ISRCounter - 1 > 0) ISRCounter--;
      }
      timeCounter = millis();
   }
}

¿Qué es el RFID?

El RFID (Identificador por radiofrecuencia) es un conjunto de tecnologías diseñadas para leer etiquetas (tags) a distancia de forma inalámbrica. Los lectores RFID pueden ser conectados a un autómata o procesador como Arduino.

Las etiquetas RFID están disponibles en una gran variedad de formatos, tales como pegatinas adheribles, tarjetas, llaveros, pueden integrarse en un determinado producto o, incluso, insertarse bajo la piel en un animal o humano.

Los RFID son ampliamente empleados, por ejemplo, en sistemas de alarma, aplicaciones comerciales en sustitución de códigos de barras, cerraduras electrónicas, sistemas de pago, tarjetas personales, control de accesos recintos como gimnasios o piscinas, fichaje en empresas, entre otras muchas aplicaciones.

En nuestros proyectos de electrónica con Arduino podemos usar el RFID, por ejemplo, en aplicaciones comerciales para mostrar en una pantalla los datos al acercar un producto, cambiar la luz o iluminación , abrir una puerta con una tarjeta personal, o hacer que un robot se comporte de forma distinta pasándole una tarjeta

¿Cómo funciona el RFID?

El RFID es un conjunto de tecnologías inalámbricas diseñadas para obtener una información almacenada en un dispositivo denominado etiqueta (tag)

El lector (transceptor) es en realidad un emisor-receptor que, en primer lugar, emite una señal para iniciar la comunicación con las etiquetas (transpondedores). Esta señal es captada por las etiquetas dentro del alcance, las cuál responden transmitiendo la información que almacenada que, finalmente, es captada y decodificada por el lector RFID.

El RFID puede operar en cuatro bandas de frecuencia, siendo la más frecuente 13.56 Mhz.

• Baja frecuencia 125-134.2 kHz. Control de animales, llaves de automóviles…
• Alta frecuencia 13.56 MHz. Control de accesos, control de artículos en tiendas…
• Ultra alta frecuencia (UHF) 868 – 956 GHZ
• Microondas, 2,45 GHz

Existen etiquetas RFID de sólo lectura, es decir, en las que la información que contienen es grabada durante su fabricación y no puede modificarse, y etiquetas de lectura y escritura, en las que podemos sobreeescribir la información de la etiqueta.

Respecto a la alimentación, existen etiquetas RFID activas que disponen de su propia fuente de energía (por ejemplo, una batería). El rango de lectura puede ser de 10m a 100m.

Por contra las etiquetas RFID pasivas obtienen su energía por inducción de la onda electromagnética emitida por el lector. Por tanto, no requieren fuente de alimentación. Sin embargo el alcance de lectura se reduce a unos centímetros.

EL NFC, UN SUBCONJUNTO DEL RFID

La tecnología RFID puede tener alcances de 10-100m. Esto tiene importante consideraciones sobre la seguridad y privacidad. Por ejemplo, imaginemos los peligros de poder leer información de personal o de pagos a estas distancias.

El NFC (Near Field Communication) es un subconjunto de la tecnología RFID que por diseño establece métodos para limitar la distancia de transmisión a menos de 10 cm. El NFC está experimentando un gran desarrollo debido a la inclusión en los smartphone, y posible formas de pago.

Sin embargo, aunque íntimamente relacionados, no hay que confundir RFID y NFC. En particular, no todos los sistemas RFID y NFC serán compatibles, es decir, que no siempre vamos a poder leer una tarjeta RFID con el lector NFC de un smartphone.

El lector MIFARE MFRC522

MIFARE es una tecnología de tarjetas inalámbricas propiedad de NXP Semiconductores. Es uno de los estándares más implantados como tarjetas inteligentes sin contacto (TSIC).

El Mifare MFRC522 es un lector de tarjetas RFID que incorpora comunicación por bus SPI, bus I2C y UART, por lo que es sencillo de conectar con Arduino. El MFRC522 soporta las tarjetas Mifate S50, Mifare S70, Mifare UltraLight, Mifare Pro y Mifare Desfire.

El lector MFRC522 opera en la frecuencia de 13.56Mhz y tiene una distancia de lectura de 0 a 60. El MFRC522 tiene un consumo de 13-26 mA durante la escritura, 10-13mA en stanby e inferior a 80uA en modo sleep. La tensión de alimentación es de 3.3V.

El MFRC522 suele suministrarse con tarjetas o llaveros MIFARE Classic 1K. Este tipo de tarjetas son, esencialmente, un sistema de almacenamiento donde la memoria está dividida en bloques, con mecanismos simple para el acceso a la información.

El MIFARE Classic 1K dispone de 1024 bytes de memoria divididos en 16 sectores de 64 bytes, cada uno protegido por dos claves llamadas A y B. Cada una puede ser programada individualmente para permitir o bloquear operaciones lectura o escritura.

Cada sector reserva una cierta memoria para las claves A y B, por lo que este espacio normalmente no puede ser empleado para guardar datos, lo que reduce la cantidad de memoria disponible en una MIFARE Classic 1K a 752 bytes.

La memoria EEPROM de las tarjetas MIFARE Classic puede soportar más de 100.000 ciclos de escritura, y pueden mantener la memoria durante más de 10 años sin recibir alimentación.

Esquema de montaje

La conexión es sencilla. Simplemente alimentamos el módulo desde Arduino mediante 3.3V y Gnd. Por otro lado, conectamos los pines del bus SPI a los correspondientes de Arduino.

Mientras que la conexión vista desde el lado de Arduino quedaría así.

Código de ejemplo

Para realizar la lectura del RC522 usaremos la librería desarrollada por Miguel Balboa, disponible en este enlace. La librería proporciona ejemplos de código, que resulta aconsejable revisar. Los siguientes ejemplos son modificaciones a partir de los disponibles en la librería.

MOSTRAR EL ID DE LA TARJETA

El siguiente ejemplo detecta una tarjeta RFID, y muestra su identificador por puerto serie.

//RST           D9
//SDA(SS)      D10
//MOSI         D11
//MISO         D12
//SCK          D13
 
#include <SPI.h>
#include <MFRC522.h>

const int RST_PIN = 9;            // Pin 9 para el reset del RC522
const int SS_PIN = 10;            // Pin 10 para el SS (SDA) del RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);   // Crear instancia del MFRC522
 
void printArray(byte *buffer, byte bufferSize) {
   for (byte i = 0; i < bufferSize; i++) {
      Serial.print(buffer[i] < 0x10 ? " 0" : " ");
      Serial.print(buffer[i], HEX);
   }
}
 
void setup()
{
   Serial.begin(9600);      //Inicializa la velocidad de Serial
   SPI.begin();         //Función que inicializa SPI
   mfrc522.PCD_Init();     //Función  que inicializa RFID
}
 
void loop()
{
   // Detectar tarjeta
   if (mfrc522.PICC_IsNewCardPresent())
   {
      if (mfrc522.PICC_ReadCardSerial())
      {
         Serial.print(F("Card UID:"));
         printArray(mfrc522.uid.uidByte, mfrc522.uid.size);
         Serial.println();
 
         // Finalizar lectura actual
         mfrc522.PICC_HaltA();
      }
   }
   delay(250);
}

VALIDAD EL ID DE LA TARJETA

El siguiente ejemplo lee una tarjeta y comprueba el ID para determinar si la tarjeta es aceptada o no.

//RST          D9
//SDA(SS)      D10
//MOSI         D11
//MISO         D12
//SCK          D13
 
#include <SPI.>;
#include <MFRC522.h>;
 
const int RST_PIN = 9;        // Pin 9 para el reset del RC522
const int SS_PIN = 10;        // Pin 10 para el SS (SDA) del RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);   // Crear instancia del MFRC522
 
byte validKey1[4] = { 0xA0, 0xB1, 0xC2, 0xD3 };  // Ejemplo de clave valida
 
//Función para comparar dos vectores
bool isEqualArray(byte* arrayA, byte* arrayB, int length)
{
  for (int index = 0; index < length; index++)
  {
    if (arrayA[index] != arrayB[index]) return false;
  }
  return true;
}
 
void setup() {
  Serial.begin(9600); // Iniciar serial
  SPI.begin();        // Iniciar SPI
  mfrc522.PCD_Init(); // Iniciar MFRC522
}
 
void loop() {
  // Detectar tarjeta
  if (mfrc522.PICC_IsNewCardPresent())
  {
    //Seleccionamos una tarjeta
    if (mfrc522.PICC_ReadCardSerial())
    {
      // Comparar ID con las claves válidas
      if (isEqualArray(mfrc522.uid.uidByte, validKey1, 4))
        Serial.println("Tarjeta valida");
      else
        Serial.println("Tarjeta invalida");
 
      // Finalizar lectura actual
      mfrc522.PICC_HaltA();
    }
  }
  delay(250);
 
}

ESCRITURA DE DATOS

En el último ejemplo empleamos las funciones de escritura y lectura para grabar una cadena de texto en la memoria de la tarjeta Mifare.

//RST           D9
//SDA(SS)      D10
//MOSI         D11
//MISO         D12
//SCK          D13

#include <SPI.h>;
#include <MFRC522.h>;
 
const int RST_PIN = 9;
const int SS_PIN = 10;
 
//Declaracion de cadena de caracteres
unsigned char data[16] = { 'T','E','S','T',' ','R','F','I','D',' ','M','F','R', '5','5','2'}; 
unsigned char *writeData = data; 
unsigned char *str;
 
MFRC522 mfrc522(SS_PIN, RST_PIN);
 
MFRC522::MIFARE_Key key;
 
void printArray(byte *buffer, byte bufferSize) {
   for (byte i = 0; i < bufferSize; i++) {
      Serial.print(buffer[i] < 0x10 ? " 0" : " ");
      Serial.print(buffer[i], HEX);
   }
}
 
void setup()
{
   Serial.begin(9600);
   SPI.begin();
   mfrc522.PCD_Init();
 
   for (byte i = 0; i < 6; i++) {
      key.keyByte[i] = 0xFF;
   }
}
 
void loop()
{
   if (!mfrc522.PICC_IsNewCardPresent())
      return;
 
   if (!mfrc522.PICC_ReadCardSerial())
      return;
 
   MFRC522::StatusCode status;
   byte trailerBlock = 7;
   byte sector = 1;
   byte blockAddr = 4;
 
   status = (MFRC522::StatusCode) mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
   if (status != MFRC522::STATUS_OK) {
      Serial.print(F("PCD_Authenticate() failed: "));
      Serial.println(mfrc522.GetStatusCodeName(status));
      return;
   }
 
   // Write data to the block
   Serial.print(F("Escribir datos en sector "));
   Serial.print(blockAddr);
   Serial.println(F(" ..."));
   printArray((byte*)data, 16); Serial.println();
   status = (MFRC522::StatusCode) mfrc522.MIFARE_Write(blockAddr, (byte*)data, 16);
   if (status != MFRC522::STATUS_OK) {
      Serial.print(F("MIFARE_Write() failed: "));
      Serial.println(mfrc522.GetStatusCodeName(status));
   }
   Serial.println();
 
   byte buffer[18];
   byte size = sizeof(buffer);
 
   // Read data from the block (again, should now be what we have written)
   Serial.print(F("Leer datos del sector ")); Serial.print(blockAddr);
   Serial.println(F(" ..."));
   status = (MFRC522::StatusCode) mfrc522.MIFARE_Read(blockAddr, buffer, &size);
   if (status != MFRC522::STATUS_OK) {
      Serial.print(F("MIFARE_Read() failed: "));
      Serial.println(mfrc522.GetStatusCodeName(status));
   }
   Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":"));
   printArray(buffer, 16); Serial.println();
 
   // Halt PICC
   mfrc522.PICC_HaltA();
   // Stop encryption on PCD
   mfrc522.PCD_StopCrypto1();
}

¿QUÉ ES UN SENSOR DE GASES MQ?

Los sensores de gases MQ son una familia de dispositivos diseñados para detectar la presencia de distintos componentes químicos en el aire. Podemos conectar estos dispositivos a un autómata o procesador como Arduino.

Existe una gran variedad de sensores MQ. Cada modelo está diseñado para detectar una o más sustancias, pensadas para un uso específico, como por ejemplo detección gases inflamables, calidad del aire o detección de alcohol en aire respirado.

Los sensores de gases MQ suelen proporcionarse con una placa de medición estándar con el comparador LMC662 o similar, que permite obtener la lectura tanto como un valor analógico, como un valor digital cuando se supera un cierto umbral regulado a través de un potenciómetro ubicado en la placa.

Los sensores de gases deben ser calibrados antes de obtener una medida precisa. Aun calibrados estos sensores no disponen de la garantía necesaria para formar parte de un sistema de seguridad.

Pese a sus limitaciones, los sensores de gases tipo MQ son muy usados en proyectos de electrónica casera con Arduino. Por ejemplo, podemos hacer encender o apagar un ventilador en función de la calidad del aire, hacer un pequeño detector de alcoholemia, o una alama que suene al detectar humos.

¿CÓMO FUNCIONA UN SENSOR DE GASES?

Los sensores MQ están compuestos por un sensor electro-químico que varía su resistencia al estar en contacto con las sustancias.

Los sensores de gases son dispositivos con alta inercia, es decir, la respuesta necesita tiempos largos para estabilizarse tras un cambio de concentración de los gases medidos. Ello es debido a la necesidad física de que el gas abandone el material sensible, lo cual es un proceso lento.

Todos los modelos MQ disponen de un calentador necesario para elevar la temperatura del sensor, y que sus materiales adquieran la sensibilidad. Mientras el calentador no alcance la temperatura de funcionamiento, la lectura del sensor no será fiable.

El tiempo de calentamiento depende de cada modelo de sensor. En la mayoría de modelos es suficiente para con unos pocos minutos pero algunos modelos requieren hasta 12 y 48 horas hasta obtener mediciones estable.

Por otro lado, cada modelo necesita su propia tensión para alimentar el calentador. En muchos modelos esta tensión es de 5V, pero algunos modelos tienen condicionantes especiales para la alimentación.

El consumo de los sensores MQ puede ser elevado debido al calor necesario para funcionar el calentador, que puede llegar hasta 800 mW en algunos modelos. Esto es superior a la potencia que puede suministrar el regulador de Arduino, por lo que será necesario proporcionar una fuente de alimentación externa.

A continuación, tenéis una tabla de resumen con los distintos modelos de sensores disponibles, los gases a los que son sensibles, y algunos datos sobre el calentador.

No obstante, consultar detalladamente el Datasheet de cada sensor MQ particular antes de emplearlo para detallar sus especificaciones técnicas, especialmente la tensión de alimentación del calentador, el tiempo de calentamiento, y la curva de sensibilidad del sensor.

* Conviene amplificación

ESQUEMA DE MONTAJE

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Ahora si queremos usar la lectura digital, conectamos la salida DO a una de las entradas digitales de Arduino.

Opcionalmente, podemos calibrar el umbral de disparo de la salida digital con el potenciómetro instalado en el módulo.

La conexión vista desde Arduino quedaría así,

Si quisiéramos emplear el valor analógico, simplemente conectaríamos la salida AO del sensor a una entrada analógica de Arduino.

Código de ejemplo

LECTURA DIGITAL

El siguiente ejemplo muestra la lectura digital del sensor. El código es muy, simplemente utilizamos una entrada digital para comprobar el estado del sensor, empleando el puerto serie para informar de la detección. En un ejemplo real, realizaríamos las acciones oportunas ante una detección.

const int MQ_PIN = 2;
const int MQ_DELAY = 2000;
 
void setup()
{
  Serial.begin(9600);
}
 
 
void loop()
{
  bool state= digitalRead(MQ_PIN);
 
  if (!state)
  {
    Serial.println("Deteccion");
  }
  else
  {
    Serial.println("No detectado");
  }
  delay(MQ_DELAY);
}

LECTURA ANALÓGICA

En el siguiente ejemplo realizamos la lectura analógica del sensor. Al igual que el anterior, es código es muy sencillo. Simplemente empleamos una entrada analógica cualquiera para leer la salida analógica del sensor, y mostramos el resultado por puerto serie.

const int MQ_PIN = A0;
const int MQ_DELAY = 2000;
 
void setup()
{
  Serial.begin(9600);
}
 
void loop() 
{
  int raw_adc = analogRead(MQ_PIN);
  float value_adc = raw_adc * (5.0 / 1023.0);
 
  Serial.print("Raw:");
  Serial.print(raw_adc);
  Serial.print("    Tension:");
  Serial.println(value_adc);
 
  delay(MQ_DELAY);
}

  

LEER LA CONCENTRACIÓN

En el siguiente ejemplo, empleamos la lectura analógica para determinar la concentración del gas normalmente en ppm (partes por millón), pero algunos sensores usan otras unidades como mg/L o bpm (partes por billón)

El Datasheet de cada sensor proporciona unas gráficas que permiten obtener la concentración del gas a partir de la relación entre la resistencia del sensor R0 y la resistencia medida Rs. También es necesario conocer la resistencia Rl empleada en el módulo para realizar la lectura del sensor MQ.

Por ejemplo, la siguiente imagen muestra las curvas de concentración de cada gas medido en un sensor MQ-2

Las gráficas se disponen en escala logarítmica para ambos ejes y, en general, son aproximadamente rectas bajo estas escalas. Por lo que la concentración resultará,

Para determinar la concentración necesitaremos la recta que la aproxima, para lo cuál debemos coger dos puntos cuales quiera de las gráficas P0 = {X0, Y0} y P1 = {X1, Y1}, resultando la ecuación de la recta

Siendo

[one_half]
[/one_half]

[one_half]
[/one_half]

const int MQ_PIN = A0;      // Pin del sensor
const int RL_VALUE = 5;      // Resistencia RL del modulo en Kilo ohms
const int R0 = 10;          // Resistencia R0 del sensor en Kilo ohms
 
// Datos para lectura multiple
const int READ_SAMPLE_INTERVAL = 100;    // Tiempo entre muestras
const int READ_SAMPLE_TIMES = 5;       // Numero muestras
 
// Ajustar estos valores para vuestro sensor según el Datasheet
// (opcionalmente, según la calibración que hayáis realizado)
const float X0 = 200;
const float Y0 = 1.7;
const float X1 = 10000;
const float Y1 = 0.28;
 
// Puntos de la curva de concentración {X, Y}
const float punto0[] = { log10(X0), log10(Y0) };
const float punto1[] = { log10(X1), log10(Y1) };
 
// Calcular pendiente y coordenada abscisas
const float scope = (punto1[1] - punto0[1]) / (punto1[0] - punto0[0]);
const float coord = punto0[1] - punto0[0] * scope;
 
void setup()
{
   Serial.begin(9600);
}
 
void loop()
{
   float rs_med = readMQ(MQ_PIN);      // Obtener la Rs promedio
   float concentration = getConcentration(rs_med/R0);   // Obtener la concentración
   
   // Mostrar el valor de la concentración por serial
   Serial.println("Concentración: ");
   Serial.println(concentration);
}
 
// Obtener la resistencia promedio en N muestras
float readMQ(int mq_pin)
{
   float rs = 0;
   for (int i = 0;i<READ_SAMPLE_TIMES;i++) {
      rs += getMQResistance(analogRead(mq_pin));
      delay(READ_SAMPLE_INTERVAL);
   }
   return rs / READ_SAMPLE_TIMES;
}
 
// Obtener resistencia a partir de la lectura analogica
float getMQResistance(int raw_adc)
{
   return (((float)RL_VALUE / 1000.0*(1023 - raw_adc) / raw_adc));
}
 
// Obtener concentracion 10^(coord + scope * log (rs/r0)
float getConcentration(float rs_ro_ratio)
{
   return pow(10, coord + scope * log(rs_ro_ratio));
}

¿QUÉ ES UN SENSOR DE COLOR TCS3200?

EL TCS3200 es un sensor óptico que permite detectar el color de un objeto ubicado en frente de él. Podemos conectarlo este sensor con facilidad a un autómata o procesador como Arduino.

Internamente, el TCS3200 está formado por una matriz de fotodiodos de silicona junto con un conversor de frecuencia, en un único integrado CMOS.

La matriz dispone de 8 x 8 fotodiodos de 110 µm, de los cuales 16 tienen filtros azules, 16 verdes, 6 rojos, y 16 no tienen filtro. Los fotodiodos están distribuidos de forma que minimizan el efecto la incidencia no uniforme de la luz.

La salida del TCS3200 es una onda cuadrada del 50% duty, cuya frecuencia es proporcional a la intensidad luminosa. La tensión de alimentación del sensor es de 2.7V a 5.5V.

Frecuentemente el TCS3200 se distribuye en módulos que incorporan dos o cuatro LED de luz blanca y un protector de plástico. El objetivo de ambas medidas es minimizar los efectos de la iluminación ambiente en la medición.

Pese a sus especificaciones y elementos para eliminar la luz ambiente, el TCS3200 no es capaz de medir de forma precisa el color RGB de un objeto, o la temperatura de color de una fuente luminosa.

Sin embargo, podemos emplearlo para distinguir entre colores básicos. Por ejemplo, podemos emplearlo para reconocer el color de una tarjeta o un objeto, y guiar a un robot en un recorrido.

ESQUEMA DE MONTAJE

El TCS3200 tiene cuatro entradas digitales S0, S1, S2, y S3, y una salida digital Out. Para conectarlo a Arduino necesitaremos emplear al menos 3 pines digitales.

En primer lugar debemos alimentar el módulo conectando los pines Gnd y Vcc del TCS3200, respectivamente, a Gnd y Vcc de Arduino.

Los pines S0 y S1 controlan la frecuencia de la salida y la desactivación del módulo. Los conectamos a dos salidas digitales, o podemos conectarlas a 5V si no queremos poder apagar el módulo.

Por otra parte, los pines S2 y S3 seleccionan el color a medir. Deberemos conectarlos a dos salidas digitales de Arduino.

Finalmente, conectamos la salida del sensor Out a una entrada digital de Arduino por lo que la conexión empleando los pines, sería la siguiente.

Mientras que la conexión, vista desde Arduino, sería la siguiente.

Código de ejemplo

En el siguiente ejemplo realizamos la lectura del TCS3200. Para ello empleamos la función PulseIn para determinar la duración del pulso recibido por el sensor.

Realizamos el proceso para cada color, y empleamos los valores obtenidos para clasificarlo como rojo, azul o verde.

//VCC——5V   
//GND——GND
//S0——D3   
//S1——D4
//S2——D5   
//S3——D6
//OUT——D2
 
const int s0 = 8;
const int s1 = 9;
const int s2 = 12;
const int s3 = 11;
const int out = 10;
 
byte countRed = 0;
byte countGreen = 0;
byte countBlue = 0;
 
void setup() {
   Serial.begin(9600);
   pinMode(s0, OUTPUT);
   pinMode(s1, OUTPUT);
   pinMode(s2, OUTPUT);
   pinMode(s3, OUTPUT);
   pinMode(out, INPUT);
   digitalWrite(s0, HIGH);
   digitalWrite(s1, HIGH);
}
 
void loop() {
   getColor();
   Serial.print("Red: ");
   Serial.print(countRed, DEC);
   Serial.print("Green: ");
   Serial.print(countGreen, DEC);
   Serial.print("Blue: ");
   Serial.print(countBlue, DEC);
 
   if (countRed < countBlue && countGreen > 100 && countRed < 80)
   {
      Serial.println(" - Red");
   }
   else if (countBlue < countRed && countBlue < countGreen)
   {
      Serial.println(" - Blue");
   }
   else if (countGreen < countRed && countGreen < countBlue)
   {
      Serial.println(" - Green");
   }
   else {
      Serial.println("-");
   }
   delay(300);
}
 
void getColor()
{
   digitalWrite(s2, LOW);
   digitalWrite(s3, LOW);
   countRed = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
   digitalWrite(s3, HIGH);
   countBlue = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
   digitalWrite(s2, HIGH);
   countGreen = pulseIn(out, digitalRead(out) == HIGH ? LOW : HIGH);
}

Introducción

El BH1750 es un sensor digital del nivel de luz que puede ser conectado con facilidad a un autómata o procesador como Arduino para formar un luxómetro.

A diferencia a otros sistemas de medición del nivel de luz, como por ejemplo las resistencias LDR, la respuesta espectral del BH1750 está diseñada para ser similar a la del ojo humano por lo que son capaces de proporcionar la medición de lux.

Recordamos que los luxes son la unidad del sistema internacional para la iluminancia. La iluminancia es la relación entre el flujo luminoso (la cantidad de luz emitida por una fuente de luz, y la superficie en la que se mide.

A modo de referencia, para que tengáis un orden de magnitud de luxes, algunos ejemplos típicos de iluminancia.

El BH1750 tiene un amplio rango de medición ajustable desde los 0.11 a 100000 lux, por lo que es capaz de medir en casi cualquier situación de iluminación. Incorpora un ADC de 16bits que proporciona una resolución de 65535 niveles.

El sensor BH1750 tiene una baja influencia al espectro infrarrojo, rechazo al ruido de 50/60 Hz (luz artificial) y alta independencia del origen de la fuente de luz (luz natural, halógenos, LED, incandescencia).

La comunicación se realiza a través del bus I2C, por lo que es sencillo obtener los datos medidos. La tensión de alimentación es de bajo voltaje entre 2.4 a 3.6V.

Frecuentemente se encuentran integrados en módulos que incorporan la electrónica necesaria para conectarla de forma sencilla a un Arduino. En la mayoría de los módulos, esto incluye un regulador de voltaje que permite alimentar directamente a 5V.

El BH1750 se emplea, principalmente, para regular la retroiluminación de LCDs y Keypads en dispositivos móviles, así como para regular la iluminación en cámaras digitales.

Nosotros podemos usarlo en nuestros proyectos, por ejemplo, para crear un luxómetro de bajo coste, controlar el funcionamiento de persianas o toldos en domótica o para regular un sistema de iluminación. 

ESQUEMA DE MONTAJE

La conexión es sencilla, simplemente alimentamos el módulo desde Arduino mediante GND y 5V y conectamos el pin SDA y SCL de Arduino con los pines correspondientes del sensor.

Mientras que la conexión vista desde el lado de Arduino quedaría así.

Código de ejemplo

Para realizar la lectura del HMC5883 usaremos la librería desarrollada por Jeff Rowberg disponible en este enlace. También emplearemos la librería I2Cdev desarrollada por el mismo autor, que mejora la comunicación I2C.

La librería proporciona ejemplos de código, que resulta aconsejable revisar. Los siguientes ejemplos son modificaciones a partir de los disponibles en la librería

Para realizar la lectura del BH1750 usaremos la librería desarrollada por Christopher Laws, disponible en este enlace.

La librería proporciona ejemplos de código, que resulta aconsejable revisar. Los siguientes ejemplos son modificaciones a partir de los disponibles en la librería.

El sensor dispone de 3 modos de resolución, siendo el predeterminado el modo «High Resolution Mode».

Adicionalmente existen 2 modos de disparo, «Continuo» y «One Time». En el modo continuo el BH1750 realiza constantemente mediciones mientras que en el modo disparo único realiza la medición bajo demanda, pasando a modo baja energía entre solicitudes.

MOSTRAR NIVEL DE LUX

En este ejemplo empleamos el BH1750 para obtener el nivel de iluminancia y, a continuación, mostramos la cantidad de lux por puerto serie.

#include <Wire.h>
#include <BH1750.h>
 
BH1750 luxometro;
 
const byte luxMode = BH1750_CONTINUOUS_HIGH_RES_MODE;
// BH1750_CONTINUOUS_HIGH_RES_MODE
// BH1750_CONTINUOUS_HIGH_RES_MODE_2
// BH1750_CONTINUOUS_LOW_RES_MODE
// BH1750_ONE_TIME_HIGH_RES_MODE
// BH1750_ONE_TIME_HIGH_RES_MODE_2
// BH1750_ONE_TIME_LOW_RES_MODE
 
void setup() {
   Serial.begin(9600);
   Serial.println(F("Inicializando sensor..."));
   luxometro.begin(luxMode); // Inicializar BH1750
}
 
void loop() {
   uint16_t lux = luxometro.readLightLevel(); // Lectura del BH1750
   Serial.print(F("Iluminancia:  "));
   Serial.print(lux);
   Serial.println(" lx");
   delay(500);
}

ENCENDER UN DISPOSITIVO CON EL LUXÓMETRO

En este ejemplo empleamos la lectura del nivel de iluminación junto con dos umbrales superior e inferior para encender y apagar un dispositivo.

En el ejemplo empleamos el LED integrado en la placa para verificar el funcionamiento, por ejemplo, tapando el BH1750 con la mano y comprobando que el LED se apaga y enciende correctamente.

No obstante, en un ejemplo real emplearíamos la salida digital para realizar una acción como desplegar un toldo o cerrar una persiana, para lo que podemos emplear transistores BJT, transistores MOSFET o salidas por rele.

#include <Wire.h>
#include <BH1750.h>

BH1750 luxometro;;
const byte luxMode = BH1750_CONTINUOUS_HIGH_RES_MODE;
 
const uint16_t lowThreshold = 20;
const uint16_t highThreshold = 50;
 
const int pinOut = LED_BUILTIN;
 
 
void setup() {
   Serial.begin(9600);
   Serial.println(F("Inicializando sensor..."));
   luxometro.begin(luxMode); // Iniciar BH1750
}
 
void setup() {
   Serial.begin(9600);
   Serial.println(F("Inicializando sensor..."));
   luxometro.begin(BH1750_CONTINUOUS_HIGH_RES_MODE); // Iniciar sens el sensor
   pinMode(pinOut, OUTPUT);
   digitalWrite(pinOut, LOW);
}
 
void loop() {
   uint16_t lux = luxometro.readLightLevel();  // Lectura iluminancia
   
   if (lux < lowThreshold)
   {
      digitalWrite(pinOut, HIGH);
   }
   else if (lux > highThreshold)
   {
      digitalWrite(pinOut, LOW);
   }
   delay(500);
}

¿QUÉ ES UNA BRÚJULA DIGITAL HMC5883?

Una brújula digital es un sensor que mide el valor del campo magnético en tres ejes. Con esta medición, es posible estimar la orientación del dispositivo respecto al campo magnético de la tierra.

El chip Honeywell HMC5883 es un chip de superficie que incorpora tres sensores de magnetoresistencia, cancelación de desfases, y conversores de 12 bits, lo que le proporciona una precisión de ±2ºC.

La comunicación con el chip Honeywell HMC5833 se realiza a través del bus I2C, por lo que es sencillo obtener los datos medidos. La tensión de alimentación es de bajo voltaje de 1.8 a 3.3V.

Frecuentemente se encuentran integrados en módulos como la GY-273 que incorporan la electrónica necesaria para conectarla de forma sencilla a un Arduino. En la mayoría de los módulos, esto incluye un regulador de voltaje que permite alimentar directamente a 5V.

Las brújulas magnéticas son dispositivos ampliamente empleados en el uso de sistemas de navegación en robots y otros vehículos, como rovers o cuadricópteros.

Sin embargo, la medición de estos sensores se ve afectada por la presencia de campos magnéticos y metales. Por tanto, para aplicaciones de navegación es necesario combinar estos sensores con acelerómetros y giroscopios, o IMU’s

ESQUEMA DE MONTAJE

La conexión es sencilla, simplemente alimentamos el módulo desde Arduino mediante GND y 5V y conectamos el pin SDA y SCL de Arduino con los pines correspondientes del sensor.

Mientras que la conexión vista desde el lado de Arduino quedaría así.

Código de ejemplo

Para realizar la lectura del HMC5883 usaremos la librería desarrollada por Jeff Rowberg disponible en este enlace. También emplearemos la librería I2Cdev desarrollada por el mismo autor, que mejora la comunicación I2C.

La librería proporciona ejemplos de código, que resulta aconsejable revisar. Los siguientes ejemplos son modificaciones a partir de los disponibles en la librería

//GND - GND
//VCC - VCC
//SDA - Pin A4
//SCL - Pin A5
 
#include "Wire.h"
#include "I2Cdev.h"
#include "HMC5883L.h"
 
HMC5883L compass;
 
int16_t mx, my, mz;
 
void setup() 
{
    
    Serial.begin(9600);
    Wire.begin();
    compass.initialize();
}
 
void loop()
{
    //Obtener componentes del campo magnético
    compass.getHeading(&mx, &my, &mz);
    
    Serial.print("mx:");
    Serial.print(mx); 
    Serial.print("tmy:");
    Serial.print(my);
    Serial.print("tmz:");
    Serial.println(mz);
    delay(100);
}

OBTENER LA ORIENTACIÓN RESPECTO AL NORTE

En este ejemplo empleamos la medición del campo magnético para determinar la orientación del sensor.

La orientación se obtiene en grados respecto al norte magnético. Sin embargo, el norte geográfico no está perfectamente alineado al norte magnético. Esto se denomina declinación, y depende del punto del globo donde esten ubicados.

Por tanto, si querés obtener la orientación respecto al norte geográfico debés introducir la declinación de tu posición. Existen varias páginas donde consultar este valor, por ejemplo: www.ngdc.noaa.gov

  
//GND - GND
//VCC - VCC
//SDA - Pin A4
//SCL - Pin A5
 
#include "Wire.h"
#include "I2Cdev.h"
#include "HMC5883L.h"
 
HMC5883L compass;
 
int16_t mx, my, mz;
 
//declinacion en grados en tu posición
const float declinacion = 0.12; 
 
void setup()
{
    Serial.begin(9600);
    Wire.begin();
    compass .initialize();
}
 
void loop() {
    //Obtener componentes del campo magnético
    compass .getHeading(&mx, &my, &mz);
 
    //Calcular ángulo el ángulo del eje X respecto al norte
    float angulo = atan2(my, mx);
    angulo = angulo * RAD_TO_DEG;
    angulo = angulo - declinacion;
    
    if(angulo < 0) angulo = angulo + 360;
    
    Serial.print("N:");
    Serial.println(angulo,0);  
}

  

¿QUÉ ES UN SENSOR INDUCTIVO?

Un sensor inductivo es un sensor de proximidad diseñado para detectar objetos metálicos. Podemos emplear conectar fácilmente este tipo de sensores a un autómata o procesador como Arduino.

Internamente estos sensores disponen de un generador de campo magnético y en una bobina inductora que detecta el campo generado por el propio sensor.

La presencia de un objeto metálico modifica el campo inducido. Al tener una menor resistencia magnética (reluctancia) el campo magnético se «alarga», incrementando la corriente inducida en la bobina sensora.

Esta campo es detectado por la electrónica del sensor, cuya salida se activa cuando un metal es detectado. Como el sensor tiene dos estados, en ocasiones a estos dispositivos se les denomina interruptores inductivos de proximidad.

Existen sensores normalmente abiertos (NO), cuya señal es LOW cuando no se detecta objeto, y normalmente cerrados (NC) cuya señal es HIGH cuando no se detecta objeto.

El rango de detección depende del metal detectado, pero en general, no excede de los milímetros. Los metales ferríticos (como el hierro y el acero) permiten rangos de medición más amplios. Por contra, los metales no ferríticos (aluminio, cobre) pueden reducir la distancia a un 60%.

Los sensores inductivos tienen la ventaja de que no necesitan contacto para detectar el objeto metálico. Además, operan hasta tapados por otro material (como un embellecedor plástico, por ejemplo). Finalmente, son sensores robustos en ambientes industriales en presencia de suciedad y polvo.

Estos dispositivos son ampliamente empleados en automatizaciones industriales para detectar la existencia de una pieza en una estación. También son empleados en elevadores, detección de vehículos. En construcción son empleados para detección de tuberías o clavos. Finalmente, sensores similares, pero mucho más potentes, son empleados en arcos de seguridad o en aplicaciones militares como detección de minas.

Nosotros podemos emplear estos sensores en nuestros proyectos de Arduino, por ejemplo, para detectar un objeto, un obstáculo, el cierre de una puerta, detectar un objeto encima de una mesa, entre otros.

ESQUEMA DE MONTAJE

Los sensores inductivos generalmente tienen 3 o 4 conductores codificados por colores. Normalmente incorporan una etiqueta en el propio sensor que indica el esquema de conexión.

El sensor inductivo que vamos a emplear LJ12A3-4-Z/BY. El cable azul (BU) es Gnd, el marrón (BN) es Vcc, y el negro (BK) es la salida del sensor.

Para conectarlo a Arduino, alimentamos el sensor conectando el cable azul y marrón, respectivamente, a Gnd y 5V de Arduino.

Por último, conectamos el conductor negro a una entrada digital cualquiera de Arduino. La conexión, vista desde Arduino, sería la siguiente.

Código de ejemplo

El código necesario es muy sencillo, simplemente empleamos una una entrada digital para leer el estado.

const int sensorPin = 9;
 
void setup()
{
   Serial.begin(9600);
}
 
void loop()
{
   bool state = digitalRead(sensorPin);
 
   //mandar mensaje a puerto serie en función del valor leido
   if (state == HIGH)
   {
      Serial.println("Detección");   
      //aquí se ejecutarían las acciones
   }
   delay(1000);
}

Introducción

El MLX90614 es un sensor de temperatura infrarrojo sin de contacto fabricado por la empresa Melexis. Es posible conectar estos sensores con un autómata o procesador como Arduino para medir la temperatura de un objeto a distancia.

Existen distintos modelos del MLX90614 cada uno con un sufijo de tres letras. Los diferentes sensores difieren en el voltaje de operación, el numero de sensores infrarrojos, y la posición del filtro.

La comunicación se realiza a través de SMBus, un subconjunto de bus I2C, por lo que resulta sencilla su lectura, y es posible conectar más de un sensor de forma simultáneamente.

Frecuentemente se encuentran termómetros MLX90614 integrados en módulos como la GY-906 que incorporan la electrónica necesaria para conectarla de forma sencilla a un Arduino. En la mayoría de los módulos, esto incluye un regulador de voltaje que permite alimentar directamente a 5V.

Este tipo de termómetros infrarrojos tienen un gran número de aplicaciones, incluyendo sistemas de control de temperatura en instalaciones térmicas en edificios, control industrial de temperatura, detección de movimiento, y aplicaciones de salud.

¿Cómo funciona el MLX90614?

Según la ley de Stefan-Boltzmann, todo objeto por encima del cero absoluto (ºK) emite radiación cuyo espectro es proporcional a su temperatura. El MLX90614 recoge esta radiación y su salida es una señal eléctrica proporcional a la temperatura de todos los objetos en su campo de visión.

Internamente el MLX90614 está constituido con un chip de silicio con una fina membrana micromecanizada sensible a la radiación infrarroja, junto con la electrónica necesaria para amplificar y digitalizar la señal y calcular la temperatura.

El conjunto incluye un amplificador de bajo ruido, un conversor ADC de 17 bits, un DSP (procesador digital de señal) y compensación de la temperatura ambiente.

El MLX90614 viene calibrado de fábrica en un amplio rango de temperaturas: -40 a 85 °C para la temperatura ambiente y -70 a 382 °C para la temperatura de objetos. La precisión estándar es de 0.5 °C referente a la temperatura ambiente, aunque existen versiones médicas que ofrecen una resolución de 0.1ºC en temperaturas entre 35-38ºC.

El MLX90614 dispone de dos modos de salida. La estándar es SMBus, un conjunto del I2C, con una resolución de 0.02ºC. También puede emplear una salida PWM de 10 bits para mediciones continuas, aunque con menor resolución 0.14ºC.

Es importante tener en cuenta la lectura del sensor solo es estable cuando el sensor se encuentra en equilibrio térmico con el ambiente. También puede afectarle la suciedad en la ventana del sensor.

También es importante entender que el MLX90614 es sensible a todos los objetos ubicados en su campo de visión. El ángulo de visión depende del modelo, y varía desde 5º a 80ºC. En el ángulo más amplio de 80º, el área de medición a 0.5 tiene un diámetro de 0.83 metros

Es decir, los modelos de menos ángulo son apropiados para medidas puntuales en frente del sensor. Los sensores de ángulo amplio están diseñados para detectar incrementos de temperatura en una gran zona, por ejemplo, para detección de fallas en maquinaria.

Esquema de Montaje

La conexión es sencilla, simplemente alimentamos el módulo desde Arduino mediante GND y 5V y conectamos el pin SDA y SCL de Arduino con los pines correspondientes del sensor.

Mientras que la conexión vista desde el lado de Arduino quedaría así.

Código de ejemplo

Para realizar la lectura del MLX90614 usaremos la librería desarrollada por Sparkfun, disponible en este enlace.

La librería proporciona ejemplos de código, que resulta aconsejable revisar. El siguiente ejemplo es una modificación a partir de los disponibles en la librería, que realiza la lectura del sensor y muestra los resultados por puerto serie.

#include <Wire.h>
#include <Adafruit_MLX90614.h>
 
Adafruit_MLX90614 mlx = Adafruit_MLX90614();
 
void setup() {
  Serial.begin(9600);
 
  mlx.begin();  
}
 
void loop() {
  Serial.print("Ambiente = ");
  Serial.print(mlx.readAmbientTempC()); 
  Serial.print("ºC\tObjeto = "); 
  Serial.print(mlx.readObjectTempC()); 
  Serial.println("ºC");
  delay(500);
}

Introducción

Un caudalímetro es un sensor que permite medir la cantidad de agua que atraviesa una tubería. Podemos conectar un caudalímetro a un procesador como Arduino para obtener la medición del sensor.

¿Qué es una bomba de agua?

Una bomba de agua es un máquina hidráulica que permite incrementar la energía cinética de un caudal de agua.

Las bombas hidráulicas son elementos ampliamente conocidos y empleados en la industria. Existe una gran variedad de bombas, que abarcan un amplio rango de potencias y características hidráulicas.

Independientemente de sus características o potencia, siempre podemos controlar un equipo de bombeo mediante un procesador, siendo de hecho frecuente que estén controlados por un autómata. Podemos encender cualquier tipo de bomba de agua mediante las salidas digitales y el uso de un MOSFET o una salida por relé.

Las bombas hidráulicas son componentes fundamentales en instalaciones e infraestructuras, en sistemas de abastecimiento y depuración de agua y sistemas de climatización. Industrialmente, forman parte de un sin fin de equipamientos e impulsan todo tipo de fluidos.

¿Cómo funciona una bomba de agua?

Una bomba de agua consta de un accionamiento, en la mayoría de los casos un motor eléctrico, acoplado a un elemento rotativo denominado rodete.

El rodete está formado por álabes que, al girar, transmiten parte de la energía al fluido que lo atraviesa. Normalmente los álabes están curvados formando una guía para las partículas, y su forma determina la cantidad de energía que se transmite al fluido y el grado en que esta se reparte entre velocidad o presión.

Sin embargo, en algunas bombas de muy pequeña potencia los álabes son rectos, formando un simple aspa.

En las bombas axiales, el agua entra en la bomba por el centro del rodete, incrementa su energía a medida que lo atraviesa girando con el mismo, y finalmente abandona la bomba en sentido tangencial.

Existen bombas que emplean otro tipo de fluidos, en lugar de agua. Por ejemplo, existen bombas para mover hidrocarburos, aceites, o disoluciones. Sin embargo, aunque la teoría dice que cualquier máquina hidráulica puede funcionar al cambiar el fluido que impulsa, en el mundo real deberemos comprobar en las especificaciones que la bomba está preparada para el tipo de fluido que vamos a emplear.

También podemos clasificar las bombas entre sumergibles y bombas no sumergibles.

En las bombas sumergibles el motor se encuentra sellado en un encapsulado, por lo que toda la bomba se introduce en el fluido, lo que evita tener una tubería de aspiración.

En las bombas no sumergibles el motor no está impermeabilizado, por lo que no puede ser introducido dentro del fluido. Por tanto, necesitan una tubería de admisión, que debe cumplir unas determinadas de condiciones para que la bomba funcione correctamente (diferencia de altura con la cota del fluido, mecanismo de cebado, diámetro de la tubería de admisión…)

Esquema de montaje

El esquema de montaje es sencillo, simplemente vamos a usar un MOSFET como el IRF520N como interruptor para controlar el encendido de la bomba.

Por un lado, alimentamos el módulo con la tensión nominal de la bomba, mediante GND y Vin.

Por otro lado, conectamos la carga mediante la clema de conexión. Una bomba, salvo que esté internamente compensada, es una carga inductiva. Por tanto, deberemos añadir un diodo de protección flyback, como vimos en la entrada sobre MOSFET.

Finalmente, alimentamos la electrónica del módulo conectando Vcc y GND a 5V y GND en Arduino, y conectamos el Pin SIG a cualquiera de las salidas digitales de Arduino.

La conexión, vista desde Arduino, sería la siguiente.

Código de ejemplo

El código necesario es sencillo, ya que para controlar la bomba de agua únicamente necesitamos emplear una salida digital.

Por ejemplo, el siguiente código simplemente encendería y apagaría la bomba de agua cada 10 segundos.

			
const int pin = 9;

void setup()
{
	pinMode(pin, OUTPUT);  //definir pin como salida
}

void loop()
{
	digitalWrite(pin, HIGH);   // poner el Pin en HIGH
	delay(10000);               // esperar 10 segundos
	digitalWrite(pin, LOW);    // poner el Pin en LOW
	delay(10000);               // esperar 10 segundos
}
			
		

¿Qué es un Micrófono?

Un micrófono es un transductor que convierte las ondas sonoras en señales eléctricas. Podemos conectar un micrófono a un procesador como Arduino para detectar sonidos.

La salida producida por un micrófono es una señal eléctrica analógica que representa el sonido recibido. Sin embargo, en general, esta señal demasiado baja para ser medida y tiene que ser amplificada.

Existen placas como la KY-038 que incorporan un micrófono junto con un comparador LM393, que permite obtener la lectura tanto como un valor analógico como de forma digital.

El uso habitual de este tipo de sensores no amplificados es emplear la salida digital para detectar el sonido cuando este supera un cierto umbral, regulado a través de un potenciómetro ubicado en la placa.

La salida analógica permite obtener una estimación del volumen registrado. Sin embargo, como hemos comentado, este tipo de módulos con micrófono no resultan adecuados para medir el sonido de forma analógica ya que carecen de amplificación.

i solo queremos detectar el sonido, y no medirlo, este tipo de sensores son más apropiados ya que únicamente requieren la lectura de una señal digital, sin necesitar realizar más cálculos.

Este tipo de sensores pueden ser útiles, por ejemplo, para encender un dispositivo cuando se detecte sonido, encender una lámpara con una palmada, o incluso orientar un robot o una torre con servos mediante sonido.

Esquema de Montaje

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Ahora si queremos usar la lectura digital, conectamos la salida DO a una de las entradas digitales de Arduino.

Deberemos calibrar el umbral de disparo de la salida digital con el potenciómetro instalado en el módulo para el nivel de sonido deseado.

Mientras que la conexión vista desde Arduino quedaría así,

Si quisiéramos emplear el valor analógico, simplemente conectaríamos la salida AO del sensor a una entrada analógica de Arduino. Aunque, como hemos dicho, en este caso sería mejor optar por un modelo amplificado.

Código de ejemplo

En el primer ejemplo de código, empleamos la señal digital del sensor para encender el LED integrado en Arduino si se detecta sonido, y apagarlo en caso contrario.

const int pinLED = 13;
const int pinMicrophone = 9;
 
void setup ()
{
  pinMode (pinLED, OUTPUT);
  pinMode (pinMicrophone, INPUT);
}
 
void loop ()
{
  bool soundDetected = digitalRead(pinMicrophone);
  if (soundDetected)
  {
    digitalWrite (pinLED, HIGH);
    delay(1000);
  }
  else
  {
    digitalWrite (pinLED, LOW);
    delay(10);
  }
}

En el siguiente ejemplo almacenamos un estado (ON/OFF) y hacemos que varíe cada vez que se detecte un sonido. En el ejemplo empleamos el estado para encender o apagar el LED integrado, pero en un caso real realizaríamos las acciones oportunas como activar un relé.

const int pinLED = 13; 
const int pinMicrophone = 9;
bool state;
 
void setup()
{
  pinMode(pinLED, OUTPUT);
  pinMode(pinMicrophone, INPUT_PULLUP);
}
 
void loop()
{
  bool soundDetected = digitalRead(pinMicrophone); 
  if (soundDetected == true)
  {
    state = ! state;    
    digitalWrite(pinLED , state);
    delay (1000);
  }
  delay(10);
}

Introducción

El PN532 es un chip NFC que podemos conectar a un procesador como Arduino para leer y escribir tarjetas NFC, comunicarse con móviles, o incluso actuar como tag NFC. Es un integrado ampliamente utilizado en todo tipo de dispositivos comerciales que implementan NDC.

Introducción

Los sensores PIR le permiten detectar movimiento, casi siempre se usan para saber si un humano se ha movido dentro o fuera del rango de los sensores.

Las siglas PIR vienen del inglés "Passive Infrared" que significa "Infrarrojo Pasivo". Básicamente miden la luz infrarroja de los objetos en su campo de visión, por lo tanto, pueden detectar el movimiento en función de los cambios de esta luz en el entorno.

Son pequeños, baratos, de bajo consumo, fáciles de usar y no se desgastan. Por esa razón, se encuentran comúnmente en electrodomésticos y aparatos utilizados en hogares o empresas.

Lista de Materiales

• Módulo de Sensor PIR
• Arduino UNO (cualquier versión)
• LED
• Buzzer
• Protoboard
• Cables de conexión
• Resistencia de 330 ohmios

Conexión

Conectar los sensores PIR a un microcontrolador Arduino es realmente simple. El PIR actúa como una salida digital que puede ser de alto o bajo voltaje.

Entonces, todo lo que necesita hacer es escuchar en una entrada digital en su Arduino. Si el pin emite un un pitido agudo significa que fue detectado, contrariamente un pitido grave indica que no lo fue.

Es probable que desee volver a activarlo, así que asegúrese de poner el puente en la posición H.

Alimente el PIR con 5V y conecte tierra a tierra. Luego conecte la salida a un pin digital. En este ejemplo usaremos el pin 2.

Código

El código es muy simple y básicamente mantiene un registro de si la entrada al pin 2 es alta o baja. También realiza un seguimiento del estado del pin, de modo que imprime un mensaje cuando el movimiento se ha iniciado y se ha detenido.

void setup() {
	pinMode(2, INPUT); //PIN 2 as INPUT
	pinMode(3, OUTPUT); //PIN 3 as OUTPUT
}
		
void loop() {
	if (digitalRead(2) == HIGH){
		digitalWrite(3, HIGH); // turn the LED/Buzz ON
		delay(100); // wait for 100 msecond 
		digitalWrite(3, LOW); // turn the LED/Buzz OFF
		delay(100); // wait for 100 msecond 
	}
}
	

	
/*
* PIR sensor tester
*/ 
int ledPin = 13;                // choose the pin for the LED
int inputPin = 2;               // choose the input pin (for PIR sensor)
int pirState = LOW;             // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
		 
void setup() {
	pinMode(ledPin, OUTPUT);      // declare LED as output
	pinMode(inputPin, INPUT);     // declare sensor as input
	Serial.begin(9600);
}
 
void loop(){
	val = digitalRead(inputPin);  // read input value
	if (val == HIGH) {            // check if the input is HIGH
		digitalWrite(ledPin, HIGH);  // turn LED ON
		if (pirState == LOW) {
			// we have just turned on
			Serial.println("Motion detected!");
			// We only want to print on the output change, not state
			pirState = HIGH;
		}
	} else {
		digitalWrite(ledPin, LOW); // turn LED OFF
		if (pirState == HIGH){
			// we have just turned of
			Serial.println("Motion ended!");
			// We only want to print on the output change, not state
			pirState = LOW;
		}
	}
}