ATNEL tech-forum

Re: nfc na pn532 i atmega. transfer z arduino.

2017-03-19T13:28:58+01:00

Jak ktoś jeszcze potrzebuje, to lekko poprawiona biblioteka dla układu NFC PN532, komunikacja SPI, testowane na ATmega328P pod MkCLIPSE'm:

[syntax=c]/**
File Name: nfc_pn532.c

C Library for the PN532 written for the A Mega644.
Adapted from pn532.cpp written by Adafruit Industries

Author: Renato Amez

Poprawki biblioteki dla ATmega328P i testy pod MkCLIPSE: ElektroTME

*/

#include
#include
#include
#include
#include
#include "nfc_pn532.h"

char pn532ack[] = {0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00};
char pn532response_firmwarevers[] = {0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03};

#define PN532_PACKBUFFSIZ 64
char pn532_packetbuffer[PN532_PACKBUFFSIZ];

// SET THE ACTUAL VALUE OF THE PINS BEFORE USING
#define PN532_CLK PINB5 // SPI clock pin
#define PN532_MISO PINB4 // SPI MISO pin
#define PN532_MOSI PINB3 // SPI MOSI pin
#define PN532_CS PINB2 // SPI chip select pin (CS/SSEL)

// CURRENT SETUP AT PORT B. SUBJECT TO CHANGE AT FINAL IMPLEMENTATION
#define DDRX DDRB
#define PORTX PORTB
#define PINX PINB

void setupPins( void ) {
// Change desired port DDRx and set MISO to INPUT, others to OUTPUT
DDRX = ( 1 << PN532_MOSI ) | ( 1 << PN532_CLK ) | ( 1 << PN532_CS );

SPCR = ( 1 << MSTR ) | ( 1 << SPR0 ) | ( 1 << SPE ) | ( 1 << DORD );
}

void begin( void ) {
PORTX &= ~( 1 << PN532_CS );

_delay_ms( 1000 );

// send dummy command to get it synched up
pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;
//uint8_t check= sendCommandCheckAck(pn532_packetbuffer, 1, 1000);
}

uint32_t getFirmwareVersion( void ) {
uint32_t response;

pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 1, 1000 ) ) return 0;

// read data packet
readspidata( pn532_packetbuffer, 12 );

// check some basic stuff
if ( 0 != strncmp(( char* )pn532_packetbuffer,
( char* )pn532response_firmwarevers, 6 ) )
return 0;

response = pn532_packetbuffer[6];
response <<= 8;
response |= pn532_packetbuffer[7];
response <<= 8;
response |= pn532_packetbuffer[8];
response <<= 8;
response |= pn532_packetbuffer[9];

return response;

}

// default timeout of one second
uint8_t sendCommandCheckAck( char *cmd, uint8_t cmdlen, uint16_t timeout ) {
uint16_t timer = 0;

// write the command
spiwritecommand( cmd, cmdlen );

// wait for the chip to say it's ready
while ( readspistatus() != PN532_SPI_READY ) {
if ( timeout != 0 ) {
timer += 10;
if ( timer > timeout ) {
return 0;
}
}
_delay_ms( 10 );
}

// read acknowledgement
if ( 0 == spi_readack() ) {
return 0;
}

timer = 0;
// wait for the chip to say it's ready
while ( readspistatus() != PN532_SPI_READY ) {
if ( timeout != 0 ) {
timer += 10;
if ( timer > timeout ) {
return 0;
}
}
_delay_ms( 10 );
}

return 1;
}

uint8_t SAMConfig( void ) {
pn532_packetbuffer[0] = PN532_SAMCONFIGURATION;
pn532_packetbuffer[1] = 0x01; // normal mode
pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
pn532_packetbuffer[3] = 0x01; // use IRQ pin!

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 4, 1000 ) ) return 0;

// read data packet
readspidata( pn532_packetbuffer, 8 );

return ( pn532_packetbuffer[5] == 0x15 ? 1 : 0 );
}

