====== RFID moodulid ======
<note important>Translation needed</note>
RFID on tehnoloogia andmevahetuseks raadiolainete kaudu lugeja ja elektroonilise identiteedi vahel, mis on paigaldatud mõne objekti külge identifitseerimise ja jälgimise eesmärgil. RFID võimaldab iga objektiga siduda unikaalse ID-numbri. Passiivsed identiteedid, millel pole patareid, on võimalik lugeda möödumisel küllalt lähedalt lugejast.

===== Mifare SL031 RFID moodul =====
Mifare RFID moodul on kõrgsageduslik RFID lugeja, mis töötab sagedusel 13,56 MHz.
Samal sagedusel töötvad ka mitmed Eesti koolides ja ettevõtetes kasutatavad id-kaardid ning RFID-nööbid.
Moodul SL031 ühendatakse kontrolleriplaadiga järgmiselt:
VCC – toide + 3.3 V (sideplaadi Xbee liidesest või kontrolleriplaadi ühendusribast), seda tuleb kindlasti jälgida, et mooduli toiteks mitte suuremat toitepinget kasutada! Siiski mooduli andmeside viigud taluvad ka + 5 V pinget.
IN – energia säästmiseks saab RFID-mooduli saata uinunud olekusse. Selleks saadetakse talle käsk 0x50. RFID-moodul ärkab üles langeva frondi peale IN sisendis.
TXD – ühendada kontrolleri RXD viiguga (nt. PE0 USART0 kasutamisel suhtlemiseks)
RXD – ühendada kontrolleri TXD viiguga (nt. PE1)
OUT – see väljund näitab, et mõni ID on detekteeritav (kaart mooduli ligidal, väljund all) või mitte (kaarti pole, väljund üleval)
GND – maaühendus

USART0 kasutamisel RFID mooduliga suhtlemiseks ei tohi RFID mooduli TXD/RXD viigud ISP programmeerimise ajal olla sideplaadiga ühendatud, sest siis tekib konflikt ja programmeerimine ei õnnestu.

USART seaded SL031 puhul on vaikimise 115200-8-N-1-N. Arvutiga ühendamise puhul, kui RFID-mooduliga suhtlemiseks kasutatakse USART0 liidest, siis jumperid parempoolsel piikribapaaril tuleb tõsta Xbee pealt RS232_2 peale ja arvuti COM port ühendada sideplaadi RS232_2 pistikusse.

Andmevahetuse formaat kontrolleri ja RFID-mooduli vahel koosneb mitmest baidist, mis on kindlas järjekorras. Esimene bait on alati sama (kontrollerist saatmise puhul 0xBA). Teine bait näitab, mitu baiti veel pärast seda saadetakse ja seda on näiteks võimalik kasutada andmevahetuse jälgimiseks, et teada, millal andmed on saadetud. Viimane bait on kontrollsumma, mille järgi saab veenduda vastuvõetud andmete veatus ülekandes. Moodulile saatmiseks on erinevaid käske, mis kirjutavad/loevad andmeid mälus, panevad selle näiteks toite säästmiseks magama jne.

Näiteprogramm saadab iga sekundi järel käsu RFID moodulile, et teada, kas sellel on mõni ID kaart avastataval ligidusel. Kui on, siis kuvab kaardi unikaalset ID-d tablool. Andmevahetuse iga bait on 16-süsteemis arv/kood, mis tuleb ekraanil kuvamiseks teisendada ASCII tähemärkideks.

===== Mifare SL031 näitekood =====

<code c>
#include <homelab/usart.h>
#include <homelab/delay.h>
#include <homelab/pin.h>
#include <homelab/module/lcd_gfx.h>

usart port = USART(1);	//Mifare RFID ühenduseks

// Käsk moodulile - kaardi valimine
// preamble, len, command, data, checksum
char SL031CMD_SelectCard[] = {0xBA,0x02,0x01,0xB9};

void hex_to_ascii(char *mass, char byte);

int main (void)
{
    char resp[14];
    char str[4];
    int a = 0;
    int bnr = 4;
	
    // USART1 setup
    usart_init_async(port,
	             USART_DATABITS_8,
                     USART_STOPBITS_ONE,
                     USART_PARITY_NONE,
                     USART_BAUDRATE_ASYNC(115200));

    // LCD ekraani algseadistamine
    lcd_gfx_init();

    // Taustavalgustuse tööle lülitamine
    lcd_gfx_backlight(true);

    // Ekraanile teksti kirjutamine
    lcd_gfx_goto_char_xy(3, 0);
    lcd_gfx_write_string("RFID Demo");
    lcd_gfx_goto_char_xy(0, 2);
    lcd_gfx_write_string("ID: ");

    while (1)	//infinite loop
    {
        // Saada käsk RFID moodulile
        usart_send_string(port, SL031CMD_SelectCard);
        
        // kuni vastuse andmebaidid kohal
        while (a < bnr)
	{
		// loeb USART-ist andmeid ja salvestab
		if (usart_try_read_char(port, &resp[a]))
		{
		     // järgmine bait
                     a++;
                     // II bait näitab, mitu baiti veel tulemas on
                     if (a == 2) bnr = resp[1] + 2;
		}
	}

	// kui ID puudub - "no tag" vastus
	if (resp[3] == 0x01)
	{
		// kirjuta seda
		lcd_gfx_goto_char_xy(4, 2);
	    	lcd_gfx_write_string("puudub   ");
	}
	// ID on olemas ja loetav
	else
	{
		// vaata ainult ID baite
		for (a=4; a<(bnr-2); a++)
		{
			// teisendab loetud andmed stringiks
			hex_to_ascii(str, resp[a]);
			// kirjuta ekraanile
			lcd_gfx_goto_char_xy((a-2)*2, 2);
		    	lcd_gfx_write_string(str);
		}
	}
	// loendurid algusesse
	a = 0;
	bnr = 4;
	// viide uuendamiseks
	hw_delay_ms(1000);
    }
}

