RFID MFRC522 con Arduino UNO

Para empezar, el modulo RFID MFRC522 (Radio Frequency IDentification) es un dispositivo de sistema de identificación, ya sea con tarjetas, llaveros u otros objetos. En la actualidad es más frecuente el uso de métodos de identificación para la vida diaria, como por ejemplo, sistemas de seguridad, control, identificación de personal, entre muchas más. Este modulo permite la detección de este tipo de objetos, dichos objetos cuentan con un microcontrolador y una antena (en PCB) los cuales son activadas por señales de radiofrecuencia proporcionada por el RFID-RC522 (en este caso con el MFRC522).

El modulo MFRC522 utiliza comunicación SPI, por lo que es compatible con cualquier Arduino, tarjeta de desarrollo o microcontrolador. En este tutorial se realzara un ejemplo el cual consiste en dos LEDs indicadores, simulando un sistema de seguridad, que a su vez son activados con la tarjeta o llavero. Cuando la tarjeta o llavero sea detectado por el modulo RFID un LED color verde indicara la autorización

Características Generales MFRC522

  • Distancia aproximada de detección del tag= 4 cms.
  • Voltaje: 3.3 volts,
  • 13 mA. Corriente máxima = 30 mA.
  • Especificación del tag: Mifare MF1S503 con 1 Kb de EEPROM
  • Frecuencia de operación: 13.56 Mhz
  • Interfaz: conector header de 8 pines, SPI, con velocidad hasta 10 Mbps.
  • Temperatura de operación: -20 a +60 grados C.
  • Dimensiones: 40 x 60 mm.

Materiales

  • Arduino UNO R3
  • Modulo RFID-RC522
  • Llaveto y/o tarjeta del modulo RFID-RC522 MFRC522
  • Cables Jumper
  • Protoboard
  • 2 LEDs

Conexión del Modulo MFRC522 RFID-RC522 con Arduino

rfid arduino

MFRC522

Librerías para el Arduino compatibles con MFRC522

MFRC522

Descargar el Archivo ZIP: https://github.com/miguelbalboa/rfid

MFRC522

– 1: Descargar todo el archivo ZIP

– 2: Abrir el Programa Arduino, irse a la opción “Programa” situada en

– 3: Seleccionas el Archivo ZIP que se descargo en el link de arriba

Código del Modulo RFID-RC522

Finalmente podemos observar el código:

Sensor de color TCS3200 con Arduino

El sensor de color RGB TCS3200 LC Tech es un convertidor de luz a frecuencia que combina fotodiodos de silicio reconfigurables y una corriente de frecuencia en un solo circuito integrado. La salida es una onda cuadrada (ciclo de trabajo 50%) con una frecuencia directamente proporcional a la intensidad de luz. Las entradas y salidas digitales permiten una interfaz directa con un microcontrolador u otro conjunto de circuitos lógicos, por esta razón el sensor TCS3200 es ideal para líneas de producción, domótica, robótica, etc.

Es un convertidor de luz a frecuencia lee una matriz de 8×8 fotodiodos , de tal manera que 16 fotodiodos tienen filtro azul, 16 fotodiodos tienen filtro verde, 16 fotodiodos tienen filtro rojo y 16 fotodiodos son sin filtro.

sensor

sensor TCS3200

Especificaciones del sensor de color TCS3200

  • Alta resolución de conversión de luz a frecuencia.
  • Frecuencia de salida Programable en color y escala completa.
  • Se comunica directamente con un microcontrolador.
  • Voltaje de funcionamiento: 2.7-5.5 V.
  • Rango de error típicamente de 0,2% a 50 kHz.
  • Coeficiente de temperatura 200 ppm/°C .

Bueno en este tutorial  aprenderemos a utilizar el sensor de color RGB TCS3200 LC Tech con Arduino. El TCS3200  va detectar colores rojo, verde y azul en el monitor serial se mostrara la cantidad de color y que color es si rojo, azul o verde.

Material necesario

Función de terminales

sensor de color TCS3200

Función de terminales del sensor

 

Opciones seleccionables

Capturaaa

Tipo de fotodiodo

 

Capturaa

Escala de frecuencia de salida

 

 

