RF-ID uygulaması (PIC16F88 SN75176 CCS)

Selam Arkadaşlar, Bu çalışma, 125kHz RFID kart okuma mantığını öğrenmek isteyenler için hazırlanmış, eğitim amaçlı ve geliştirilmeye açık bir PIC uygulamasıdır. Denetleyici olarak PIC16F88 kullanılmıştır. PIC16F88, giriş/çıkış yapısı ve çevresel birimleri açısından sade ama yeterli bir çözüm sunduğu için bu tip kart okuma ve kontrol projelerinde pratik bir tercih olur.

PIC ailesine giriş yapmak isteyenler için PIC16F628A ile kıyaslandığında daha esnek bir yapı sunması da önemli bir avantajdır.

Devre, EM4100 olarak bilinen 125kHz RFID kartları okuyup aldığı kimlik bilgisini seri haberleşme hattı üzerinden dışarı aktarır. Okunan veri gönderildikten sonra sistem yaklaşık 5 saniye boyunca karşı taraftan cevap bekler.

Gelen cevap E karakteri ise yeşil LED, buzzer ve röle birlikte çalışır; farklı bir cevap gelirse veya hiç cevap gelmezse kırmızı LED ve buzzer uyarı verir. Bu yapı, temel bir erişim kontrol uygulamasının nasıl kurulacağını anlaşılır biçimde gösterir.

Devrenin çalışma mantığı

Sistemin merkezinde PIC16F88 bulunur. RFID okuyucu modülden gelen veri önce mikrodenetleyici tarafından alınır, ardından seri hatta gönderilir. Harici sistemden gelen onay bilgisine göre çıkış elemanları sürülür. Bu sayede kart okuma, karar verme ve çıkış kontrolü tek kart üzerinde toplanmış olur.

Benzer mantığın daha gelişmiş bir kartlı geçiş yapısına nasıl dönüştürülebileceğini görmek için RFID erişim kontrolü projesi de incelenebilir.

RF-ID Devre şeması

Devre Şeması Ana Bloklar

• PIC16F88 kontrol bölümü: 4MHz kristal, 2 adet 22pF kondansatör, MCLR hattında 4K7 pull-up ve besleme tarafında 100nF bypass kondansatörü ile kurulmuş temel mikrodenetleyici yapısı görülüyor.
• RFID okuyucu arayüzü: Modül tarafında RDY/CLK, MOD, SHD ve OUT hatları doğrudan PIC pinlerine bağlanmış. Böylece modülün veri toplama ve kontrol hatları mikrodenetleyiciye aktarılmış oluyor.
• RS485 haberleşme katı: SN75176 transceiver ile seri veri diferansiyel hatta taşınıyor. Şemada 120R terminasyon ve 560R bias elemanları da gösterilmiş.
• Röle sürücü katı: Röle, BC237 transistörü ile sürülüyor. Bobin üzerinde 1N4148 diyot bulunuyor. Bu kısım PIC çıkışının doğrudan röleyi yüklememesi açısından doğru bir ayrım sağlıyor.
• Görsel ve sesli uyarı bölümü: Yeşil LED, kırmızı LED ve buzzer ile kullanıcıya kart sonucu anlık olarak bildiriliyor.
• Besleme bölümü: 9V-12V AC giriş, 2A köprü doğrultucu ve 7805 regülatör ile 5V besleme elde ediliyor.

PIC16F88 pin dağılımı ve görevler

Şemadaki pin isimleri ile yazılım içeriği birlikte okunduğunda, RA1 röle çıkışı, RA2 ve RA3 LED çıkışları, RB7 buzzer kontrolü, RB1 modülün SHD hattı, RB4 MOD hattı, RB3 demodüle veri çıkışı ve RB6 RDY/CLK hattı olarak kullanılıyor.

Bu dağılım, hem modül kontrolünü hem de kullanıcı geri bildirimini tek bir PIC üzerinde toplamak için dengeli bir seçimdir.

CCS C yazılım tarafında neler yapılıyor?

Yazılım CCS C ile hazırlanmıştır. Kodun başlangıcında ADC girişleri kapatılıyor, karşılaştırıcı birimleri devre dışı bırakılıyor ve RFID modülünü yöneten sürücü dosyaları dahil ediliyor.