uint8_t authenticateBlock( uint8_t cardnumber, uint32_t cid, uint8_t blockaddress,
uint8_t authtype, uint8_t* keys ) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;

if ( authtype == KEY_A ) {
pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYA;
} else {
pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYB;
}
pn532_packetbuffer[3] = blockaddress; // Address can be 0-63 for MIFARE 1K card

pn532_packetbuffer[4] = keys[0];
pn532_packetbuffer[5] = keys[1];
pn532_packetbuffer[6] = keys[2];
pn532_packetbuffer[7] = keys[3];
pn532_packetbuffer[8] = keys[4];
pn532_packetbuffer[9] = keys[5];

pn532_packetbuffer[10] = (( cid >> 24 ) & 0xFF );
pn532_packetbuffer[11] = (( cid >> 16 ) & 0xFF );
pn532_packetbuffer[12] = (( cid >> 8 ) & 0xFF );
pn532_packetbuffer[13] = (( cid >> 0 ) & 0xFF );

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 14, 1000 ) ) return 0;

// read data packet
readspidata( pn532_packetbuffer, 2 + 6 );

if (( pn532_packetbuffer[6] = 0x41 ) && ( pn532_packetbuffer[7] == 0x00 ) ) {
return 1;
} else {
return 0;
}
}

uint8_t readMemoryBlock( uint8_t cardnumber, uint8_t blockaddress, uint8_t* block ) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;
pn532_packetbuffer[2] = PN532_MIFARE_READ;
pn532_packetbuffer[3] = blockaddress;

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 4, 1000 ) ) return 0;

// read data packet
readspidata( pn532_packetbuffer, 18 + 6 );
for ( uint8_t i = 8; i < 18 + 6; i++ ) {
block[i-8] = pn532_packetbuffer[i];
}

if (( pn532_packetbuffer[6] == 0x41 ) && ( pn532_packetbuffer[7] == 0x00 ) ) {
return 1; // read successful
} else {
return 0;
}
}

// Do not write to Sector Trailer Block unless you know what you are doing
uint8_t writeMemoryBlock( uint8_t cardnumber, uint8_t blockaddress, uint8_t* block ) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;
pn532_packetbuffer[2] = PN532_MIFARE_WRITE;
pn532_packetbuffer[3] = blockaddress;

for ( uint8_t byte = 0; byte < 16; byte++ ) {
pn532_packetbuffer[4+byte] = block[byte];
}

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 4 + 16, 1000 ) ) return 0;

// read data packet
readspidata( pn532_packetbuffer, 2 + 6 );

if (( pn532_packetbuffer[6] == 0x41 ) && ( pn532_packetbuffer[7] == 0x00 ) ) {
return 1; // write successful
} else {
return 0;
}
}

uint32_t readPassiveTargetID( uint8_t cardbaudrate ) {
uint32_t cid;

pn532_packetbuffer[0] = PN532_INLISTPASSIVETARGET;
pn532_packetbuffer[1] = 1; // max 1 card at once
pn532_packetbuffer[2] = cardbaudrate;

if ( 0 == sendCommandCheckAck( pn532_packetbuffer, 3, 1000 ) ) return 0x00; // no cards read

// read data packet
readspidata( pn532_packetbuffer, 20 );

if ( pn532_packetbuffer[7] != 1 ) return 0;

uint16_t sens_res = pn532_packetbuffer[9];
sens_res <<= 8;
sens_res |= pn532_packetbuffer[10];

cid = 0;
for ( uint8_t i = 0; i < pn532_packetbuffer[12]; i++ ) {
cid <<= 8;
cid |= pn532_packetbuffer[13+i];
}

return cid;
}

// high level SPI
uint8_t spi_readack( void ) {
char ackbuff[6];

readspidata( ackbuff, 6 );

return ( 0 == strncmp(( char* ) ackbuff, ( char* ) pn532ack, 6 ) ) ? 1 : 0;
}