Conexión con Arduino UNO

La tabla siguiente muestra hacia como se deben hacer las conexiones del sensor hacia un Arduino UNO.

conexiones1

tabla de conexiones del sensor de color con Arduino UNO

 

conexiones

Diagrama de conexiones

 

 

Programación

En la programación se abre el monitor serial y se muestra los valores de rojo, verde y azul, también se muestra cuando detecta el color rojo verde o azul, puedes modificar.

Resultados

Se compila el programa y se carga al Arduino UNO, después abrimos el monitor serial donde se muestran los datos obtenidos, cada vez que el sensor detecte un color ya sea rojo, verde o azul indicará que color es el que detecta a continuación se muestran las imágenes de los resultados.

monitor serial

monitor serial

sensor detectando color azul

sensor detectando color

 

Enlaces de interés:

 

 

 

LCD Nextion y Graficas

LCD Nextion y graficas

En el siguiente tutorial vamos a graficar en una LCD Nextion las temperaturas de tres sensores distintos y que trabajan con diferentes protocolos de comunicación (One-Wire, I2C, Analògico), las gráficas y los valores numèricos los mostraremos en la Pantalla Nextion de 2.4″.

Es importante mencionar que Las librerías para la pantalla Nextion están configuradas para trabajar con el Arduino Mega 2560 con los pines Serial 2 (Rx2, Tx2). Si desea utilizar otra Tarjeta Arduino es necesario modificar el archivo NexConfig.h, ver archivo readme.md en la carpeta de la libreria Nextion de Itead.

Las librerías para la Pantalla Nextion podrán descargarlas en el enlace de abajo.

Materiales 

  • Arduino Mega 2560
  • DS18B20 (Sensor de Temperatura One-Wire)
  • MCP9808 (Sensor de Temperatura I2C)
  • MCP9700 (Sensor de Temperatura Analògico)
  • Pantalla Nextion 2.4″
  • Protoboard

Código de Arduino

En el còdigo de Arduino esta comentado donde conectar cada sensor de Temperatura y la Pantalla Nextion.


/*HeTPro Herramientas Tecnològicas Profecionles*/
/*Tutorial para graficar Temperaturas de 3 sensores distintos*/
/*Protocolos de comunicacion I2C, One-Wire y Analògico*/ç
/*
                       Conexiones
    Nextion: Conectar a SERIAL 2 TX2 RX2(Librerias por default funciona en SERIAL 2)
    DS18B20: Conectar pin de Salida a pin Digital 3 de Arduino Mega(Sensor Digital One-Wire)
    MCP9808: Conectar a Pines I2C (20, 21) (Sensor Digital I2C)
    MCP9700:: Conectar a PIN Analògico A0 (Sensor Analògico)
*/
/*Sensor de Temperatura MCP9808 con Comunicacion I2C */
#include <Wire.h>;
#include "Adafruit_MCP9808.h"
/*Crea El Sensor MCP9808 un objeto*/
Adafruit_MCP9808 tempsensor = Adafruit_MCP9808();
/*********************************************************/
/*Sensor de Temperatura DS18B20 ONE-WIRE*/
#include &lt;OneWire.h&gt;
#include &lt;DallasTemperature.h&gt;
#define ONE_WIRE_BUS 3 //Pin 3 a Salida DS18B20
OneWire ourWire(ONE_WIRE_BUS);
DallasTemperature sensors(&ourWire);
/**********************************************************/
/*Nextion*/
#include "Nextion.h" /*Libreria para Pantalla Nexion*/
/*Funcion para Graficar las Temperaturas en la Nextion*/
NexWaveform s0 = NexWaveform(0, 1, "s0");
/*Funciones para mostrar las temperaturas numericamente*/
NexNumber n0 = NexNumber(0, 1, "n0");
NexNumber n1 = NexNumber(0, 1, "n1");
NexNumber n2 = NexNumber(0, 1, "n2");
int i;
/*********************************************************/
/* Sensor de Temperatura Analògico MCP9700*/
int mcp1 = A0;
float mcpT1 = 0;