Ardından 9600 baud seri haberleşme tanımlanarak karttan okunan 5 baytlık veri dışarı aktarılıyor.

Program akışında kart başarılı biçimde okununca önce kısa bir sesli ve görsel bildirim veriliyor, sonra kart kodu seri hatta gönderiliyor.

Harici taraftan belirlenen süre içinde cevap gelirse buna göre doğru veya yanlış geri bildirimi üretiliyor.

Bu , kart doğrulama kararının bilgisayar ya da üst seviye kontrol sistemine bırakıldığı yarı dağıtık bir yapı sunar.

PIC tarafını derleme ve test aşamasında pratik bir programlayıcı çözümü arayanlar için Arduino ile USB PIC programlayıcı içeriği de faydalı olabilir.

SN75176 ile RS485 kullanımının avantajı

Projede yalnızca basit TTL seri çıkışla yetinilmemiş, ayrıca SN75176 üzerinden RS485 haberleşme katı da eklenmiştir. Bu sayede hat daha dayanıklı hale gelir ve özellikle kart okuyucu ile ana kontrol birimi arasında daha sağlam bir veri iletimi kurulabilir.

İsteyen kullanıcı bu bölümü iptal edip farklı haberleşme uyarlamaları da yapabilir. Temel seri haberleşme mantığını görmek isteyenler için RS232 seri iletişim portu hakkında bilgiler bağlantısı da yararlı olacaktır.

Uygulamanın öne çıkan tarafları

• Eğitim odaklıdır: Kart okuma, seri veri gönderme, cevap bekleme ve çıkış kontrolü tek projede toplanmıştır.
• Modülerdir: RFID okuyucu, haberleşme, uyarı ve röle sürme kısımları ayrı ayrı geliştirilebilir.
• Gerçek uygulamaya yakındır: Sadece kart numarası okuyup göstermekle kalmaz, dışarıdan gelen onaya göre karar verir.
• Kaynak dosyaları paylaşılmıştır: Proteus, program ve kaynak kod dosyalarıyla birlikte verilmesi projeyi daha kullanışlı hale getirir.

Geliştirme açısından neler yapılabilir?

• Kart kodları harici bilgisayara bırakılmadan PIC içinde EEPROM üzerinde tutulabilir.
• Yetkili ve yetkisiz kart sayısı artırılarak bağımsız kapı kontrolü yapılabilir.
• Röle çıkışına zamanlama, kapı açık kalma süresi ve alarm koşulları eklenebilir.
• RS485 hattı üzerinden çoklu okuyucu yapısına geçilebilir.

Daha yüksek kullanıcı sayısı ve erişim kontrol mantığı görmek isteyenler için PIC18F4620 ile apartman için şifreli kilit projesi de iyi bir devam örneğidir.

Dikkat edilmesi gereken noktalar

• Bu devre 125kHz sınıfındaki EM4100 tip kart yapısına göre hazırlanmıştır. Farklı protokoller için yazılım ve okuyucu modül değişikliği gerekebilir.
• Şemada R?, C? ve RL? şeklinde işaretlenmiş bazı değerler açık verilmemiştir. Kartı yeniden üretmeden önce bu değerler proje dosyasından veya baskı devre üzerinden doğrulanmalıdır.
• Röleli uygulamalarda besleme hattının temiz olması, buzzer ve röle sürme anlarında PIC reset sorunlarını önlemek açısından önemlidir.
• RS485 hattı kullanılacaksa kablolama yönü, terminasyon ve ortak referans düzeni doğru kurulmalıdır.

Ayrıca PC üzerinde alınan kodları görmek ve cevap göndermek için Delphi 7 ile hazırlanmış küçük bir arayüz de paylaşılmıştır. Bu arayüz, sistemi masaüstünde hızlı biçimde denemek için pratik bir yardımcı olur.

Devre üzerindeki RFID okuyucu modül MikroElektronika modülüdür ve modülün ana çipi EM4095 olarak belirtilmiştir. Bu da projenin yalnızca teorik kalmadığını, gerçek modül kullanımıyla denenmiş bir çalışma olduğunu gösterir.

CCS C rfid reader.c yazılım içeriği