// mid level SPI
uint8_t readspistatus( void ) {
PORTX &= ~( 1 << PN532_CS ); // write LOW to CS pin
_delay_us( 2000 );

spiwrite( PN532_SPI_STATREAD );
// read byte
uint8_t x = spiread();

PORTX |= ( 1 << PN532_CS ); // write HIGH to CS pin
return x;
}

void readspidata( char* buff, uint8_t n ) {
PORTX &= ~( 1 << PN532_CS ); // write LOW to CS pin
_delay_us( 2000 );
spiwrite( PN532_SPI_DATAREAD );

for ( uint8_t i = 0; i < n; i++ ) {
_delay_us( 1000 );
buff[i] = spiread();
}

PORTX |= ( 1 << PN532_CS ); // write HIGH to CS pin
}

void spiwritecommand( char* cmd, uint8_t cmdlen ) {
uint8_t checksum;

cmdlen++;

PORTX &= ~( 1 << PN532_CS ); // write LOW to CS pin
_delay_us( 2000 );
spiwrite( PN532_SPI_DATAWRITE );

checksum = PN532_PREAMBLE + PN532_PREAMBLE + PN532_STARTCODE2;
spiwrite( PN532_PREAMBLE );
spiwrite( PN532_PREAMBLE );
spiwrite( PN532_STARTCODE2 );

spiwrite( cmdlen );
uint8_t cmdlen_1 = ~cmdlen + 1;
spiwrite( cmdlen_1 );

spiwrite( PN532_HOSTTOPN532 );
checksum += PN532_HOSTTOPN532;

for ( uint8_t i = 0; i < cmdlen - 1; i++ ) {
spiwrite( cmd[i] );
checksum += cmd[i];
}

uint8_t checksum_1 = ~checksum;
spiwrite( checksum_1 );
spiwrite( PN532_POSTAMBLE );
PORTX |= ( 1 << PN532_CS ); // write HIGH to CS pin
}

// low level SPI
void spiwrite( uint8_t c ) {
SPDR = c;
//wait until SPIF is set (SPI done)
while ( !( SPSR & ( 1 << SPIF ) ) ) ;
//uint8_t junk = SPDR;
}

uint8_t spiread( void ) {
SPDR = 0;
//wait until SPIF is set (SPI done)
while ( !( SPSR & ( 1 << SPIF ) ) ) ;

return SPDR;
}[/syntax]

[syntax=c]/**
File name: nfc_pn532.h

Header file for pn532 library written for A Mega644.
Adapted from pn532.h written by Adafruit Industries

Author: Renato Amez

Poprawki biblioteki dla ATmega328P i testy pod MkCLIPSE: ElektroTME

*/

#define PN532_PREAMBLE 0x00
#define PN532_STARTCODE1 0x00
#define PN532_STARTCODE2 0xFF
#define PN532_POSTAMBLE 0x00

#define PN532_HOSTTOPN532 0xD4

#define PN532_FIRMWAREVERSION 0x02
#define PN532_GETGENERALSTATUS 0x04
#define PN532_SAMCONFIGURATION 0x14
#define PN532_INLISTPASSIVETARGET 0x4A
#define PN532_INDATAEXCHANGE 0x40
#define PN532_MIFARE_READ 0x30
#define PN532_MIFARE_WRITE 0xA0

#define PN532_AUTH_WITH_KEYA 0x60
#define PN532_AUTH_WITH_KEYB 0x61

#define PN532_WAKEUP 0x55

#define PN532_SPI_STATREAD 0x02
#define PN532_SPI_DATAWRITE 0x01
#define PN532_SPI_DATAREAD 0x03
#define PN532_SPI_READY 0x01

#define PN532_MIFARE_ISO14443A 0x0

#define KEY_A 1
#define KEY_B 2

void setupPins( void );

void begin( void );

uint8_t SAMConfig( void );
uint32_t getFirmwareVersion( void );
uint32_t readPassiveTargetID( uint8_t cardbaudrate );
uint8_t authenticateBlock( uint8_t cardnumber /* 1 or 2 */,
uint32_t cid /* Card NUID */,
uint8_t blockaddress /* 0 to 63 */,
uint8_t authtype /* Either KEY_A or KEY_B */,
uint8_t* keys );

