PN532 spi通信

peter

SPI communication details
      The PN532 is slave. A Status byte (Bit 0 of Status byte) indicates if the PN532 is ready to give a response
or not. First byte sent on MOSI by the host controller indicates which operation will be performed:
xxxx xx10 : Read (by the host) Status byte
xxxx xx01 : Write data (transmission from the host to the PN532)
xxxx xx11 : Read data (transmission from the PN532 to the host)
After having sent a command, the host controller must wait for bit 0 of Status byte equals 1 before reading
the data from the PN532.
Bytes are transmitted LSB first.
NSS must be toggle as shown in the user manual (reference 1) or in the next figures.

看文档：http://www.adafruit.com/datashee ... ion%20Note_v1.2.pdf
严格按照：2.4.2.4 章来调试
波形如下：

C语言代码参考（记得要行读）：

1. /**
   
2.         File Name: pn532_spi.c
   
3. 
   
4.         C Library for the PN532 written for the A Mega644.
   
5.         Adapted from pn532.cpp written by Adafruit Industries
   
6. 
   
7.         Author: Renato Amez
   
8. 
   
9. */
   
10. 
    
11. #include <avr/io.h>
    
12. #include <avr/pgmspace.h>
    
13. #include <stdio.h>
    
14. #include <util/delay.h>
    
15. #include <string.h>
    
16. #include "pn532_spi.h"
    
17. 
    
18. char pn532ack[] = {0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00};
    
19. char pn532response_firmwarevers[] = {0x00, 0xFF, 0x06, 0xFA, 0xD5, 0x03};
    
20. 
    
21. #define PN532_PACKBUFFSIZ        64
    
22. char pn532_packetbuffer[PN532_PACKBUFFSIZ];
    
23. 
    
24. // SET THE ACTUAL VALUE OF THE PINS BEFORE USING
    
25. #define PN532_CLK                PINB7        // SPI clock pin
    
26. #define PN532_MISO                PINB6        // SPI MISO pin
    
27. #define PN532_MOSI                PINB5         // SPI MOSI pin
    
28. #define PN532_CS                PINB4        // SPI chip select pin (CS/SSEL)
    
29. 
    
30. // CURRENT SETUP AT PORT A. SUBJECT TO CHANGE AT FINAL IMPLEMENTATION
    
31. #define DDRX                        DDRB
    
32. #define PORTX                        PORTB
    
33. #define PINX                        PINB
    
34. 
    
35. void setupPins(void) {
    
36.         // Change desired port DDRx and set MISO to INPUT, others to OUTPUT
    
37.         DDRX = (1 << PN532_MOSI) | (1 << PN532_CLK) | (1 << PN532_CS);
    
38. 
    
39.         SPCR = (1 << MSTR) | (1 << SPR0) | (1 << SPE) | (1 << DORD);
    
40. }
    
41. 
    
42. void begin(void) {
    
43.         PORTX &= ~(1 << PN532_CS);
    
44.         
    
45.         _delay_ms(1000);
    
46.         
    
47.         // send dummy command to get it synched up
    
48.         pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;
    
49.         uint8_t check = sendCommandCheckAck(pn532_packetbuffer, 1, 1000);
    
50. }
    
51. 
    
52. uint32_t getFirmwareVersion(void) {
    
53.         uint32_t response;
    
54. 
    
55.         pn532_packetbuffer[0] = PN532_FIRMWAREVERSION;
    
56. 
    
57.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 1, 1000)) return 0;
    
58. 
    
59.         // read data packet
    
60.         readspidata(pn532_packetbuffer, 12);
    
61. 
    
62.         // check some basic stuff
    
63.         if (0 != strncmp((char*)pn532_packetbuffer,
    
64.                 (char*)pn532response_firmwarevers, 6))
    
65.                         return 0;
    
66. 
    
67.         response = pn532_packetbuffer[6];
    
68.         response << 8;
    
69.     response |= pn532_packetbuffer[7];
    
70.     response <<= 8;
    
71.     response |= pn532_packetbuffer[8];
    
72.     response <<= 8;
    
73.     response |= pn532_packetbuffer[9];
    
74. 
    
75.     return response;
    
76. 
    
77. }
    
78. 
    
79. // default timeout of one second
    
80. uint8_t sendCommandCheckAck(uint8_t *cmd, uint8_t cmdlen, uint16_t timeout) {
    
81.         uint16_t timer = 0;
    
82.         
    
83.         // write the command
    
84.         spiwritecommand(cmd, cmdlen);
    
85. 
    
86.         // wait for the chip to say it's ready
    
87.         while(readspistatus() != PN532_SPI_READY) {
    
88.                 if (timeout != 0) {
    
89.                         timer += 10;
    
90.                         if (timer > timeout) {
    
91.                                 return 0;
    
92.                         }
    
93.                 }
    
94.                 _delay_ms(10);
    
95.         }
    
96. 
    
97.         // read acknowledgement
    
98.         if (0 == spi_readack()) {
    
99.                 return 0;
    
100.         }
     
101. 
     
102.         timer = 0;
     
103.         // wait for the chip to say it's ready
     
104.         while(readspistatus() != PN532_SPI_READY) {
     
105.                 if (timeout != 0) {
     
106.                         timer += 10;
     
107.                         if (timer > timeout) {
     
108.                                 return 0;
     
109.                         }
     
110.                 }
     
111.                 _delay_ms(10);
     
112.         }
     
113.         
     
114.         return 1;
     
115. }
     
