125Khz RFID module - UART - RDM 630

Tenho visto várias empresas com acesso por cartões utilizando RFID e fiquei curioso para saber como funciona esta tecnologia. Encontrei no site seedstudio o produto 125Khz RFID Module modelo RDM630 com um preço bem razoável e resolvi testar para entender o funcionamento.

Na imagem acima está apresentada a montagem que fiz com o módulo em uma breadboard e com a saída da leitura dos cartões ou chaveiros para o LCD serial. A antena é bem frágil e por isso montei dentro de um saco plástico para proteção. Para controlar o sistema utilizei a placa Tatuino nano da tato.ind.br.

Quando o chaveiro RFID é passado a uma distância de no máximo 5 cm da antena os dados do chip são apresentados na tela LCD com o MAC adress e checksum. O código é basicamente para apresentar os dados da porta serial no terminal da IDE do arduino ou em um LCD como eu fiz.

Os dados  vem em formato ASCII, segundo modelo abaixo:

02 / 10ASCII Data Characters / Checksum  / 03
O módulo é bem simples de montar porque já vem com os pinos soldados e encaixa sem problemas nos furos da breadboard, sendo a montagem que fiz a seguinte:

RDM630 - INTERFACE TTL RS232

 P1
PIN 1 TX - Para o RX do arduino
PIN 2 RX - Para o TX do arduino
PIN 3 - Livre
PIN 4 - Ground
PIN 5 - 5 V

P2
PIN1 - Fio vermelho da antena
PIN1 - Fio preto da antena

P3
Para conexão de led- não utilizei

O código usado neste exemplo foi modificado para apresentação dos dados no lcd e foi montado para uso com o leitor de RFID ID-12 vendido na sparkfun:

---------------------------------------------------------------------------------------------------------------------------

// RFID reader ID-12 for Arduino 
// Based on code by BARRAGAN  
// and code from HC Gilje - http://hcgilje.wordpress.com/resources/rfid_id12_tagreader/
// Modified for Arudino by djmatic
// Modified for ID-12 and checksum by Martijn The - http://www.martijnthe.nl/
//
// Use the drawings from HC Gilje to wire up the ID-12.
// Remark: disconnect the rx serial wire to the ID-12 when uploading the sketch

#include <SoftwareSerial.h>

#define txPin 2
SoftwareSerial LCD = SoftwareSerial(0, txPin);

void setup() {
  Serial.begin(9600);                                 // connect to the serial port
  pinMode(txPin, OUTPUT);
  LCD.begin(2400);
  clearLCD();
  clearCURSOR();
}

void loop () {
  byte i = 0;
  byte val = 0;
  byte code[6];
  byte checksum = 0;
  byte bytesread = 0;
  byte tempbyte = 0;

  if(Serial.available() > 0) {
    if((val = Serial.read()) == 2) {                  // check for header 
      bytesread = 0; 
      while (bytesread < 12) {                        // read 10 digit code + 2 digit checksum
        if( Serial.available() > 0) { 
          val = Serial.read();
          if((val == 0x0D)||(val == 0x0A)||(val == 0x03)||(val == 0x02)) { // if header or stop bytes before the 10 digit reading 
            break;                                    // stop reading
          }

          // Do Ascii/Hex conversion:
          if ((val >= '0') && (val <= '9')) {
            val = val - '0';
          } else if ((val >= 'A') && (val <= 'F')) {
            val = 10 + val - 'A';
          }

          // Every two hex-digits, add byte to code:
          if (bytesread & 1 == 1) {
            // make some space for this hex-digit by
            // shifting the previous hex-digit with 4 bits to the left:
            code[bytesread >> 1] = (val | (tempbyte << 4));

            if (bytesread >> 1 != 5) {                // If we're at the checksum byte,
              checksum ^= code[bytesread >> 1];       // Calculate the checksum... (XOR)
            };
          } else {
            tempbyte = val;                           // Store the first hex digit first...
          };

          bytesread++;                                // ready to read next digit
        } 
      } 

      // Output to Serial:

      if (bytesread == 12) {   
       clearLCD();
       clearCURSOR();
       selectLineOne();        // if 12 digit read is complete
       LCD.print("Code:");
        for (i=0; i<5; i++) {
          if (code[i] < 16) LCD.print("0");
           LCD.print(code[i], HEX);
        }
        Serial.println();
        selectLineTwo();
        LCD.print("Check:");
        LCD.print(code[5], HEX);
        LCD.print(code[5] == checksum ? "-passed" : "-error");       
        
      }

      bytesread = 0;
    }
  }
}