///////////////////////////////////////////////////////////////////////////////
//// Proje:PIC16F88 ile RF-ID okuyucu uygulaması                           ////   
//// Projeyi yapan:Erhan Yılmaz(tekniker_erhan)                            ////
//// E-mail:[email protected]                                      ////
//// Tarih:22-06-2009 Pazartesi                                            ////
//// Version 1.0                                                           ////
//// Not:Proje eğitim amaçlı ve RF-ID uygulamaları ile örnek niteliğinde   ////
//// olup geliştirilmeye müsaittir.                                        ////
///////////////////////////////////////////////////////////////////////////////
#include  <16F88.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT,PUT,CCPB3,NOMCLR
#use delay(clock=4000000)
#include <em4095_read.c>
#include <em4102.c>
#use rs232 (baud=9600, xmit=pin_B5, rcv=pin_B2, parity=N, stop=1)
#define RF_RDY_CLK   PIN_B6         
#define RF_SHD       PIN_B1       
#define RF_MOD       PIN_B4        
#define RF_DEMOD_OUT PIN_B3        
#define k_led PIN_A2
#define y_led PIN_A3
#define buzzer PIN_B7
#define role PIN_A1

unsigned int8 code[5];
unsigned int8 cevap;
void yanlis(void){
        output_high(k_led);
        output_high(buzzer);
        delay_ms(200);
        output_low(k_led);
        output_low(buzzer);
        delay_ms(200);
        output_high(k_led);
        output_high(buzzer);
        delay_ms(200);
        output_low(k_led);
        output_low(buzzer);
        }

void dogru (void){
        output_high(y_led);
        output_high(role);
        output_high(buzzer);
        delay_ms(1000);
        output_low(y_led);
        output_low(role);
        output_low(buzzer);
        }
        
        
void kontrol(int8){
   if(cevap=='E'){dogru();}
   else{yanlis();}}

void main(void) {
int16 i;
   setup_adc_ports(NO_ANALOGS); 
   setup_comparator(NC_NC_NC_NC);
   rf_init(); 

   while(1) {

        if(read_4102(code)){
        disable_interrupts(global); 
        output_high(y_led);
        output_high(buzzer);
        delay_ms(200);
        output_low(y_led);
        output_low(buzzer);
        printf("%X-%X-%X-%X-%X"code[0],code[1],code[2],code[3],code[4]);
        cevap='H';
        for(i=0;i<=5000;i++){
        if (kbhit()){
        cevap=getch();
        break;}
        delay_ms(1);}
        kontrol(cevap);
        enable_interrupts(global);
        }
     }
}

CCS C em4095_read.c yazılım içeriği

/////////////////////////////////////////////////////////////////////////
////                             em4095_read.c                       ////
//// This file contains drivers for a EM4095 RFID basestation.       ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////
////                                                                 ////
////                          Pin Layout                             ////
////   ------------------------------------------------------------  ////
////   |                                                          |  ////
////   | 1: VSS       GND         | 16: DC2                       |  ////
////   |                          |                               |  ////
////   | 2: RDY/CLK   RF_RDY_CLK  | 15: FCAP                      |  ////
////   |                          |                               |  ////
////   | 3: ANT1                  | 14: SHD         RF_SHD        |  ////
////   |                          |                               |  ////
////   | 4: DVDD                  | 13: DEMOD_OUT   RF_DEMOD_OUT  |  ////
////   |                          |                               |  ////
////   | 5: DVDS                  | 12: MOD         RF_MOD        |  ////
////   |                          |                               |  ////
////   | 6: ANT2                  | 11: AGND                      |  ////
////   |                          |                               |  ////
////   | 7: VDD       +5V         | 10: CDEC_IN                   |  ////
////   |                          |                               |  ////
////   | 8: DMOD_IN               |  9: CDEC_OUT                  |  ////
////   ------------------------------------------------------------  ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

#ifndef EM4095
#define EM4095

#ifndef RF_SHD
#define RF_RDY_CLK   PIN_B6         // External interrupt used to read clock
#define RF_SHD       PIN_B1         // High disables the antenna signal
#define RF_MOD       PIN_B4         // High does 100% modulation
#define RF_DEMOD_OUT PIN_B3         // Data read in interrupt service routine
#endif

