¿Qué es este blog?

La idea de este blog nace para compartir los avances que se vayan realizando a lo largo de un estudio sobre cómo interconectar los distintos sensores que se pueden encontrar en el mercado, o fabricar de forma casera, con la plataforma Mindstorms de LEGO. Para ello se hará uso ARDUINO, un entorno de desarrollo abierto basado en microcontrolador.

domingo, 12 de junio de 2011

Lector RFID ID-20 y su conexión con Arduino y el NXT


El segundo sensor con el que se han realizado pruebas ha sido el lector de tarjetas RFID ID-20 de la empresa ID Innovations. Se trata de un pequeño módulo con antena incorporada, que detecta cuando se le acerca un tag RFID y devuelve a través del puerto serie su código de identificación. Las principales características de este dispositivo, que podemos ver en la figura de abajo, se listan a continuación:
-       Alimentación de 5 V
-       Frecuencia de lectura: 125 KHz
-       Permite conexiones en serie a 9600 baudios y con puertos de tipo RS-232
-       Es capaz de leer los tags RFID a una distancia de 200 mm aproximadamente
-       El tamaño del dispositivo es de 38x70x7 mm.

Figura  Lector RFID ID-20
Para facilitar la integración de este lector con Arduino, y para poder hacer pruebas pinchándolo directamente sobre una placa de prototipos, se ha usado también una base con conector USB como la que se ve en la figura siguiente:

Figura Lector RFID USB
Como se aprecia en la figura anterior, esta placa tiene un zócalo que permite insertar el lector ID-20. Además de permitir la transferencia de datos mediante el puerto USB, esta placa sigue permitiendo la transmisión de datos vía serie con la misma configuración antes mencionada. Además, la placa consta de un pequeño zumbador para avisar de que ha leído un tag RFID, así como de un led que se encenderá cuando ésta se encuentre alimentada.

Conexiones entre el dispositivo y Arduino

Las conexiones que se han realizado han sido las siguientes: 

  •      El dispositivo necesita para funcionar una tensión de alimentación de 5 V, por lo que en el caso de querer alimentarlo exclusivamente con la placa de Arduino, se deberá conectar el pin de 5 V del mismo con  el pin VCC de la placa RFID USB.
  •        Los pines de tierra de la placa USB se conectarán a cualquiera de las tierras que ofrece Arduino.
  •        El pin TX de la placa USB es aquel por el que se enviarán los datos que posteriormente Arduino recibirá y procesará. Dicho pin deberá conectarse con el pin RX0 de Arduino, que en el caso de Arduino Mega 2560 es el pin 0.
  •        El resto de pines no es necesario conectarlos, aunque si se quisiera un mayor alcance de recepción de datos podría incorporarse una antena al pin AN1 o al AN2 de la placa.

Código cargado en Arduino

La función que realiza el código que se muestra a continuación es, tras configurar la conexión por puerto serie a una velocidad de 9600 baudios, esperar a que el dispositivo le devuelva un identificador RFID válido. Esto ocurre cuando se acerca un tag válido al lector.
Para identificar que el valor recibido es correcto, se ha tenido en cuenta que los tags se reciben como una cadena de caracteres que siempre empieza con el valor “02” y termina con el valor “03”. Todo lo que se reciba entre estos dos valores forma parte del identificador.

Además, este código recibido se almacena en el array denominado “buffersalida” que será enviado al NXT. El procedimiento para prepararlo y enviarlo es similar al que ya se vio en el caso del IMU presentado en el apartado 5.1, sólo que en esta ocasión los datos se transmiten como bytes.
El código implementado es el siguiente:



#include <Wire.h> //Para gestionar las comunicaciones