uint8_t readMemoryBlock( uint8_t cardnumber /* 1 or 2 */,
uint8_t blockaddress /* 0 to 63 */,
uint8_t* block );
uint8_t writeMemoryBlock( uint8_t cardnumber /* 1 or 2 */,
uint8_t blockaddress /* 0 to 63 */,
uint8_t* block );
uint8_t sendCommandCheckAck( char *cmd, uint8_t cmdlen, uint16_t timeout );

uint8_t spi_readack( void );
uint8_t readspistatus( void );
void readspidata( char* buff, uint8_t n );
void spiwritecommand( char* cmd, uint8_t cmdlen );
void spiwrite( uint8_t c );
uint8_t spiread( void );[/syntax]

Statystyki: Napisane przez ElektroTME — 19 mar 2017, o 13:28

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-26T06:14:51+01:00

Zakupilem shielda od seedstudio na NFC.

Otaki o:
http://www.seeedstudio.com/wiki/NFC_Shield_V2.0

wg. specu jest kompatybilny z adafruit i ma ponadto mozliwosc komunikacji P2P.

Masz moze jakis przykladowy,podstawowy kod uzywajacy twoich bibliotek?

Chodzi mi o inicjalizacje i o to jak podac warunek odnosnie otrzymanego tagu.

Z gory dziekowac.

Statystyki: Napisane przez corey — 26 sie 2014, o 06:14

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-17T18:37:21+01:00

no cóż ja używam od lady Ady .. na spi .. ale na uarcie masz prościej

Statystyki: Napisane przez SunRiver — 17 sie 2014, o 18:37

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-17T16:55:05+01:00

SunRiver napisał(a):

jak uporządkuję stronę to chętnie opiszę całość
puki co .. musisz poczekać

chodze od okna do okna,gryze paznokcie i czekam na Ciebie jak na zbawienie

czwarty dzien z tym siedze i nic sie nie urodzilo.

modul z dfrobot ma wyprowadzone zasilanie, mase i tx, rx. takze spi raczej nie pojdzie.

Statystyki: Napisane przez corey — 17 sie 2014, o 16:55

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-17T15:45:09+01:00

jak uporządkuję stronę to chętnie opiszę całość
puki co .. musisz poczekać

Statystyki: Napisane przez SunRiver — 17 sie 2014, o 15:45

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-17T14:54:46+01:00

dzieki wielkie.

bardzo bogata ta biblioteka i z tego co widze bez uarta tylko spi.

Masz moze jakis kawalek kodu z glownego programu jak sie inicjalizuje polaczenie za pomoca tych bibliotek?

Statystyki: Napisane przez corey — 17 sie 2014, o 14:54

Re: nfc na pn532 i atmega. transfer z arduino.

2014-08-16T09:08:00+01:00

Dlaczego można przecież tak :

plik np: nfc_pn532.c

[syntax=c]// Na podstawie biblioteki arduino
// by AdaFruit -- pn532.cpp
// Konwersja bezpośrednia -- testowane na ATmega644

// -- dla forum Atnel
// -- do użytku prywatnego :P

#include
#include
#include
#include
#include
#include "pn532_spi.h"

char pn532ack[] = {0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00};
char pn532response_firmwarevers[] = {0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03};

#define PN532_PACKBUFFSIZ64
char pn532_packetbuffer[PN532_PACKBUFFSIZ];

// Ustawienie Pinów SPI
#define PN532_CLKPINB7 // SPI CLK
#define PN532_MISOPINB6 // SPI MISO
#define PN532_MOSIPINB5 // SPI MOSI
#define PN532_CSPINB4 // SPI (CS/SSEL)

// Konfiguracja portu A --
#define DDRXDDRB
#define PORTXPORTB
#define PINXPINB