#define RFBUFFER_SIZE 20
int8 RFbuffer[RFBUFFER_SIZE];
int8 RFbuffer_index = 0;
int8 RFbuffer_bitIndex = 0;
#define END_OF_RFBUFFER (RFbuffer_index == sizeof(RFbuffer))

int8 RF_readMode;
#define RF_MANCHESTER_DATA    0
#define RF_MEASURE_WIDTHS     1
#define RF_FIND_WIDTH         2
#define RF_FIND_PATTERN       3

int1  bitValue              = 1;
int1  storeData             = TRUE;
int1  RE_FE_TOGGLE          = 1;
int1  RF_widthFound         = FALSE;
int1  RF_patternFound       = FALSE;
int8  RF_widthToFind        = 0;
int8* RF_findWidths         = 0;
int8  RF_uncertainty        = 0;
int8  timer0_overflows      = 0;
int8  dataTransferred       = 0;
int16 old_clock             = 0;

void rf_init()
{
   output_low(RF_SHD);
   output_low(RF_MOD);

   setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1);
   setup_ccp1(CCP_CAPTURE_RE);

   setup_timer_0(RTCC_INTERNAL | RTCC_DIV_256 | RTCC_8_BIT);
   enable_interrupts(INT_RTCC);
   enable_interrupts(GLOBAL);
}

void RF_readEdge(int1 edge)
{
   if(edge)
   {
      setup_ccp1(CCP_CAPTURE_RE);
      RE_FE_TOGGLE = 1;
   }
   else
   {
      setup_ccp1(CCP_CAPTURE_FE);
      RE_FE_TOGGLE = 0;
   }
}

#INT_CCP1
void isr_ccp1()
{
   int8  width;

   if(RE_FE_TOGGLE)
   {
      setup_ccp1(CCP_CAPTURE_FE);
      RE_FE_TOGGLE = 0;
   }
   else
   {
      setup_ccp1(CCP_CAPTURE_RE);
      RE_FE_TOGGLE = 1;
   }

   width = CCP_1 - old_clock;
   old_clock = CCP_1;

   switch(RF_readMode)
   {
      case RF_MANCHESTER_DATA:
      {
         if(width > 54)
         {
            bitValue = ~bitValue;
            storeData = TRUE;
         }

         if(storeData)
         {
            shift_right(RFbuffer+RFbuffer_index, 1, bitValue);
            ++dataTransferred;

            if(++RFbuffer_bitIndex == 8 )
            {
               RFbuffer_bitIndex = 0;
               ++RFbuffer_index;
            }
         }

         storeData = ~storeData;
         break;
      }

      case RF_MEASURE_WIDTHS:
      {
         RFbuffer[RFbuffer_index++] = width;
         ++dataTransferred;
         break;
      }

      case RF_FIND_WIDTH:
      {
         if(width > (RF_widthToFind - RF_uncertainty)
         && width < (RF_widthToFind + RF_uncertainty))
         {
            RF_widthFound = TRUE;
         }
         break;
      }

      case RF_FIND_PATTERN:
      {
         if(width > RF_findWidths[RFbuffer_index] - RF_uncertainty
         && width < RF_findWidths[RFbuffer_index] + RF_uncertainty)
         {
            if(++RFbuffer_index == dataTransferred)
            {
               RF_patternFound = TRUE;
            }
         }
         else
         {
            if(RFbuffer_index > 0)
            {
               int8 pos, i, j;
               pos = RFbuffer_index-1;

               while(--RFbuffer_index != 0)
               {
                  if(width > RF_findWidths[RFbuffer_index] - RF_uncertainty
                  && width < RF_findWidths[RFbuffer_index] + RF_uncertainty)
                  {
                     for(i=pos, j=RFbuffer_index-1; j!=255; --i, --j)
                     {
                        if(RF_findWidths[j] != RF_findWidths[i])
                        {
                           break;
                        }
                     }
                     if(j == 255)
                     {
                        break;
                     }
                  }
               }
            }
         }
         break;
      }
   }
}

#INT_RTCC
void isr_rtcc()
{
   ++timer0_overflows;
}

