| 0,0 → 1,402 |
|---|
| #include "maindefs.h" |
| #include "nfc.h" |
| #include "i2c.h" |
| #include <string.h> |
| #include <delays.h> |
| |
| static NFC_DATA nfc_data; |
| |
| // Const value arrays for comparison use |
| static char pn532response_firmwarevers[] = {0x01, 0x00, 0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03}; |
| static char pn532ack[] = {0x01, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00}; |
| |
| void NFC_Init() { |
| TRISCbits.TRISC1 = 1; // IRQ Pin is RC5 |
| TRISCbits.TRISC2 = 0; // Reset Pin is RC2 |
| |
| // Reset the PN532 |
| LATCbits.LATC2 = 1; |
| LATCbits.LATC2 = 0; |
| Delay10TCYx(1); |
| LATCbits.LATC2 = 1; |
| } |
| |
| // Configures the SAM (Secure Access Module) |
| unsigned char NFC_SAMConfig() { |
| nfc_data.packetbuffer[0] = PN532_COMMAND_SAMCONFIGURATION; |
| nfc_data.packetbuffer[1] = 0x01; // Normal mode |
| nfc_data.packetbuffer[2] = 0x14; // Timeout 50ms * 20 = 1s |
| nfc_data.packetbuffer[3] = 0x01; // Use IRQ pin |
| |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 4)) |
| return 0; |
| |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 8); |
| |
| return (nfc_data.packetbuffer[7] == 0x15); |
| } |
| |
| // Checks the firmware version of the PN5xx chip |
| NFC_FIRMWARE_VERSION NFC_getFirmwareVersion(void) { |
| NFC_FIRMWARE_VERSION response = {0,0,0,0}; |
| |
| // Create and send command |
| nfc_data.packetbuffer[0] = PN532_COMMAND_GETFIRMWAREVERSION; |
| |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 1)) |
| return response; |
| |
| // Read back data from the PN532 |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 12); |
| |
| // Compare and check returned values |
| if (strncmp((char *)nfc_data.packetbuffer, (char *)pn532response_firmwarevers, 8) != 0) |
| return response; |
| |
| // Save and return info |
| response.IC = nfc_data.packetbuffer[8]; |
| response.Ver = nfc_data.packetbuffer[9]; |
| response.Rev = nfc_data.packetbuffer[10]; |
| response.Support = nfc_data.packetbuffer[11]; |
| |
| return response; |
| } |
| |
| // Sends a command and waits a specified period for the ACK |
| unsigned char NFC_sendCommandCheckAck(unsigned char *cmd, unsigned char cmdlen) { |
| unsigned int timer = 0; |
| |
| // Write the command |
| NFC_I2C_Write_Cmd(cmd, cmdlen); |
| |
| // Wait for chip to be ready |
| while (NFC_I2C_Read_Status() != PN532_I2C_READY) { |
| if (PN532_TIMEOUT != 0) { |
| timer += 1; |
| if (timer > PN532_TIMEOUT) |
| return 0; |
| } |
| Delay10TCYx(1); |
| } |
| |
| // Check ACK |
| if (!NFC_I2C_Read_ACK()) { |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| // Waits for an ISO14443A target to enter the field |
| unsigned char NFC_readPassiveTargetID(unsigned char cardbaudrate, unsigned char * uid, unsigned char * uidLength) { |
| unsigned char i = 0; |
| |
| nfc_data.packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET; |
| nfc_data.packetbuffer[1] = 1; // max 1 cards at once (we can set this to 2 later) |
| nfc_data.packetbuffer[2] = cardbaudrate; |
| |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 3)) |
| return 0; |
| |
| // Wait for IRQ line |
| while (NFC_I2C_Read_Status() != PN532_I2C_READY); |
| |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 20); |
| |
| /* ISO14443A card response should be in the following format: |
| // (byte 0 is actually 0x01 (data ready)) |
| byte Description |
| ------------- ------------------------------------------ |
| b0..6 Frame header and preamble |
| b7 Tags Found |
| b8 Tag Number (only one used in this example) |
| b9..10 SENS_RES |
| b11 SEL_RES |
| b12 NFCID Length |
| b13..NFCIDLen NFCID */ |
| |
| // Check # of tags found |
| if (nfc_data.packetbuffer[8] != 1) |
| return 0; |
| |
| // Save UID length |
| *uidLength = nfc_data.packetbuffer[13]; |
| |
| // Save UID |
| for (i = 0; i < *uidLength; i++) { |
| uid[i] = nfc_data.packetbuffer[14+i]; |
| } |
| |
| return 1; |
| } |
| |
| // Indicates whether the specified block number is the first block |
| // in the sector (block 0 relative to the current sector) |
| unsigned char NFC_mifareclassic_IsFirstBlock(unsigned long uiBlock) { |
| // Test if we are in the small or big sectors |
| if (uiBlock < 128) |
| return ((uiBlock) % 4 == 0); |
| else |
| return ((uiBlock) % 16 == 0); |
| } |
| |
| // Indicates whether the specified block number is the sector trailer |
| unsigned char NFC_mifareclassic_IsTrailerBlock(unsigned long uiBlock) { |
| // Test if we are in the small or big sectors |
| if (uiBlock < 128) |
| return ((uiBlock + 1) % 4 == 0); |
| else |
| return ((uiBlock + 1) % 16 == 0); |
| } |
| |
| // Tries to authenticate a block of memory on a MIFARE card using the INDATAEXCHANGE command |
| unsigned char NFC_mifareclassic_AuthenticateBlock(unsigned char *uid, unsigned char uidLen, unsigned long blockNumber, unsigned char keyNumber, unsigned char *keyData) { |
| // See section 7.3.8 of the PN532 User Manual |
| // blockNumber = The block number to authenticate. (0..63 for 1KB cards, and 0..255 for 4KB cards)\ |
| // keyNumber = Which key type to use during authentication (0 = MIFARE_CMD_AUTH_A, 1 = MIFARE_CMD_AUTH_B) |
| // keyData = Pointer to a byte array containing the 6 byte key value |
| |
| unsigned char i; |
| |
| // Assemble frame data |
| nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; /* Data Exchange Header */ |
| nfc_data.packetbuffer[1] = 1; /* Max card numbers */ |
| nfc_data.packetbuffer[2] = (keyNumber) ? MIFARE_CMD_AUTH_A : MIFARE_CMD_AUTH_B; |
| nfc_data.packetbuffer[3] = blockNumber; /* Block Number (1K = 0..63, 4K = 0..255 */ |
| for (i = 0; i < 6; i++) { |
| nfc_data.packetbuffer[4+i] = keyData[i]; |
| } |
| for (i = 0; i < uidLen; i++) { |
| nfc_data.packetbuffer[10+i] = uid[i]; |
| } |
| |
| // Send frame and check for ACK |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 10+uidLen)) |
| return 0; |
| |
| // Read response from PN532 |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 12); |
| |
| return 1; |
| } |
| |
| // Tries to read an entire 16-byte data block at the specified block address |
| unsigned char NFC_mifareclassic_ReadDataBlock(unsigned char blockNumber, unsigned char *data) { |
| unsigned char i; |
| |
| // Assemble frame data |
| nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
| nfc_data.packetbuffer[1] = 1; /* Card number */ |
| nfc_data.packetbuffer[2] = MIFARE_CMD_READ; /* Mifare Read command = 0x30 */ |
| nfc_data.packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
| |
| // Send frame and check for ACK |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 4)) |
| return 0; |
| |
| // Read reponse |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 26); |
| |
| // If byte 9 isnt 0x00 we probably have and error |
| if (nfc_data.packetbuffer[8] != 0x00) { |
| return 0; |
| } |
| |
| // Copy the 16 data bytes into the data buffer |
| // Block contents starts at byte 10 of a valid response |
| for (i = 0; i < 16; i++) { |
| data[i] = nfc_data.packetbuffer[9+i]; |
| } |
| |
| return 1; |
| } |
| |
| // Tries to write an entire 16-byte data block at the specified block address |
| unsigned char NFC_mifareclassic_WriteDataBlock(unsigned char blockNumber, unsigned char *data) { |
| unsigned char i; |
| |
| // Assemble frame data |
| nfc_data.packetbuffer[0] = PN532_COMMAND_INDATAEXCHANGE; |
| nfc_data.packetbuffer[1] = 1; /* Card number */ |
| nfc_data.packetbuffer[2] = MIFARE_CMD_WRITE; /* Mifare Write command = 0xA0 */ |
| nfc_data.packetbuffer[3] = blockNumber; /* Block Number (0..63 for 1K, 0..255 for 4K) */ |
| for (i = 0; i < 16; i++) { /* Data Payload */ |
| nfc_data.packetbuffer[4+i] = data[i]; |
| } |
| |
| // Send frame and check for ACK |
| if (!NFC_sendCommandCheckAck(nfc_data.packetbuffer, 20)) |
| return 0; |
| |
| // Read response |
| NFC_I2C_Read_Data(nfc_data.packetbuffer, 26); |
| |
| return 1; |
| } |
| |
| // Formats a Mifare Classic card to store NDEF Records |
| unsigned char NFC_mifareclassic_FormatNDEF(void) { |
| unsigned char sectorbuffer1[16] = {0x14, 0x01, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1}; |
| unsigned char sectorbuffer2[16] = {0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1, 0x03, 0xE1}; |
| unsigned char sectorbuffer3[16] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0x78, 0x77, 0x88, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
| |
| // Write blocks 1 and 2 |
| if (!NFC_mifareclassic_WriteDataBlock(1, sectorbuffer1)) |
| return 0; |
| if (!NFC_mifareclassic_WriteDataBlock(2, sectorbuffer2)) |
| return 0; |
| // Write key A and access rights |
| if (!NFC_mifareclassic_WriteDataBlock(3, sectorbuffer3)) |
| return 0; |
| |
| return 1; |
| } |
| |
| // Writes an NDEF URI Record to the specified sector (1..15) |
| /* Note that this function assumes that the Mifare Classic card is |
| already formatted to work as an "NFC Forum Tag" and uses a MAD1 |
| file system. You can use the NXP TagWriter app on Android to |
| properly format cards for this. */ |
| unsigned char NFC_mifareclassic_WriteNDEFURI(unsigned char sectorNumber, unsigned char uriIdentifier, const char * url) { |
| // uriIdentifier = The uri identifier code (0 = none, 0x01 = "http://www.", etc.) |
| // url = The uri text to write (max 38 characters) |
| |
| // Figure out how long the string is |
| unsigned char len = strlen(url); |
| |
| unsigned char sectorbuffer1[16] = {0x00, 0x00, 0x03, len + 5, 0xD1, 0x01, len + 1, 0x55, uriIdentifier, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
| unsigned char sectorbuffer2[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
| unsigned char sectorbuffer3[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
| unsigned char sectorbuffer4[16] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7, 0x7F, 0x07, 0x88, 0x40, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
| |
| // Make sure we're within a 1K limit for the sector number |
| if ((sectorNumber < 1) || (sectorNumber > 15)) |
| return 0; |
| |
| // Make sure the URI payload is between 1 and 38 chars |
| if ((len < 1) || (len > 38)) |
| return 0; |
| |
| if (len <= 6) { |
| // Unlikely we'll get a url this short, but why not ... |
| memcpy(sectorbuffer1 + 9, url, len); |
| sectorbuffer1[len + 9] = 0xFE; |
| } else if (len == 7) { |
| // 0xFE needs to be wrapped around to next block |
| memcpy(sectorbuffer1 + 9, url, len); |
| sectorbuffer2[0] = 0xFE; |
| } else if ((len > 7) || (len <= 22)) { |
| // Url fits in two blocks |
| memcpy(sectorbuffer1 + 9, url, 7); |
| memcpy(sectorbuffer2, url + 7, len - 7); |
| sectorbuffer2[len - 7] = 0xFE; |
| } else if (len == 23) { |
| // 0xFE needs to be wrapped around to final block |
| memcpy(sectorbuffer1 + 9, url, 7); |
| memcpy(sectorbuffer2, url + 7, len - 7); |
| sectorbuffer3[0] = 0xFE; |
| } else { |
| // Url fits in three blocks |
| memcpy(sectorbuffer1 + 9, url, 7); |
| memcpy(sectorbuffer2, url + 7, 16); |
| memcpy(sectorbuffer3, url + 23, len - 24); |
| sectorbuffer3[len - 22] = 0xFE; |
| } |
| |
| // Now write all three blocks back to the card |
| if (!(NFC_mifareclassic_WriteDataBlock(sectorNumber * 4, sectorbuffer1))) |
| return 0; |
| if (!(NFC_mifareclassic_WriteDataBlock((sectorNumber * 4) + 1, sectorbuffer2))) |
| return 0; |
| if (!(NFC_mifareclassic_WriteDataBlock((sectorNumber * 4) + 2, sectorbuffer3))) |
| return 0; |
| if (!(NFC_mifareclassic_WriteDataBlock((sectorNumber * 4) + 3, sectorbuffer4))) |
| return 0; |
| |
| return 1; |
| } |
| |
| // Reads and checks for the ACK signal |
| unsigned char NFC_I2C_Read_ACK() { |
| unsigned char buffer[7]; |
| |
| // Check ACK |
| NFC_I2C_Read_Data(buffer, 6); |
| |
| // Return if the 7 bytes matches the ACK |
| return (strncmp((char *)buffer, (char *)pn532ack, 7) == 0); |
| } |
| |
| // Checks the IRQ pin to know if the PN532 is ready |
| unsigned char NFC_I2C_Read_Status() { |
| if (PORTCbits.RC1 == 1) { |
| return PN532_I2C_BUSY; |
| } else { |
| return PN532_I2C_READY; |
| } |
| } |
| |
| // Reads n bytes of data from the PN532 via I2C |
| void NFC_I2C_Read_Data(unsigned char *buffer, unsigned char length) { |
| unsigned char result; |
| |
| // Wait for IRQ to go low |
| while (NFC_I2C_Read_Status() != PN532_I2C_READY); |
| |
| // Read bytes from PN532 into buffer |
| I2C_Master_Recv(PN532_I2C_ADDRESS, length+2); |
| result = I2C_Get_Status(); |
| while (!result) { |
| result = I2C_Get_Status(); |
| } |
| I2C_Read_Buffer((char *)buffer); |
| |
| // Note: First byte is always 0x01 (ready status from PN532) |
| /* Remaining packet byte layout is as follows: |
| Byte Description |
| ----- ---------------------- |
| * 0 Preamble (0x00) |
| * 1-2 Start code (0x00,0xFF) |
| * 3 Length (TFI to N) |
| * 4 Length Checksum (Length + LCS = 0x00) |
| * 5 TFI (Frame identifier) |
| * 0xD4 - Host to PN532 |
| * 0xD5 - PN532 to Host |
| * 6-N Data (Length - 1 bytes) |
| * N+1 Data checksum (TFI + Data~N + DCS = 0x00) |
| * N+2 Postamble (0x00) */ |
| } |
| |
| // Writes a command to the PN532, automatically inserting the preamble and required frame details (checksum, len, etc.) |
| void NFC_I2C_Write_Cmd(unsigned char* cmd, unsigned char cmdlen) { |
| int i; |
| unsigned char checksum; |
| unsigned char buffer[PN532_PACKBUFFSIZ+8]; |
| unsigned char buffer_ind = 6; |
| cmdlen++; |
| |
| checksum = PN532_PREAMBLE + PN532_PREAMBLE + PN532_STARTCODE2 + PN532_HOSTTOPN532; |
| |
| // Fill out required frame fields |
| buffer[0] = PN532_PREAMBLE; |
| buffer[1] = PN532_PREAMBLE; |
| buffer[2] = PN532_STARTCODE2; |
| buffer[3] = cmdlen; |
| buffer[4] = ~cmdlen + 1; |
| buffer[5] = PN532_HOSTTOPN532; |
| |
| |
| // Copy cmd to be sent |
| for (i = 0; i < cmdlen-1; i++) { |
| checksum += cmd[i]; |
| buffer[buffer_ind] = cmd[i]; |
| buffer_ind++; |
| } |
| |
| buffer[buffer_ind] = ~checksum; |
| buffer_ind++; |
| buffer[buffer_ind] = PN532_POSTAMBLE; |
| buffer_ind++; |
| |
| I2C_Master_Send(PN532_I2C_ADDRESS, buffer_ind, buffer); |
| } |