116. 
     
117. uint8_t SAMConfig(void) {
     
118.         pn532_packetbuffer[0] = PN532_SAMCONFIGURATION;
     
119.         pn532_packetbuffer[1] = 0x01; // normal mode
     
120.         pn532_packetbuffer[2] = 0x14; // timeout 50ms * 20 = 1 second
     
121.         pn532_packetbuffer[3] = 0x01; // use IRQ pin!
     
122. 
     
123.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 4, 1000)) return 0;
     
124. 
     
125.         // read data packet
     
126.         readspidata(pn532_packetbuffer, 8);
     
127. 
     
128.         return (pn532_packetbuffer[5] == 0x15 ? 1 : 0);
     
129. }
     
130. 
     
131. uint8_t authenticateBlock(uint8_t cardnumber, uint32_t cid, uint8_t blockaddress,
     
132.                                         uint8_t authtype, uint8_t* keys) {
     
133.         pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
     
134.         pn532_packetbuffer[1] = cardnumber;
     
135. 
     
136.         if (authtype == KEY_A) {
     
137.                 pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYA;
     
138.         } else {
     
139.                 pn532_packetbuffer[2] = PN532_AUTH_WITH_KEYB;
     
140.         }
     
141.         pn532_packetbuffer[3] = blockaddress; // Address can be 0-63 for MIFARE 1K card
     
142. 
     
143.         pn532_packetbuffer[4] = keys[0];
     
144.         pn532_packetbuffer[5] = keys[1];
     
145.         pn532_packetbuffer[6] = keys[2];
     
146.     pn532_packetbuffer[7] = keys[3];
     
147.     pn532_packetbuffer[8] = keys[4];
     
148.     pn532_packetbuffer[9] = keys[5];
     
149. 
     
150.         pn532_packetbuffer[10] = ((cid >> 24) & 0xFF);
     
151.         pn532_packetbuffer[11] = ((cid >> 16) & 0xFF);
     
152.         pn532_packetbuffer[12] = ((cid >> 8) & 0xFF);
     
153.         pn532_packetbuffer[13] = ((cid >> 0) & 0xFF);
     
154. 
     
155.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 14, 1000)) return 0;
     
156.         
     
157.         // read data packet
     
158.         readspidata(pn532_packetbuffer, 2+6);
     
159. 
     
160.         if ((pn532_packetbuffer[6] = 0x41) && (pn532_packetbuffer[7] == 0x00)) {
     
161.                 return 1;
     
162.         } else {
     
163.                 return 0;
     
164.         }
     
165. }
     
166. 
     
167. uint8_t readMemoryBlock(uint8_t cardnumber, uint8_t blockaddress, uint8_t* block) {
     
168.         pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
     
169.         pn532_packetbuffer[1] = cardnumber;
     
170.         pn532_packetbuffer[2] = PN532_MIFARE_READ;
     
171.         pn532_packetbuffer[3] = blockaddress;
     
172. 
     
173.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 4, 1000)) return 0;
     
174. 
     
175.         // read data packet
     
176.         readspidata(pn532_packetbuffer, 18+6);
     
177.         for (uint8_t i = 8; i < 18+6; i++) {
     
178.                 block[i-8] = pn532_packetbuffer[i];
     
179.         }
     
180. 
     
181.         if ((pn532_packetbuffer[6] == 0x41) && (pn532_packetbuffer[7] == 0x00)) {
     
182.                 return 1; // read successful
     
183.         } else {
     
184.                 return 0;
     
185.         }
     
186. }
     
187. 
     
188. // Do not write to Sector Trailer Block unless you know what you are doing
     
189. uint8_t writeMemoryBlock(uint8_t cardnumber, uint8_t blockaddress, uint8_t* block) {
     
190.         pn532_packetbuffer[0] = PN532_INDATAEXCHANGE;
     
191.         pn532_packetbuffer[1] = cardnumber;
     
192.         pn532_packetbuffer[2] = PN532_MIFARE_WRITE;
     
193.         pn532_packetbuffer[3] = blockaddress;
     
194. 
     
195.         for (uint8_t byte = 0; byte < 16; byte++) {
     
196.                 pn532_packetbuffer[4+byte] = block[byte];
     
197.         }
     
198. 
     
199.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 4+16, 1000)) return 0;
     
200. 
     
201.         // read data packet
     
202.         readspidata(pn532_packetbuffer, 2+6);
     
203. 
     
