[syntax=c]
// ***********************************************
// ATMEGA128 użyte piny
// kwarc : 16Mhz
// ***********************************************
// 28 TXD1 = TX
// 27 RXD1 = RX
// 31 PD6/T1 = RDY-CLK w EM4095
// 29 PD4/ICP1 = DMOD w EM4095
// 45 PA6 = przekaźnik
// ***********************************************
#include <iom128v.h>
#include <macros.h>
unsigned char rxd_buff;
unsigned char flag_1ms =0;
unsigned char flag_rxd =0;
unsigned char flag_err =0;
unsigned char flag_adc =0;
unsigned char par_err =0;
unsigned char time_1ms;
unsigned int adc_buff;
char rf_buff[16];
char rf_buff_ptr =0;
char rf_bit_ptr = 0;
char bit_value =1;
char bit_saved =1;
char edge_dir =1;
char stable_width =0;
char bit_trans_num =0;
int old_width =0;
int timer_over =0;
int value;
int width;
// PORTY
// ***********************************************
void port_init(void)
{
DDRA |= (1 << 6); //Przekaźnik
PORTA &= ~(1 << 6); // sprawdzenie stanu PK
DDRD &= ~(1 << 4); //DEMOD w EM4095.
PORTD |= (1 << 4);
DDRD &= ~(1 << 6); //CLK w EM4095.
PORTD |= (1 << 6);
}
// ADC czas konwersji 104uS
// ***********************************************
void adc_init(void)
{
ADCSRA = 0x00;
ADMUX = 0x07;
ACSR = 0x80;
ADCSRA = 0xEF; //start adc w trybie free running mode preskaler:128
}
// ADC
// ***********************************************
#pragma interrupt_handler adc_isr:22
void adc_isr(void)
{
adc_buff =ADCL;
adc_buff |=(int)ADCH << 8;
flag_adc =1;
}
// Włączenie przekaźnika
// ***********************************************
void rel_on(void)
{
PORTA |= (1 << 6);
}
// ***********************************************
// Wyłączenie przekaźnika
// ***********************************************
void rel_off(void)
{
PORTA &= ~(1 << 6);
}
// TIMER0
// ***********************************************
void timer0_init(void)
{
TCCR0 = 0x00; //stop
ASSR = 0x00; // async mode
TCNT0 = 0xbb;
OCR0 = 0x00;
TCCR0 = 0X06;
TIMSK |= 0x01;
}
// TIMER0 1ms
// ***********************************************
#pragma interrupt_handler timer0_ovf_isr:17
void timer0_ovf_isr(void)
{
TCNT0 = 0xbb; // przeładowanie licznika
flag_1ms =1; // flag_1ms =1
timer_over++; // 1ms timer +1
}
//void timer0_init(void)
//{
// TCCR0 = 0x00; //stop
// ASSR = 0x08; //async mode
// TCNT0 = 0x100;
// OCR0 = 0x00;
// TCCR0 = 0x06; //start timer
//}
// delay_ms(100)=100ms
// ***********************************************
void delay_ms(int dlay)
{
unsigned int i;
for (i=0; i <dlay; i++) // 1ms *N =N [ms]
{
while (flag_1ms ==0) // czekam 1ms
{
}
flag_1ms =0; // 1 ms
}
}
// UART
// ***********************************************
// dla F_CPU 16000000
#define BAUD_RATE 57600
//użyjemy uart1 w mega128.
void uart1_init(void)
{
unsigned char baudscaler;
baudscaler = (unsigned char)((F_CPU+(BAUD_RATE*8L))/(BAUD_RATE*16L)-1); .
UCSR1C = (1<<UCSZ10)| (1<<UCSZ11);
UBRR1H = baudscaler >> 8;
UBRR1L = baudscaler;
UCSR1B = (1<<RXEN1)|(1<<TXEN1);
}
// ***********************************************
#pragma interrupt_handler uart1_rx_isr:19
void uart1_rx_isr(void)
{
//UDR
rxd_buff =UDR1;
flag_rxd =1;
}
// ***********************************************
void uart_putchar(unsigned char tx_byte)
{
while(!(UCSR1A & (1 << UDRE1)));
UDR1 = tx_byte;
}
void uart_putstring (char *str)
{
while (*str)
{
uart_putchar(*str);
str++;
}
}
// TIMER1
// timer1 zegar EXT_T1 z RDY-CLK w EM4095
// PD4/ICP wejście DEMOD z EM4095
// ***********************************************
void timer1_init(char edge)
{
TCCR1B = 0x00; // stop timer1
TCNT1H = 0x00;
TCNT1L = 0x00; // start 0000
ICR1H = 0x00;
ICR1L = 0x00;
TCCR1A = 0x00;
TCCR1B = 0x00; // stop timer1,
if (edge ==1) TCCR1B = 0x40;
else TCCR1B = 0x00;
TIMSK |= 0x24;
}
// TIMER1
// ***********************************************
#pragma interrupt_handler timer1_ovf_isr:15
void timer1_ovf_isr(void)
{
TCNT1H = 0x00;
TCNT1L = 0x00;
}
// ***********************************************
void rf_bit_store(char bit_value)
{
char byte;
if(!(rf_buff_ptr ==sizeof(rf_buff)))
{
byte =rf_buff[rf_buff_ptr];
byte =(byte << 1);
if (bit_value) byte |=0x01;
else byte &=0xfe;
rf_buff[rf_buff_ptr] =byte;
if(++rf_bit_ptr == 8)
{
rf_bit_ptr = 0;
++rf_buff_ptr;
}
}
}
// Kasowanie bufora
// ***********************************************
void erase_rf_buff(char num_byte)
{
int i;
rf_buff_ptr =0;
rf_bit_ptr =0;
for(i =0; i <num_byte; ++i)
{
rf_buff[i] = 0x00;
}
}
// PD4/ICP
// 16 bit w rejestrze ICR1
// ***********************************************
#pragma interrupt_handler timer1_capt_isr:12
void timer1_capt_isr(void)
{
value =ICR1L;
value |=(int)ICR1H << 8;
if (edge_dir)
{
TCCR1B &= ~0x40;
TCCR1B |= 0x00;
edge_dir =0;
}
else
{
TCCR1B &= ~0x00;
TCCR1B |= 0x40;
edge_dir =1;
}
width =value -old_width;
old_width =value;
// odebranie kody manchester z karty RFID
if(width > 40)
{
bit_value = ~bit_value;
rf_bit_store(bit_value);
++bit_trans_num;
bit_saved = 0;
}
if(bit_saved)
{
rf_bit_store(bit_value);
++bit_trans_num;
}
bit_saved = ~bit_saved;
}
// PD4/ICP1 sygnał wejściowy z wyjścia DMOD w EM4095
// ***********************************************
void set_rf_edge(char edge)
{
if(edge)
{
timer1_init(1);
edge_dir =1; // RF ON
}
else
{
timer1_init(0);
edge_dir =0; // RF OFF
}
}
// ***********************************************
// Odebranie 64 bitów z RFID
// ***********************************************
void get_bits_num(char num_bits, char edge)
{
set_rf_edge(edge);
//=1 musisz zapisać 1 bit.
bit_saved =1;
// Jak przechwycisz 40 lub więcej bitów to konwertuj
bit_value =0; // =0
rf_buff_ptr =0; // =0
rf_bit_ptr =0; // =0
bit_trans_num =0; // =0
timer_over =0; // =0
old_width =0; // =0
TCCR1B = 0x00; // stop Timer1 dla EXT-T1
TCNT1H = 0x00;
TCNT1L = 0x00; // timer0 =0x0000
TCCR1B = 0x07; // start timer1
TIMSK |= 0x20;
while(bit_trans_num < num_bits && timer_over < 60)
{
//PD4/ICP
}
// 60ms wymagane ...
TIMSK &= ~0x20; // stop timer1
rf_buff_ptr = 0;
rf_bit_ptr = 0;
}
// Pobieranie z bufora
// wyjście przyjmuje TRUE lub FALSE (0x01 or 0x00)
// ***********************************************
char get_buff_bit(void)
{
char bit;
char byte;
if(!(rf_buff_ptr ==sizeof(rf_buff)))
{
byte =rf_buff[rf_buff_ptr];
byte =(byte << rf_bit_ptr); //0~7
byte &=0x80;
if (byte ==0x80) bit =0x01;
else bit =0x00;
if(++rf_bit_ptr == 8)
{
rf_bit_ptr = 0; // =0
rf_buff_ptr++; // +1
}
}
return bit;
}
// *********************************************** Nagłówek 9 bitów
void find_header(void)
{
char i;
char bit;
rf_buff_ptr =0;
rf_bit_ptr =0; // start bufora
flag_err =0; // kasowanie flaki błedów
for(i =0; i <9; i++) // test dla 9 bitów
{
bit =get_buff_bit();
if (bit ==0) flag_err =1;
}
}
// *********************************************** CRC
void checksum(void)
{
char n; // nib dla licznika
char b; // bit licznika
char bit; // pobierz bit
char par;
par_err =0; // kasowanie błędów parzystości
for (n=0; n < 10; n++) // 10
{
par =0; // =0 dla kalkulacji
for(b =0; b < 4; b++) // dla 4 bitów.
{
bit =get_buff_bit(); // pobranie bitów dla 0x00 lub 0x01.
if (bit) par ^=0x01; // kalkulacja parzystości dla 4 bitów.
}
bit =get_buff_bit(); // 5bit parzystości
if (bit !=par) par_err =1; // Nie znaleziono
}
}
// 10 cyferek ASCI
// ***********************************************
void tx_buff_hex(void)
{
char bit;
char txd;
char nib;
char b;
rf_buff_ptr =1; // pomijamy 9 bitów nagłówka
rf_bit_ptr =1;
uart_putchar(0x0a); // start textu =LF
for (nib =0; nib <10; nib++)
{
for (b =0; b <4; b++) // dla 4 bitów
{
txd = (txd <<1); // przesuniecie w lewo
bit =get_buff_bit(); // pobranie bita z rf_buff
if (bit) txd |=0x01; // zapis bita do lsb
else txd &= 0xfe;
}
txd &= 0x0f; // lecimy w kulki .... 4bity dla bajtu
if (txd < 0x0a) txd +=0x30;
else txd +=0x37; // ASCII HEX
uart_putchar(txd); // ASCII na UART
bit =get_buff_bit();
}
uart_putchar(0x0d); // koniec textu =CR
}
// ***********************************************
void main(void)
{
CLI(); //wyłączenie przerwań
MCUCR = 0x00; //ustawienie rejestru kontrolnego
EICRA = 0x00;
port_init(); // inicjacja portów
adc_init(); // 10 bit adc #7 (free running)
timer1_init(0); // inicjacja timer1 od EXT-T1 (EM4095-CLK)
timer0_init(); // inicjacja timera dla delajów
uart1_init(); // inicjacja UART-a
SEI(); // włączenie przerwań
uart_putchar(0x0a); // start
uart_putstring("Card Reader V1.a");
uart_putchar(0x0d); // koniec
uart_putstring("\r\n>");
while(1)
{
// wyszukiwanie manchester-a
// wyjście jest liczbą odebranych bitów =bit_trans_num
erase_rf_buff(16); // hmm.. nie no kasujemy 16 bitów
get_bits_num(64, 0); // odebranie 64 bitów
find_header(); // sprawdzanie nagłówka i 9 bit =1
checksum(); // CRC
// if ((flag_err != 0) && (par_err != 0))
// {
// uart_putchar(0x0a); // start
// uart_putstring("Card ERROR:");
// uart_putchar(0x0d); // Koniec
// tx_buff_hex(); // 10 hexów na uart
// }
if (flag_err ==0)
{
if (par_err ==0)
{
uart_putchar(0x0a); // start w stringach
uart_putstring("Card ID:");
uart_putchar(0x0d); // koniec w stringach
tx_buff_hex();
uart_putstring("\r\n>");
rel_on(); // Włączenie PK.
delay_ms(20); //100ms.
rel_off(); // Wyłczenie PK.
}
}
delay_ms(5);
}
}
[/syntax]
sorki ale tylko m128 miałem akurat pod ręką
Statystyki: Napisane przez SunRiver — 26 wrz 2012, o 21:34
]]>