void setupPins(void) {
// Ustawiamy piny MISO jako INPUT, a inne jako wyjścia
DDRX = (1 << PN532_MOSI) | (1 << PN532_CLK) | (1 << PN532_CS);

SPCR = (1 << MSTR) | (1 << SPR0) | (1 << SPE) | (1 << DORD);
}

void begin(void) {
PORTX &= ~(1 << PN532_CS);

_delay_ms(1000);

pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;
uint8_t check = sendCommandCheckAck(pn532_packetbuffer, 1, 1000);
}

uint32_t getFirmwareVersion(void) {
uint32_t response;

pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;

if (0 == sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) return 0;

// Odcztt pakietów
readspidata(pn532_packetbuffer, 12);

// check some basic stuff
if (0 != strncmp((char*)pn532_packetbuffer,
(char*)pn532response_firmwarevers, 6))
return 0;

response = pn532_packetbuffer[6];
response << 8;
response |= pn532_packetbuffer[7];
response <<= 8;
response |= pn532_packetbuffer[8];
response <<= 8;
response |= pn532_packetbuffer[9];

return response;

}

// Domyślny czas 1s.
uint8_t sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, uint16_t timeout) {
uint16_t timer = 0;

// Zapis komendy
spiwritecommand(cmd, cmdlen);

// Oczekiwanie na odpowiedź z układu ..
while(readspistatus() != PN532_SPI_READY) {
if (timeout != 0) {
timer += 10;
if (timer > timeout) {
return 0;
}
}
_delay_ms(10);
}

// odczyt potwierdzenia
if (0 == spi_readack()) {
return 0;
}

timer = 0;
// Oczekiwanie na ready z układu
while(readspistatus() != PN532_SPI_READY) {
if (timeout != 0) {
timer += 10;
if (timer > timeout) {
return 0;
}
}
_delay_ms(10);
}

return 1;
}

uint8_t SAMConfig(void) {
pn532_packetbuffer[0] = PN532_SAMCONFIGURATION;
pn532_packetbuffer[1] = 0x01; // tryb normalny
pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
pn532_packetbuffer[3] = 0x01; // użycie przerwania

if (0 == sendCommandCheckAck(pn532_packetbuffer, 4, 1000)) return 0;

// odczyt pakietów
readspidata(pn532_packetbuffer, 8);

return (pn532_packetbuffer[5] == 0x15 ? 1 : 0);
}

uint8_t authenticateBlock(uint8_t cardnumber, uint32_t cid, uint8_t blockaddress,
uint8_t authtype, uint8_t* keys) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;

if (authtype == KEY_A) {
pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYA;
} else {
pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYB;
}
pn532_packetbuffer[3] = blockaddress; // Adresw zakresie 0-63 dla standardu MIFARE i kart o pojemności 1K

pn532_packetbuffer[4] = keys[0];
pn532_packetbuffer[5] = keys[1];
pn532_packetbuffer[6] = keys[2];
pn532_packetbuffer[7] = keys[3];
pn532_packetbuffer[8] = keys[4];
pn532_packetbuffer[9] = keys[5];

pn532_packetbuffer[10] = ((cid >> 24) & 0xFF);
pn532_packetbuffer[11] = ((cid >> 16) & 0xFF);
pn532_packetbuffer[12] = ((cid >> 8) & 0xFF);
pn532_packetbuffer[13] = ((cid >> 0) & 0xFF);

if (0 == sendCommandCheckAck(pn532_packetbuffer, 14, 1000)) return 0;

// odczyt danych
readspidata(pn532_packetbuffer, 2+6);

if ((pn532_packetbuffer[6] = 0x41) && (pn532_packetbuffer[7] == 0x00)) {
return 1;
} else {
return 0;
}
}

uint8_t readMemoryBlock(uint8_t cardnumber, uint8_t blockaddress, uint8_t* block) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;
pn532_packetbuffer[2] = PN532_MIFARE_READ;
pn532_packetbuffer[3] = blockaddress;

if (0 == sendCommandCheckAck(pn532_packetbuffer, 4, 1000)) return 0;