void selectLineOne(){  //puts the cursor at line 0 char 0.
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(128, BYTE);    //position
}
void selectLineTwo(){  //puts the cursor at line 0 char 0.
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(192, BYTE);    //position
}

void clearCURSOR(){
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(0xC, BYTE);   //clear command.
}

void clearLCD(){
   LCD.print(0xFE, BYTE);   //command flag
   LCD.print(0x01, BYTE);   //clear command.
}

void serCommand(){   //a general function to call the command flag for issuing all other commands   
  LCD.print(0xFE, BYTE);
}

----------------------------------------------------------------------------------------------------------------------------

Alguns links com outros exemplos:

http://www.gumbolabs.org/2009/10/17/parallax-rfid-reader-arduino/
http://planaheist.com/imagehost/?v=dsc00456.jpg
http://www.trileet.com/node/34
http://kalshagar.wikispaces.com/ARCPO
http://www.arduino.cc/playground/Code/ID12
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1274920778
http://blog.formatlos.de/2008/12/08/arduino-id-12/

STM8S-Discovery & MSP-EXP430G2 LaunchPad

Duas grandes empresas mundiais estão lançando no mercado placas de desenvolvimento para concorrer no mercado amador com a arduino. Achei interessante registrar este fato pois é a primeira vez que estas big muitinacionais lançam este tipo de produto. A Atmel e a Pic já estão no mercado faz tempo com algumas placas de desenvolvimento mas não são produtos com características tão próximas da arduino como estes.


STM8S-Discovery - http://www.st.com/mcu/contentid-130-113-STM8S_DISCOVERY.html

Uma placa de avaliação do chip STM8S com conexão usb e custo abaixo de USD 10,00 com IDE gratuita.


MSP-EXP430G2 - http://www.ti-estore.com/Merchant2/merchant.mvc?Screen=PROD&Product_Code=MSP-EXP430G2

Aproveite o lançamento deste produto para comprar a placa por USD 4,00 com frete gratis no site da ST. A placa vem com conexão usb, exemplos e IDE gratuita.

SHIFT REGISTER M74HC595 + DISPLAY 7 SEGMENTOS

Continuando com as experiências com a arduino montada na breadboard, resolvi aprender a usar os chips de shift register que expandem as portas digitais da arduino.

Nos exemplos do comando ShiftOut site arduino.cc existem esquemas e bons exemplos, porém como sempre, não consegui encontrar o chip 74HC595 da philips que é usado em todos os exemplos que encontrei na web. O chip que achei é um clone compatível do fabricante SGS-THOMSON modelo M74HC595F1R.

Mudam os nomes dos pinos e sua posição mas as funcionalidades são exatamente as mesmas. Isso aconteceu também com o display de 7 segmentos que achei, tive que testar todos os pinos para achar qual era aordem correta de conexão, o modelo do display é HS5101AG VERDE - CATODO (COM TERRA COMUM), nao consegui achar nada de documentação deste.

O site mais completo que achei sobre o assunto com exemplos foi :

http://tronixstuff.wordpress.com/2010/04/30/getting-started-with-arduino-%E2%80%93-chapter-four/

Nao tem nehum esquema da montagem no site acima, mas tem explicações sobre o funcionamento do sistema bem feitas. O mais interessante é que a foto do chip que ele usa é a do modelo que encontrei e usei mas o resto das explicações são sobre o chip da philips...

Segue o meu esquema de pinagem:

O chip M74HC595 recebe do microcontrolador por meio do comando ShiftOut um número decimal que é convertido em binário, este número binário representa os pinos que devem ser ligados e desligados para acender ou apagar os leds que formam um certo número ou letra.

São 7 segmentos e um ponto, por tanto, oito leds para serem controlados por uma sequencia de oito zeros e uns.