void setup()
{
 Serial.begin(9600);
 /*Inicializacion de LCD nextion 2.4"*/
 nexInit();
 /*Inicializacion de Sensor DS18B20*/
 sensors.begin();
 /*Inicializacion MCP9808*/
 /* Direccion tempsensor.begin(0x19)*/
  if (!tempsensor.begin(0x19)) {
    Serial.println("No se enconto MCP9808!");
    while (1);
  }//end if(MCP9808)  
}//end void setup()

void loop()
{
  /*Lectura del sensor I2C MCP9808*/ 
tempsensor.shutdown_wake(0);//prepata el sensor para leer temperatura en MCP9808
float c = tempsensor.readTempC();//lee la temperatura en MCP9808
delay(5);
  /*Lectura del sensor DS18B20 ONE-WIRE*/ 
sensors.requestTemperatures(); //lee temperatura en ds18b20
delay(5);
i= sensors.getTempCByIndex(0);// lee la temperatura y asigna el valor en i
/*Lectura del sensor Analògico MCP9700*/ 
  mcpT1 = analogRead(mcp1)*5 / 1024.0;
  mcpT1 = mcpT1 - 0.5;
  mcpT1 = mcpT1 / 0.01;
  delay(5); 

/*Funciones para enviar las lecturas de los sensores a la Nextion */
/*DS18B20*/
 s0.addValue(0, i);/*Graficar Temperatura de DS18B20*/
 n2.setValue(i);/*Mostrar el Valor de DS18B20*/
 /*MCP9700*/
 s0.addValue(1, mcpT1);
 n1.setValue(mcpT1);
 /*MCP9808*/
 s0.addValue(2, c);
 n0.setValue(c);

tempsensor.shutdown_wake(1); // shutdown MSP9808 - power consumption ~0.1 mikro Ampere
 
}// end loop

Imagenes y video del Tutorial
En el siguiente link se encuentra el video del Funcionamiento completo del Tutorial: https://www.youtube.com/watch?v=LGWgJ3lgcFw&spfreload=5

LCD Nextion

Sensores de Temperatura y Nextion de 2.4″

 

LCD Nextion

Gráficas de los sensores de temperatura.

 

LCD Nextion

En la imagen podemos apreciar las gráficas y los valores de las temperaturas.

LCD Nextion

Valores para los tres sensores de temperatura

Enlaces de Interés

– Hoja de Datos MCP9808
– Hoja de Datos MCP9700
– Tutorial Editor de Nextion y Arduino UNO
– Tutorial DS18B20
– Nextion Editor
-Librterias Nextion

Sensor MCP9808 de temperatura

Introducción:

En primer lugar, el objetivo de este tutorial es mostrarla el funcionamiento y la facilidad  que tiene el sensor  MCP9808 de temperatura. Además identificar para que sirve cada pin(que posee con comunicación I2C), junto con un Arduino UNO. Finalmente observar en la terminal de comunicación de Arduino la información obtenida.

Antes que nada la biblioteca que se necesita para trabajar con este sensor es:

-Adafruit_MCP9808

Link: https://github.com/adafruit/Adafruit_MCP9808_Library/archive/master.zip

sensor MCP9808

Funcionamiento del sensor MCP9808

Descripción del sensor MCP9808:

Es un sensor de temperatura digital que conserva con una interfaz I2C la cual es compatible con los microcontroladores que manejen igualmente este mismo tipo de comunicación (la cual sea del tipo estándar).

Cuenta con un rango de exactitud /precisión el cual es muy bueno,evidentemente su tiempo de respuesta es de 15 minutos o menos.

El sensor  especialmente posee con registros que pueden ser programados por el usuario en tanto que dependiendo del rango de la temperatura o la aplicación que se tenga básicamente planeada; también el uso de estos registros se puede usar para fijar limites en la temperatura que se necesite usar.

Por ejemplo cuando la temperatura que se monitorea sobrepase los limites establecidos se puede tener en cuenta el usar la salida de alerta con la que cuenta el sensor, ademas el usuario tiene la elección de ajustar la polaridad de la señal de salida de alerta como una salida de comparador activo-alto o activo-bajo para la utilización del termostato, sin duda alguna esta es una, de algunas ventajas del sensor.