int8 RF_get(int8 numBits, int1 edge)
{
   RF_readEdge(edge);
   RF_readMode = RF_MANCHESTER_DATA;

   storeData         = TRUE;
   bitValue          = 0;
   RFbuffer_index    = 0;
   RFbuffer_bitIndex = 0;
   dataTransferred   = 0;
   timer0_overflows  = 0;
   old_clock         = 0;
   set_timer1(0);

   clear_interrupt(INT_CCP1);
   enable_interrupts(INT_CCP1);
   while(dataTransferred < numBits && timer0_overflows < 15);
   disable_interrupts(INT_CCP1);

   RFbuffer_index = 0;
   RFbuffer_bitIndex = 0;

   return dataTransferred;
}

int1 RF_findWidth(int8 numClocks, int8 uncertainty, int1 edge)
{
   RF_readEdge(edge);

   RF_readMode          = RF_FIND_WIDTH;
   RF_widthToFind       = numClocks;
   RF_widthFound        = FALSE;
   RF_uncertainty       = uncertainty;
   timer0_overflows     = 0;
   old_clock            = 0;
   set_timer1(0);

   clear_interrupt(INT_CCP1);
   enable_interrupts(INT_CCP1);
   while(RF_widthFound == FALSE && timer0_overflows < 50);
   disable_interrupts(INT_CCP1);

   return RF_widthFound;
}

int8 RF_measureWidths(int8 numWidths, int1 edge)
{
   RF_readEdge(edge);

   RF_readMode       = RF_MEASURE_WIDTHS;
   dataTransferred   = 0;
   RFbuffer_index    = 0;
   timer0_overflows  = 0;
   old_clock         = 0;
   set_timer1(0);

   clear_interrupt(INT_CCP1);
   enable_interrupts(INT_CCP1);
   while(dataTransferred < numWidths && timer0_overflows < 50);
   disable_interrupts(INT_CCP1);

   return dataTransferred;
}

int8 RF_findPattern(int8* widths, int8 numWidths, int8 uncertainty, int1 edge)
{
   RF_readEdge(edge);

   RF_readMode       = RF_FIND_PATTERN;
   RF_patternFound   = FALSE;
   RFbuffer_index    = 0;
   RF_findWidths     = widths;
   dataTransferred   = numWidths;
   RF_uncertainty    = uncertainty;
   timer0_overflows  = 0;
   old_clock         = 0;
   set_timer1(0);

   clear_interrupt(INT_CCP1);
   enable_interrupts(INT_CCP1);
   while(RF_patternFound == FALSE && timer0_overflows < 40);
   disable_interrupts(INT_CCP1);

   return RF_patternFound;
}

void RFbuffer_fill(int8 data)
{
   int i;
   for(i=0; i<sizeof(RFbuffer); ++i)
   {
      RFbuffer[i] = data;
   }
}

void RFbuffer_invert()
{
   int i;
   for(i=0; i<sizeof(RFbuffer); ++i)
   {
      RFbuffer[i] = ~RFbuffer[i];
   }
}

int1 RFbuffer_getBit()
{
   int1 bit;

   if(!END_OF_RFBUFFER)
   {
      bit = bit_test(RFbuffer[RFbuffer_index], RFbuffer_bitIndex);

      if(++RFbuffer_bitIndex == 8 )
      {
         ++RFbuffer_index;
         RFbuffer_bitIndex = 0;
      }
   }

   return bit;
}

int8 RFbuffer_getByte()
{
   if(!END_OF_RFBUFFER)
   {
      int8 i;
      int8 data;

      for(i=0; i<8; ++i)
      {
         shift_right(&data, 1, RFbuffer_getBit());
      }

      return data;
   }
}

void RFbuffer_setBit(int1 bit)
{
   if(!END_OF_RFBUFFER)
   {
      if(bit)
      {
         bit_set(RFbuffer[RFbuffer_index], RFbuffer_bitIndex);
      }
      else
      {
         bit_clear(RFbuffer[RFbuffer_index], RFbuffer_bitIndex);
      }

      if(++RFbuffer_bitIndex >= 8 )
      {
         ++RFbuffer_index;
         RFbuffer_bitIndex = 0;
      }
   }
}

void RFbuffer_setByte(int8 data)
{
   if(!END_OF_RFBUFFER)
   {
      int8 i;
      for(i=0; i<8; ++i)
      {
         RFbuffer_setBit(bit_test(data, 7));
         rotate_left(&data, 1);
      }
   }
}

#endif

Projenin kaynak kod, proteus ve program dosyaları;