204.         if ((pn532_packetbuffer[6] == 0x41) && (pn532_packetbuffer[7] == 0x00)) {
     
205.                 return 1; // write successful
     
206.         } else {
     
207.                 return 0;
     
208.         }
     
209. }
     
210. 
     
211. uint32_t readPassiveTargetID(uint8_t cardbaudrate) {
     
212.         uint32_t cid;
     
213. 
     
214.         pn532_packetbuffer[0] = PN532_INLISTPASSIVETARGET;
     
215.         pn532_packetbuffer[1] = 1; // max 1 card at once
     
216.         pn532_packetbuffer[2] = cardbaudrate;
     
217. 
     
218.         if (0 == sendCommandCheckAck(pn532_packetbuffer, 3, 1000)) return 0x00; // no cards read
     
219. 
     
220.         // read data packet
     
221.         readspidata(pn532_packetbuffer, 20);
     
222. 
     
223.         if (pn532_packetbuffer[7] != 1) return 0;
     
224. 
     
225.         uint16_t sens_res = pn532_packetbuffer[9];
     
226.         sens_res <<= 8;
     
227.         sens_res |= pn532_packetbuffer[10];
     
228. 
     
229.         cid = 0;
     
230.          for (uint8_t i = 0; i < pn532_packetbuffer[12]; i++) {
     
231.                 cid <<= 8;
     
232.                 cid |= pn532_packetbuffer[13+i];
     
233.         }
     
234. 
     
235.         return cid;
     
236. }
     
237. 
     
238. // high level SPI
     
239. uint8_t spi_readack(void) {
     
240.         uint8_t ackbuff[6];
     
241.         
     
242.         readspidata(ackbuff, 6);
     
243. 
     
244.         return (0 == strncmp((char*) ackbuff, (char*) pn532ack, 6)) ? 1 : 0;
     
245. }
     
246. 
     
247. // mid level SPI
     
248. uint8_t readspistatus(void) {
     
249.         PORTX &= ~(1 << PN532_CS); // write LOW to CS pin
     
250.         _delay_us(2000);
     
251. 
     
252.         spiwrite(PN532_SPI_STATREAD);
     
253.         // read byte
     
254.         uint8_t x = spiread();
     
255. 
     
256.         PORTX |= (1 << PN532_CS); // write HIGH to CS pin
     
257.         return x;
     
258. }
     
259. 
     
260. void readspidata(uint8_t* buff, uint8_t n) {
     
261.         PORTX &= ~(1 << PN532_CS); // write LOW to CS pin
     
262.         _delay_us(2000);
     
263.         spiwrite(PN532_SPI_DATAREAD);
     
264. 
     
265.         for (uint8_t i = 0; i < n; i++) {
     
266.                 _delay_us(1000);
     
267.                 buff[i] = spiread();
     
268.         }
     
269. 
     
270.         PORTX |= (1 << PN532_CS); // write HIGH to CS pin
     
271. }
     
272. 
     
273. void spiwritecommand(uint8_t* cmd, uint8_t cmdlen) {
     
274.         uint8_t checksum;
     
275. 
     
276.         cmdlen++;
     
277. 
     
278.         PORTX &= ~(1 << PN532_CS); // write LOW to CS pin
     
279.         _delay_us(2000);
     
280.         spiwrite(PN532_SPI_DATAWRITE);
     
281. 
     
282.         checksum = PN532_PREAMBLE + PN532_PREAMBLE + PN532_STARTCODE2;
     
283.         spiwrite(PN532_PREAMBLE);
     
284.         spiwrite(PN532_PREAMBLE);
     
285.         spiwrite(PN532_STARTCODE2);
     
286. 
     
287.         spiwrite(cmdlen);
     
288.         uint8_t cmdlen_1 = ~cmdlen + 1;
     
289.         spiwrite(cmdlen_1);
     
290. 
     
291.         spiwrite(PN532_HOSTTOPN532);
     
292.         checksum += PN532_HOSTTOPN532;
     
293. 
     
294.         for (uint8_t i=0; i<cmdlen-1; i++) {
     
295.                 spiwrite(cmd[i]);
     
296.                 checksum += cmd[i];
     
297.         }
     
298. 
     
299.         uint8_t checksum_1 = ~checksum;
     
300.         spiwrite(checksum_1);
     
301.         spiwrite(PN532_POSTAMBLE);
     
302.         PORTX |= (1 << PN532_CS); // write HIGH to CS pin
     
303. }
     
304. 
     
305. // low level SPI
     
306. void spiwrite(uint8_t c) {
     
307.         SPDR = c;        
     
308.         //wait until SPIF is set (SPI done)
     
309.     while (!(SPSR & (1<<SPIF))) ;
     
310.         uint8_t junk = SPDR;
     
311. }
     
312. 
     
313. uint8_t spiread(void) {
     
314.         SPDR = 0;        
     
315.         //wait until SPIF is set (SPI done)
     
316.     while (!(SPSR & (1<<SPIF))) ;
     
317. 
     
318.         return SPDR;
     
319. }

复制代码

记得先 调用getFirmwareVersion