Características:

  • Rango de tensión: 2.7V a 5.5V
  • Corriente de operación (típica): 200  μA

Precisión:

  • ±0.25°C (típica) de-40°C a +125°C
  • ±0.5°C (máxima) de -20°C a 100°C
  • Resolución: 0,0625°C

Pines:

sensor MCP9808

Descripción de los pines

En esta practica realizaremos una prueba del sensor de tal manera de conocer su funcionamiento mas sencillamente, antes de comenzar te recomiendo que observes la descripción sobre los detalles de cada pin del sensor para después iniciar la practica, en el caso de la imagen inferior se muestra la posición de cada pin del sensor  para no confundirnos a la hora de la conexión. Finalmente a continuación se presentan las capas de cobre de la PCB.

Materiales:

-1 Sensor de Temperatura I2C MCP9808

-Jumpers macho-macho

-1 Arduino UNO

-1 Protoboard

Diagrama de conexiones:

sensor MCP9808

Conexiones del Sensor MCP9808

Código:

Finalmente, observaremos desde el monitor serie las lecturas que nos arroja nuestro sensor, de tal manera que las temperaturas están en Fahrenheit y Celsius:

sensor MCP9808

Lecturas obtenidas finalmente en el programa.

GPS Shield con Arduino

GPS Shield

GPS Shield vista superior

GPS Shield

 

El GPS Shield es una herramienta muy útil que nadie puede perder la oportunidad de aprender a usarla. En este tutorial aprenderán a utilizar de una manera sencilla una GPS Shield programada con Arduino. Algo que se debe hacer mención es que se necesita una librería especial llamada TinyGPS. Esta librería es de gran ayuda a la hora de programar un GPS Shield. La librería es gratis y se puede descargar de internet, aquí se les dejará el link de descarga:

http://arduiniana.org/libraries/tinygps/

En este tutorial se verá un modo sencillo de utilización, ya la información que se obtendrá será solo la longitud y la latitud. Que como ya sabrán la latitud mide el ángulo entre cualquier punto y el ecuador las líneas de latitud se denominan paralelos y la  longitud mide el ángulo a lo largo del Ecuador desde cualquier punto de la Tierra. Se acepta que Greenwich en Londres es la longitud 0 en la mayoría de las sociedades modernas. Las líneas de longitud son círculos máximos que pasan por los polos y se llaman meridianos.

Bien, empezaremos por iniciar el programa.

Seleccion de prgrama para GPS Shield

Codigo fuente para GPS Shield.

Tomando en cuenta que ya está descargada la librería y agregada a nuestro software de Arduino. Pasaremos a hacer un par de modificaciones a nuestro programa, ya que se cuenta con una par de datos extras que no nos serán del todo útiles, esto es porque tiene una función especial de distancia actual y otra es distancia para llegar a Londres, eso no se ve del todo necesario así que se procederá a solo obtener datos de ubicación del usuario.

Materiales:

#include <SoftwareSerial.h> // se declara la función SoftwareSerial

#include <TinyGPS.h> // se incluye la librería TinyGPS

/* 
 Este código de ejemplo muestra el uso normal de un objeto TinyGPS.
 Se requiere el uso de SoftwareSerial, y se supone que tiene una
 4800 baudios dispositivo GPS conectado en serie en los pines 3 (RX) y 4 (TX).
*/
TinyGPS gps;
SoftwareSerial ss(4, 3); // Se declara los pines 4 y 3 como TX y RX

static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);

void setup()
{ // declaración de datos textuales que veremos en
 Serial.begin(115200); //El monitor serial 
 
 Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
 Serial.println("by Mikal Hart");
 Serial.println();
 Serial.println("Sats HDOP Latitude Longitude Chars Sentences Checksum");
 Serial.println(" (deg) (deg) RX RX Fail");
 Serial.println("---------------------------------------------------------");

 ss.begin(9600);
}