Veja nos comentários abaixo o número decimal, o binário interpretado pelo chip e o número a ser apresentado no display .

Segue o  sketch que montei par apresentar todos os números em série:

--------------------------------------------------------------------------------------------

/*
Claudio Miklos based on work by Carlyn Maw and Tom Igoe
 */



int latchpin = 11; // conecta no pino 14 do M74HC595
int clockpin = 10; // conecta no pino 12 do M74HC595
int datapin = 9; // conecta no pino 11 do M74HC595
void setup()
{
   pinMode(latchpin, OUTPUT);
   pinMode(clockpin, OUTPUT);
   pinMode(datapin, OUTPUT);
}
void loop()
{
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 63); // 111111 = 0
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 6); // 110 = 1
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 91); // 1011011 = 2
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 79); // 1001111 = 3
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 102); // 00000100 = 4
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 109); // 1101101 = 5
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 125); // 1111101 = 6
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 7); // 00000111 = 7
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 127); // 1111111 = 8
     digitalWrite(latchpin, HIGH);
     delay(1000);
          digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 111); // 1101111 = 9
     digitalWrite(latchpin, HIGH);
     delay(1000);
           digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 128); // 10000000 = DP
     digitalWrite(latchpin, HIGH);
     delay(1000);
                digitalWrite(latchpin, LOW);
     shiftOut(datapin, clockpin, MSBFIRST, 255); // 11111111 = TUDO
     digitalWrite(latchpin, HIGH);
     delay(1000);
 }

-------------------------------------------------------------------------------------------------------

O objetivo agora é fazer um termometro usando o que aprendi nos experiencias anteriores e montar tudo em uma placa de circuito de verdade.

ARDUINO BREADBOARD + ARDUINO ISP

Este fim de semana montei a arduino em uma protoboard seguindo as instruções do site http://itp.nyu.edu/physcomp/Tutorials/ArduinoBreadboard. O chip ATMEGA328 tive que encomendar do mercado livre porque não encontrei em nenhuma loja na santa efigênia. Somente encontrei o ATMEGA8 em uma loja pequena depois de rodar a manhã de sábado inteira, assim mesmo eram as duas últimas unidades.

O resto dos componentes foi fácil encontrar (tudo nesta loja) , segue abaixo uma lista com os valores que paguei:

• Protoboard = R$ 15,00 (unit)
• Fios = R$ 2,00 (2 m)
• 1 x 7805 Regulador de Voltagem= R$ 0,70 (unit)
• 2 x LED = R$ 0,25 (unit)
• 2 x 220 Ohm resistor = R$ 0,01 (unit)
• 1 x 10k Ohm resistor = R$ 0,01 (unit)
• 2 x 10 uF capacitor = R$ 0,05 (unit)
• 1 x 16 MHz clock crystal = R$ 0,60 (unit)
• 2 x 22 pF capacitor = R$ 0,05 (unit)
• 1 x 0.1 uF capacitor = R$ 0,05 (unit)
• 1 x Botão Reset = R$ 0,10 (unit)
• ATMEGA328 = R$ 19,00 
• Cabo TTL = R$ 25,00

ARDUINO PROTOBOARD =  R$ 23,00 (sem protoboard e cabo)
ARDUINO 2009 ML = R$ 98,00
ARDUINO 2009 legalizada = R$ 136,00 (http://www.multilogica-shop.com/)
 Diversão = não tem preço :-)

O que me preocupava mais era queimar o bootloader no chip ATMEGA328. Em geral é necessário ter um programador especial para isso, mas agora na versão 0018 da IDE do Arduino existe a possibilidade de utilizar a própria placa 2009 como programador para os chips ATMEL. Com isso foi fácil conectar as duas placas e programar o chip. Veja instruções neste endereço : http://arduino.cc/en/Tutorial/ArduinoISP.

Para programar, depois de ter queimado o bootloader, eu já tinha um cabo TTL e assim estou utilizando este para transferir os sketches. Somente tive que montar na breadborad uma adaptação com seis pinos conectados nas portas RX e TX e Reset do chip.

O plano agora é transferir a montagem para uma placa de circuito pronta e assim deixar meus projetos mais permanentes.