//odczyta danych
readspidata(pn532_packetbuffer, 18+6);
for (uint8_t i = 8; i < 18+6; i++) {
block[i-8] = pn532_packetbuffer[i];
}

if ((pn532_packetbuffer[6] == 0x41) && (pn532_packetbuffer[7] == 0x00)) {
return 1; // odczyt udany ....
} else {
return 0;
}
}

// Lepiej nie wykonuj zapisu do bloku Trailera chyba ze naprawdę wiesz co robisz.
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
uint8_t writeMemoryBlock(uint8_t cardnumber, uint8_t blockaddress, uint8_t* block) {
pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
pn532_packetbuffer[1] = cardnumber;
pn532_packetbuffer[2] = PN532_MIFARE_WRITE;
pn532_packetbuffer[3] = blockaddress;

for (uint8_t byte = 0; byte < 16; byte++) {
pn532_packetbuffer[4+byte] = block[byte];
}

if (0 == sendCommandCheckAck(pn532_packetbuffer, 4+16, 1000)) return 0;

// odczyt pakietów
readspidata(pn532_packetbuffer, 2+6);

if ((pn532_packetbuffer[6] == 0x41) && (pn532_packetbuffer[7] == 0x00)) {
return 1; // Zapis udany....
} else {
return 0;
}
}

uint32_t readPassiveTargetID(uint8_t cardbaudrate) {
uint32_t cid;

pn532_packetbuffer[0] = PN532_INLISTPASSIVETARGET;
pn532_packetbuffer[1] = 1; // max 1 karta na raz
pn532_packetbuffer[2] = cardbaudrate;

if (0 == sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) return 0x00; // karta nie odczytana

// odczyt danych
readspidata(pn532_packetbuffer, 20);

if (pn532_packetbuffer[7] != 1) return 0;

uint16_t sens_res = pn532_packetbuffer[9];
sens_res <<= 8;
sens_res |= pn532_packetbuffer[10];

cid = 0;
for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) {
cid <<= 8;
cid |= pn532_packetbuffer[13+i];
}

return cid;
}

// SPI ------------------ SPI -- HI LEVEL
uint8_t spi_readack(void) {
uint8_t ackbuff[6];

readspidata(ackbuff, 6);

return (0 == strncmp((char*) ackbuff, (char*) pn532ack, 6)) ? 1 : 0;
}

// SPI ----------------- SPI -- MID LEVEL
uint8_t readspistatus(void) {
PORTX &= ~(1 << PN532_CS); // LOW na CS
_delay_us(2000);

spiwrite(PN532_SPI_STATREAD);
// odczyt
uint8_t x = spiread();

PORTX |= (1 << PN532_CS); // HIGH na CS
return x;
}

void readspidata(uint8_t* buff, uint8_t n) {
PORTX &= ~(1 << PN532_CS); // LOW na CS
_delay_us(2000);
spiwrite(PN532_SPI_DATAREAD);

for (uint8_t i = 0; i < n; i++) {
_delay_us(1000);
buff[i] = spiread();
}

PORTX |= (1 << PN532_CS); // HIGH na CS
}

void spiwritecommand(uint8_t* cmd, uint8_t cmdlen) {
uint8_t checksum;

cmdlen++;

PORTX &= ~(1 << PN532_CS); // LOW na CS
_delay_us(2000);
spiwrite(PN532_SPI_DATAWRITE);

checksum = PN532_PREAMBLE + PN532_PREAMBLE + PN532_STARTCODE2;
spiwrite(PN532_PREAMBLE);
spiwrite(PN532_PREAMBLE);
spiwrite(PN532_STARTCODE2);

spiwrite(cmdlen);
uint8_t cmdlen_1 = ~cmdlen + 1;
spiwrite(cmdlen_1);

spiwrite(PN532_HOSTTOPN532);
checksum += PN532_HOSTTOPN532;

for (uint8_t i=0; ispiwrite(cmd[i]);
checksum += cmd[i];
}

uint8_t checksum_1 = ~checksum;
spiwrite(checksum_1);
spiwrite(PN532_POSTAMBLE);
PORTX |= (1 << PN532_CS); // HIGH na CS
}