void loop()
{
 float flat, flon;
 unsigned long age, date, time, chars = 0;
 unsigned short sentences = 0, failed = 0;
 static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
 
 print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
 print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
 gps.f_get_position(&flat, &flon, &age);
 print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
 print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
 print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
 // print_date(gps);
 // print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
 // print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
 //print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
 //print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
 // print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
 // print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
 // print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);

 gps.stats(&chars, &sentences, &failed);
 print_int(chars, 0xFFFFFFFF, 6);
 print_int(sentences, 0xFFFFFFFF, 10);
 print_int(failed, 0xFFFFFFFF, 9);
 Serial.println();
 
 smartdelay(1000);
}

static void smartdelay(unsigned long ms)
{
 unsigned long start = millis();
 do 
 {
 while (ss.available())
 gps.encode(ss.read());
 } while (millis() - start < ms);
}

static void print_float(float val, float invalid, int len, int prec)
{
 if (val == invalid)
 {
 while (len-- > 1)
 Serial.print('*');
 Serial.print(' ');
 }
 else
 {
 Serial.print(val, prec);
 int vi = abs((int)val);
 int flen = prec + (val < 0.0 ? 2 : 1); // . and -
 flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
 for (int i=flen; i<len; ++i)
 Serial.print(' ');
 }
 smartdelay(0);
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
 char sz[32];
 if (val == invalid)
 strcpy(sz, "*******");
 else
 sprintf(sz, "%ld", val);
 sz[len] = 0;
 for (int i=strlen(sz); i<len; ++i)
 sz[i] = ' ';
 if (len > 0) 
 sz[len-1] = ' ';
 Serial.print(sz);
 smartdelay(0);
}

static void print_date(TinyGPS &gps)
{
 int year;
 byte month, day, hour, minute, second, hundredths;
 unsigned long age;
 gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
 if (age == TinyGPS::GPS_INVALID_AGE)
 Serial.print("********** ******** ");
 else
 {
 char sz[32];
 sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
 month, day, year, hour, minute, second);
 Serial.print(sz);
 }
 print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
 smartdelay(0);
}

static void print_str(const char *str, int len)
{
 int slen = strlen(str);
 for (int i=0; i<len; ++i)
 Serial.print(i<slen ? str[i] : ' ');
 smartdelay(0);
}

Con este código obtendremos los valores deseados del satélite, hay que cargarlo al Arduino una vez ya montado el GPS Shield y la antena, que claro, es indispensable para que funcione nuestra GPS Shield, aunque existen muchos tipos de antenas, se han utilizado dos y cualquiera de las dos se recomienda para utilizar. La antena la puedes encontrar en nuestra tienda virtual www.hetpro-store.com.

 

Antena GPS Shield.

Antena para recepcion de datos.

Antena GPS Shield opcional.

ANtena GPS para recepcion de datos.

 

 

En la primera opción se muestra la antena que es la más común al venderse y trabaja bien aunque se recomendaría que se utilizara la segunda opción (si pueden), ya que cuenta con un poco más de rapidez a la hora de conectarse al satélite, de manera que es más probable que se obtengas los datos un poco más rápidos con la segunda antena.

GPS sHield montaje completo.

Montaje de la GPS Shield completa.

 

Una vez ya conectado y cargado el programa es hora de abrir el monitor serial, ojo, es probable que a la primera no funcione como se desea, hay que ser un poco pacientes ya que unas antenas se tardan un poco más que otras en conectarse al satélite, pero descuiden una vez conectada obtendrán una lectura como la siguiente.

Vista de datos en monitor serial.

Recepcion de datos, monitor serial.

Para terminar y saber si nuestro GPS Shield funciona solo basta con copiar y pegar las coordenadas (latitud y longitud) en aplicación de ubicación preferida, en este ejemplo utilizare Google Maps para que se den una idea de cómo hacerlo:

Ubicación dada por GPS Shield.

Ubicacion MAPS

De esta manera sabemos si los datos que se están recibiendo son acertados o no, solo basta con copiar y pegar las coordenadas en el buscador de Maps y este interpretará al instante de que son coordenadas geográficas además de que son muy acertadas, la ubicación es dentro de la tienda Hetpro y apenas el rango de error es unos 3-5 metros de diferencia.

De esta manera se concluye este tutorial de cómo darle un uso básico, así más adelante podremos utilizar mas funciones de este como utilizar la SD para guardar datos y muchos otros usos más.