//Definiciones y variables globales
uint8_t SensorVersion[9] = " V0.1   ";
uint8_t SensorName[9] =    "RFIDReadr";
uint8_t SensorType[9] =    "RFID    ";
byte buffersalida[] = { 0, 0, 0, 0, 0, 0}; //Para enviar al RCX
byte buffrfid[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; //Para el tag
//uint8_t buffrfid[13];

int val = 0;                    //Datos que se leeran del acelerometro o giroscopo
unsigned long timer=0;          //timer
unsigned long  delta_t;         //delta o tiempo entre muestras

byte rec;

void setup(){
 
  Serial.begin(9600);
  Wire.begin(1); //Nos unimos como esclavos con dir. 1
  Wire.onRequest(requestEvent); //Rutinas para cuando llegue algo
  Wire.onReceive(receiveEvent);
}


void loop(){
  char IDstring[13]; //Para almacenar el tag
    int  i;
  
    if (Serial.available() > 0 ) {
      Serial.println("Tarjeta detectada");
      if ( (val = Serial.read()) == 02 ) {    // Se busca el inicio del codigo
        Serial.print("[SOT] ");
                                              // Se lee hasta llegar al final
        for ( i = 0; (val = Serial.read()) != 03 ; i++) {
          Serial.print(val, HEX);
          Serial.print(" ");
          IDstring[i] = val;
          buffrfid[i] = val;
        }
        Serial.println("[EOT]");
        Serial.println();
        Serial.print("  IDString[");
        IDstring[10] = 0x00;  
        Serial.print(IDstring);
        Serial.println("] ");
        Serial.println();
}
    }
 } 
void receiveEvent(int len){ //Devuelve el nº de bytes recibidos
  while (0 < Wire.available() ) {
    rec = Wire.receive();
  } //While
}
void requestEvent(){

  Serial.print(rec, BYTE);
  if (rec == 0x00){ //Version del sensor
    Wire.send(SensorVersion, 8);
  } else if (rec == 0x08){ //Nombre del sensor
    Wire.send(SensorName, 8);
  } else if (rec == 0x10){ //Tipo del sensor
    Wire.send(SensorType, 8);
  } else if (rec == 0x05) { // Lectura del tag
      Wire.send(buffrfid, 14);
  } else {
    buffersalida[0] = 0;
    buffersalida[1] = 0;
    Wire.send(buffersalida, 2);
  }
}



Código cargado en el NXT




A continuación se muestra el código que se ha cargado en el NXT. Este código, similar al usado para recibir los datos del IMU que se conectaba a Arduino. Al igual que entonces, en primer lugar se procede a obtener los datos del sensor (versión, tipo e identificador), y a continuación se obtienen los tags que se vayan leyendo desde el lector. Para que la información de la lectura de los tags se muestre en hexadecimal, se hace la conversión de los bytes que vayan llegando usando las función toHexString propia de los tipos enteros. El código completo es el siguiente:

import lejos.nxt.*;

public class ArduCom {

            public static void main(String[] args) throws Exception{
                       byte [] dato = new byte[15];
                       String Tipo = "";
                       String ID ="";
                       String Ver="";
                       String cad="";
                       int err = 0;
                      
                       for (int i=0;i<dato.length;i++){
                                   dato[i] = 0;
                       }
                      
                       I2CSensor Arduino = new I2CSensor(SensorPort.S1);
                       Arduino.setAddress(1);
                       Ver = Arduino.getVersion();
                       System.out.println("Ver: "+Ver);
                       Tipo = Arduino.getSensorType();
                       System.out.println("Tipo: "+Tipo);
                       ID = Arduino.getProductID();
                       System.out.println("ID: "+ID);
                       Thread.sleep(1000);
                       while (!Button.ESCAPE.isPressed()) {
                                   err = Arduino.getData(5, dato, 15);

                                               System.out.print("Tag: ");
                                               for(int i=0; i<14;i++) {
                                                          int num = (int)dato[i];
                                                          cad = Integer.toHexString(num);
                                                          System.out.print(cad+" ");
                                               }
                                               Thread.sleep(1000);
                                               System.out.println();
                       } //Fin del while
            }         
}

No hay comentarios:

Publicar un comentario