// LOW Level SPI

void spiwrite(uint8_t c) {
SPDR = c;
//oczekiwanie na ustawienie SPIF jeśli tak SPI done
while (!(SPSR & (1<uint8_t junk = SPDR;
}

uint8_t spiread(void) {
SPDR = 0;
//oczekiwanie na ustawienie SPIF jeśli tak SPI done
while (!(SPSR & (1<
return SPDR;
}[/syntax]

plik nfc_pn532.h

[syntax=c]# define PN532_PREAMBLE 0x00
# define PN532_STARTCODE1 0x00
# define PN532_STARTCODE2 0xFF
# define PN532_POSTAMBLE 0x00

# define PN532_HOSTTOPN532 0xD4

# define PN532_FIRMWAREVERSION 0x02
# define PN532_GETGENERALSTATUS 0x04
# define PN532_SAMCONFIGURATION 0x14
# define PN532_INLISTPASSIVETARGET 0x4A
# define PN532_INDATAEXCHANGE 0x40
# define PN532_MIFARE_READ 0x30
# define PN532_MIFARE_WRITE 0xA0

# define PN532_AUTH_WITH_KEYA 0x60
# define PN532_AUTH_WITH_KEYB 0x61

# define PN532_WAKEUP 0x55

# define PN532_SPI_STATREAD 0x02
# define PN532_SPI_DATAWRITE 0x01
# define PN532_SPI_DATAREAD 0x03
# define PN532_SPI_READY 0x01

# define PN532_MIFARE_ISO14443A 0x0

# define KEY_A 1
# define KEY_B 2

void setupPins (void);

void begin (void);

uint8_t SAMConfig (void);
uint32_t getFirmwareVersion (void);
uint32_t readPassiveTargetID (uint8_t cardbaudrate);
uint8_t authenticateBlock (uint8_t CardNumber / * 1 lub 2 * /,
uint32_t cid / * Id katry * /,
uint8_t blockaddress / * 0 do 63 * /,
uint8_t AuthType / * KEY_A lub KEY_B * /,
uint8_t * keys);

uint8_t readMemoryBlock (uint8_t CardNumber / * 1 lub 2 * /,
uint8_t blockaddress / * 0 do 63 * /,
uint8_t * blok);
uint8_t writeMemoryBlock (uint8_t CardNumber / * 1 lub 2 * /,
uint8_t blockaddress / * 0 do 63 * /,
uint8_t * blok);
uint8_t sendCommandCheckAck (uint8_t * cmd, uint8_t cmdlen, uint16_t limitu czasu);

spi_readack uint8_t (void);
readspistatus uint8_t (void);
void readspidata (uint8_t * buff, uint8_t n);
void spiwritecommand (uint8_t * cmd, uint8_t cmdlen);
void spiwrite (uint8_t c);
spiread uint8_t (void);[/syntax]

miłej zabawy z tagami NFC w standardzie MIAFARE

Statystyki: Napisane przez SunRiver — 16 sie 2014, o 09:08

nfc na pn532 i atmega. transfer z arduino.

2014-08-16T02:55:49+01:00

hej!

Kupilem sobie modul nfc oparty na pn532 z firmy df robot, o taki o:

http://www.dfrobot.com/wiki/index.php/NFC_Module_for_Arduino_(SKU:DFR0231)

jest tam gotowy kod z wywolaniem tagu dla arduino :

[syntax=cpp]
const unsigned char wake[24]={
  0x55, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0xfd, 0xd4, 0x14, 0x01, 0x17, 0x00};//wake up NFC module
const unsigned char firmware[9]={
  0x00, 0x00, 0xFF, 0x02, 0xFE, 0xD4, 0x02, 0x2A, 0x00};//
const unsigned char tag[11]={
  0x00, 0x00, 0xFF, 0x04, 0xFC, 0xD4, 0x4A, 0x01, 0x00, 0xE1, 0x00};//detecting tag command
const unsigned char std_ACK[25] = {
  0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x0C, \
0xF4, 0xD5, 0x4B, 0x01, 0x01, 0x00, 0x04, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x00};
unsigned char old_id[5];

unsigned char receive_ACK[25];//Command receiving buffer
//int inByte = 0;               //incoming serial byte buffer

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#define print1Byte(args) Serial1.write(args)
#define print1lnByte(args) Serial1.write(args),Serial1.println()
#else
#include "WProgram.h"
#define print1Byte(args) Serial1.print(args,BYTE)
#define print1lnByte(args) Serial1.println(args,BYTE)
#endif

void setup()
{
  Serial.begin(9600);   // open serial with PC
  Serial1.begin(115200);    //open serial1 with device
  //Serial2.begin(115200);
  wake_card();
  delay(100);
  read_ACK(15);
  delay(100);
  display(15);

}

void loop()
{
  send_tag();
  read_ACK(25);
  delay(100);
  if (!cmp_id ()) {
    if (test_ACK ()) {
      display (25);
      delay (100);
    }
  }
  copy_id ();
}

void copy_id (void)
{//save old id
  int ai, oi;
  for (oi=0, ai=19; oi<5; oi++,ai++) {
    old_id[oi] = receive_ACK[ai];
  }
}


char cmp_id (void)
{//return true if find id is old
  int ai, oi;
  for (oi=0,ai=19; oi<5; oi++,ai++) {
    if (old_id[oi] != receive_ACK[ai])
      return 0;
  }
  return 1;
}

int test_ACK (void)
{// return true if receive_ACK accord with std_ACK
  int i;
  for (i=0; i<19; i++) {
    if (receive_ACK[i] != std_ACK[i])
      return 0;
  }
  return 1;
}

void send_id (void)
{//send id to PC
  int i;
  Serial.print ("ID: ");
  for (i=19; i<= 23; i++) {
    Serial.print (receive_ACK[i], HEX);
    Serial.print (" ");
  }
  Serial.println ();
}

void UART1_Send_Byte(unsigned char command_data)
{//send byte to device
  print1Byte(command_data);
#if defined(ARDUINO) && ARDUINO >= 100
  Serial1.flush();// complete the transmission of outgoing serial data
#endif
}

void UART_Send_Byte(unsigned char command_data)
{//send byte to PC
  Serial.print(command_data,HEX);
  Serial.print(" ");
}

void read_ACK(unsigned char temp)
{//read ACK into reveive_ACK[]
  unsigned char i;
  for(i=0;i    receive_ACK[i]= Serial1.read();
  }
}

void wake_card(void)
{//send wake[] to device
  unsigned char i;
  for(i=0;i<24;i++) //send command
    UART1_Send_Byte(wake[i]);
}

void firmware_version(void)
{//send fireware[] to device
  unsigned char i;
  for(i=0;i<9;i++) //send command
    UART1_Send_Byte(firmware[i]);
}

void send_tag(void)
{//send tag[] to device
  unsigned char i;
  for(i=0;i<11;i++) //send command
    UART1_Send_Byte(tag[i]);
}

void display(unsigned char tem)
{//send receive_ACK[] to PC
  unsigned char i;
  for(i=0;i    UART_Send_Byte(receive_ACK[i]);
  Serial.println();
}

//*********** end *************[/syntax]

wklepalem to w eclipse i tak paczam w to i paczam. Obejzalem filmik instruktazowy jak importowac z arduino potrzebne rzeczy, niby mam mlotek ale boje sie tego znieczulenia.

Nie bardzo to wyglada aby dalo sie bezposrednio zaimportowac. Przerabiac tego chyba nie ma sensu.
Calosc zprowadza sie chyba tylko do wyslania znakow z tablicy wake i urzadzonko powinno wyslac swoj tag - mam racje? ktos probowal laczyc sie z pn532?

Statystyki: Napisane przez corey — 16 sie 2014, o 02:55