// Teisendab hex kujul arvu ASCII märkideks ja salvestab stringi
void hex_to_ascii(char *mass, char byte)
{
	unsigned int high = 0;

	// leiab esimese numbrikoha hex arvust
	while (byte > 0x0F)
	{
		high++;
		byte -= 0x10;
	}
	// esimene numbrikoht, hex teisendada ASCII-ks
	mass[0] = high + 0x30;
	// kui tähemärk
	if (mass[0] >= 0x3A) mass[0] += 0x07;
	// teine numbrikoht, hex teisendada ASCII-ks
	mass[1] = byte + 0x30;
	if (mass[1] >= 0x3A) mass[1] += 0x07;
	// stringi terminaator
	mass[2] = 0x00;
}
</code>

===== Parallax RFID moodul =====

Parallaxi RFID moodul on madalsageduslik RFID lugeja, mis töötab sagedusel ~170 kHz.

{{:examples:sensor:rfid.jpg|}}


===== Parallax RFID näitekood =====

Järgnev kood kasutab RFID lugejat ja LCD ekraani.

<code c>
// RFID reader with Interstudy ATmegal28 board
// Reader pins : Enable - PD3, Serout - PD2 (RXD1)
// Reads and displays ID

// Includes 
#include <avr/io.h> 
#include <util\delay.h> 
#include "lcd.h"
#include "pin.h"

// Configuration
#define RFID_BAUDRATE     2400
#define RFID_BAUD_VALUE   (((F_CPU / (RFID_BAUDRATE * 16UL))) - 1)
#define RFID_ENABLE       PORTPIN(D, 3)
#define RFID_RX           PORTPIN(D, 2)
#define LED_GREEN         PORTPIN(C, 3)
#define LED_DEBUG         PORTPIN(B, 7)

//
// Display initialization
//
void display_init(void)
{
	lcd_init(LCD_DISP_ON);
	lcd_clrscr();
	lcd_puts("  RFID reader\n waiting for ID");
}

//
// Write ID on display
//
void display_write_id(char *id)
{
	lcd_gotoxy(0, 0);
	lcd_puts("ID: "); 
	lcd_puts(id);
}

//
// UART configuring
//
void uart_setup()
{
	// Setup serial interface
	SET_BIT(UCSR1B, RXEN);   // Activate RX only
	SET_BIT(UCSR1C, UCSZ0);  // 8 data bits, 1 stop bit, no parity
	SET_BIT(UCSR1C, UCSZ1);

	// Set baud rate
	UBRR1L = (RFID_BAUD_VALUE & 0xFF);
	UBRR1H = (RFID_BAUD_VALUE >> 8);
}

//
// Wait for UART incoming data
//
void uart_wait_rx()
{
	while (!IS_BIT_SET(UCSR1A, RXC)) { }
}

//
// Read UART data
//
inline unsigned char uart_read()
{
	return UDR1;
}

//
// RFID interface initialization
//
void rfid_init(void)
{
	// Setup UART
	uart_setup();

	// Setup enable and RX pin
	pin_setup_output(RFID_ENABLE); 		
	pin_setup_input(RFID_RX);
}

//
// RFID ID reading
//
void rfid_read_id(char *id)
{
	enum States { BEGIN, DATA, END } state = BEGIN;
	unsigned char data;
	unsigned char digits = 0;

	// Enable RFID with low signal
	pin_clear(RFID_ENABLE);

	// Cycle until tag ID received
	while (1)
	{	 
 		// Wait for data
		uart_wait_rx();		
		data = uart_read();		

		// Toggle debug indicator
		pin_toggle(LED_DEBUG);

		// What's present state and what's next ? 
		switch (state)
		{
			// Begin state - we expect start byte (0x0A)
			case BEGIN:
				// Got the start ?
				if (data == 0x0A)
				{
					state = DATA;
					
					// Disable RFID
					pin_set(RFID_ENABLE);
				}
				break;

			// Data state - we expect 10 bytes of ID
			case DATA:
				// Fill ID string
				id[digits++] = data;				

				// All digits arrived ?
				if (digits == 10) state = END;
				break; 

			// End state - we expect end byte (0x0D)
			case END:
				// Got the end ?
				if (data == 0x0D)
				{
					// Terminate the string
					id[digits] = '\0'; 

					// All done - return
					return;					
				}
				// Any other case - restart
				else
				{
					state = BEGIN;

					// Enable RFID with low signal
					pin_clear(RFID_ENABLE);
				}
				break; 			
		}
	}
}

//
// Main function  
//
int main(void)
{
	char id[11];

	// Initialization
	display_init();
	rfid_init();

	// Setup indicator pins
	pin_setup_output(LED_GREEN); 
	pin_setup_output(LED_DEBUG);
		
 	// Endless loop
	while (1)
	{		
		// Turn off green LED
		pin_set(LED_GREEN);

		// Read RFID tag ID
		rfid_read_id(id);

		// Light green LED
		pin_clear(LED_GREEN);

		// Display ID	
		display_write_id(id);		
	}
} 
</code>

  * {{examples:digi:rfid.zip|AVR Studio projekt}}