RFID - MFRC523 mit NTAG203F

Daniel B. OP #3316622
Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich benutze den MFRC523 (NXP) in Verbindung mit dem C8051F120 von 
Silabs. Der Chip ist an der SPI angebunden und ich kann mit ihm auch 
soweit kommunizieren.

Der integrierte Selbsttest funktioniert auch, d.h. im FIFO des MFRC523 
stehen genau die Bytes wie im Handbuch beschrieben.

Ich versuche gerade eine Verbindung mit dem NTAG203F (NXP) herzustellen. 
Eine Antwort (0x44 0x00) auf das Kommando 0x26 (REQA) bekomme ich auch 
wie im Datenblatt beschrieben. Nun habe ich versucht die Anticollision 
durchzuführen, aber dabei erhalte ich nie eine Antwort, der FIFO ist 
immer leer, auch wenn ich etwas länger auf eine Antwort warte.

Kennt sich jemand von euch damit aus und kann mir eventuell einen Tip 
geben, was ich falsch mache?

MfG, Daniel
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Ralf Gast #3316686
Lesenswert?
• ▲
▼ 
> Kennt sich jemand von euch damit aus und kann mir eventuell einen Tip
> geben, was ich falsch mache?
Der erste Tip wäre, wenn du einen Bezug auf ein Datenblatt machst, 
dieses auch geschickterweise zu verlinken :)
Der zweite wäre, deinen Code zu posten. Und der dritte: eine 
Beschreibung dessen, was bereits funktioniert (z.B. UID lesen, etc.), 
und worauf der bestehende Code aufbaut.

Hast du bei NxP bzw. auf deren Mifare-Seite schon geschaut, ob es einen 
(mehr oder weniger) fertigen Stack oder zumindest ne API gibt?

Ralf
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Daniel B. OP #3317744
Lesenswert?
• ▲
▼ 
Hallo Ralf,

vielen Dank für deine Antwort.

Die Datenblattverweise habe ich total vergessen, also hier zur Ergänzung 
noch die Verweise.

NXP MFRC523 - http://www.nxp.com/documents/data_sheet/MFRC523.pdf
NTAG203F    - http://www.nxp.com/documents/data_sheet/NTAG203F.pdf

Nach einer API habe ich auch geschaut und habe auch eine gefunden 
(http://www.nxp.com/documents/software/200312.zip), nur ist mir bisher 
noch nicht klar, wie ich diese einbinden soll, da ich nicht den vollen 
Funktionsumfang benötige.

Mein bisheriger Code kann nur wie oben schon beschrieben Mittels REQA 
Kommando den Tag erkennen. Das sehe ich am Inhalt des FIFO's nach 
absenden des Kommandos. Da stehen dann genau die beiden Bytes 0x44 & 
0x00 wie im Datenblatt vom Tag beschrieben. Das Problem was ich 
eigentlich nun habe ist, dass nachdiesem REQA Kommando laut Datenblatt 
der Tag in den Ready 1 state (S.7 Fig.5) gehen sollte und man von dort 
aus entweder mit der Anticollision oder dem direktem Select fortfahren 
kann. Nun hatte ich versucht die Anticollision durchzuführen, habe dabei 
aber keine Antwort vom Tag mehr erhalten und ich weis nicht warum. Nur 
zur Information, das Tag wurde nicht bewegt.

Hier mein bisheriger Code (ist nur ein Ausschnitt):
1
SET_SFRPAGE (CONFIG_PAGE);

2
CS_RST_RFID = 1;

3


4
for(i=0; i<64; i++)

5
{

6
  buf[5+i] = 0x00;

7
}

8


9
SET_SFRPAGE (SPI0_PAGE);

10
SPICFG (0,0);  // CLKPOL=0, CLKPHA=0

11


12
SET_SFRPAGE (CONFIG_PAGE);

13
CS_RFID = 0;                    

14


15
SET_SFRPAGE (SPI0_PAGE);

16
SPIF = 0;

17
SPI0DAT = (0x01<<1);  // CommandReg register. 

18
while (!SPIF);  // wait until transmission complete

19


20
SPIF = 0;

21
SPI0DAT = 0x0F;  // SoftReset

22
while (!SPIF);  // wait until transmission complete

23


24
SET_SFRPAGE (CONFIG_PAGE);

25
CS_RFID = 1;

26


27
CS_RFID = 0;

28


29
SET_SFRPAGE (SPI0_PAGE);

30
SPIF = 0;

31
SPI0DAT = (0x14<<1);  // TxControlReg register. 

32
while (!SPIF);  // wait until transmission complete

33


34
SPIF = 0;

35
SPI0DAT = 0x83;  // TxControlReg - InvTx2On=1, Tx2RFEn, Tx1RFEn

36
while (!SPIF);  // wait until transmission complete

37


38
SET_SFRPAGE (CONFIG_PAGE);

39
CS_RFID = 1;

40


41
CS_RFID = 0;

42


43
SET_SFRPAGE (SPI0_PAGE);

44
SPIF = 0;

45
SPI0DAT = (0x15<<1);  // TxASKReg register. 

46
while (!SPIF);  // wait until transmission complete

47


48
SPIF = 0;

49
SPI0DAT = 0x40;  // Force100ASK

50
while (!SPIF);  // wait until transmission complete

51


52
SET_SFRPAGE (CONFIG_PAGE);

53
CS_RFID = 1;

54


55
CS_RFID = 0;

56


57
SET_SFRPAGE (SPI0_PAGE);

58
SPIF = 0;

59
SPI0DAT = (0x18<<1);  // RxThresholdReg register. 

60
while (!SPIF);  // wait until transmission complete

61


62
SPIF = 0;

63
SPI0DAT = 0x55;  // RxThresholdReg - MinLevel, CollLevel

64
while (!SPIF);  // wait until transmission complete

65


66
SET_SFRPAGE (CONFIG_PAGE);

67
CS_RFID = 1;

68


69
CS_RFID = 0;

70


71
SET_SFRPAGE (SPI0_PAGE);

72
SPIF = 0;

73
SPI0DAT = (0x19<<1);  // DemodReg register. 

74
while (!SPIF);  // wait until transmission complete

75


76
SPIF = 0;

77
SPI0DAT = 0x4D;  // DemodReg

78
while (!SPIF);  // wait until transmission complete

79


80
SET_SFRPAGE (CONFIG_PAGE);

81
CS_RFID = 1;

82


83
CS_RFID = 0;

84


85
SET_SFRPAGE (SPI0_PAGE);

86
SPIF = 0;

87
SPI0DAT = (0x23<<1);  // GsNLoadMod register. 

88
while (!SPIF);  // wait until transmission complete

89


90
SPIF = 0;

91
SPI0DAT = 0x6F;  // GsNLoadMod

92
while (!SPIF);  // wait until transmission complete

93


94
SET_SFRPAGE (CONFIG_PAGE);

95
CS_RFID = 1;

96


97
CS_RFID = 0;

98


99
SET_SFRPAGE (SPI0_PAGE);

100
SPIF = 0;

101
SPI0DAT = (0x24<<1);  // ModwidthReg register. 

102
while (!SPIF);  // wait until transmission complete

103


104
SPIF = 0;

105
SPI0DAT = 0x26;  // Modwidth

106
while (!SPIF);  // wait until transmission complete

107


108
SET_SFRPAGE (CONFIG_PAGE);

109
CS_RFID = 1;

110


111
CS_RFID = 0;

112


113
SET_SFRPAGE (SPI0_PAGE);

114
SPIF = 0;

115
SPI0DAT = (0x25<<1);  // TxBitPhase register. 

116
while (!SPIF);  // wait until transmission complete

117


118
SPIF = 0;

119
SPI0DAT = 0x8F;  // TxBitPhase

120
while (!SPIF);  // wait until transmission complete

121


122
SET_SFRPAGE (CONFIG_PAGE);

123
CS_RFID = 1;

124


125
CS_RFID = 0;

126


127
SET_SFRPAGE (SPI0_PAGE);

128
SPIF = 0;

129
SPI0DAT = (0x26<<1);  // RFCfgReg register. 

130
while (!SPIF);  // wait until transmission complete

131


132
SPIF = 0;

133
SPI0DAT = 0x59;  // RxGain

134
while (!SPIF);  // wait until transmission complete

135


136
SET_SFRPAGE (CONFIG_PAGE);

137
CS_RFID = 1;

138


139
CS_RFID = 0;

140


141
SET_SFRPAGE (SPI0_PAGE);

142
SPIF = 0;

143
SPI0DAT = (0x27<<1);  // GsNReg register. 

144
while (!SPIF);  // wait until transmission complete

145


146
SPIF = 0;

147
SPI0DAT = 0xF4;  // CWGsN, ModGsN

148
while (!SPIF);  // wait until transmission complete

149


150
SET_SFRPAGE (CONFIG_PAGE);

151
CS_RFID = 1;

152


153
CS_RFID = 0;

154


155
SET_SFRPAGE (SPI0_PAGE);

156
SPIF = 0;

157
SPI0DAT = (0x28<<1);  // CWGsPReg register. 

158
while (!SPIF);  // wait until transmission complete

159


160
SPIF = 0;

161
SPI0DAT = 0x3F;  // CWGsP

162
while (!SPIF);  // wait until transmission complete

163


164
SET_SFRPAGE (CONFIG_PAGE);

165
CS_RFID = 1;

166


167
CS_RFID = 0;

168


169
SET_SFRPAGE (SPI0_PAGE);

170
SPIF = 0;

171
SPI0DAT = (0x29<<1);  // ModGsPReg register. 

172
while (!SPIF);  // wait until transmission complete

173


174
SPIF = 0;

175
SPI0DAT = 0x11;  // ModGsP

176
while (!SPIF);  // wait until transmission complete

177


178
SET_SFRPAGE (CONFIG_PAGE);

179
CS_RFID = 1;

180


181
CS_RFID = 0;

182


183
SET_SFRPAGE (SPI0_PAGE);

184
SPIF = 0;

185
SPI0DAT = (0x01<<1);  // CommandReg

186
while (!SPIF);  // wait until transmission complete

187


188
SPIF = 0;

189
SPI0DAT = 0x0C;  // transceive

190
while (!SPIF);  // wait until transmission complete

191


192
SET_SFRPAGE (CONFIG_PAGE);

193
CS_RFID = 1;

194


195


196
//Write Request code 0x26 = REQA or 0x52 = WUPA to FIFO

197
// and wait for an answer only 100 times, then stop

198
buf[7] = 0x00;

199
i=0;

200


201
while(buf[7] != 0x02 && i<100) // 100x versuchen einen Tag zu erkennen, danach abbrechen

202
{

203
  CS_RFID = 0;

204
  

205
  SET_SFRPAGE (SPI0_PAGE);

206
  SPIF = 0;

207
  SPI0DAT = (0x0A<<1);  // Flush FIFO

208
  while (!SPIF);  // wait until transmission complete

209
  

210
  SPIF = 0;

211
  SPI0DAT = 0x80;  // Flush FIFO

212
  while (!SPIF);  // wait until transmission complete

213
  

214
  SET_SFRPAGE (CONFIG_PAGE);

215
  CS_RFID = 1;

216
  

217
  CS_RFID = 0;

218
  

219
  SET_SFRPAGE (SPI0_PAGE);

220
  SPIF = 0;

221
  SPI0DAT = (0x09<<1);  // write to FIFO

222
  while (!SPIF);  // wait until transmission complete

223
  

224
  SPIF = 0;

225
  SPI0DAT = 0x26;  // REQA - Request code

226
  while (!SPIF);  // wait until transmission complete

227
  

228
  SET_SFRPAGE (CONFIG_PAGE);

229
  CS_RFID = 1;

230
  

231
  CS_RFID = 0;

232
  

233
  SET_SFRPAGE (SPI0_PAGE);

234
  SPIF = 0;

235
  SPI0DAT = (0x80|(0x0A<<1));  // Read FIFOLevel

236
  while (!SPIF);  // wait until transmission complete

237
  

238
  SPIF = 0;

239
  SPI0DAT = 0x00;  // Read FIFOLevel

240
  while (!SPIF);  // wait until transmission complete

241
  buf[5] = SPI0DAT;

242
  

243
  SET_SFRPAGE (CONFIG_PAGE);

244
  CS_RFID = 1;

245
                      

246
  CS_RFID = 0;

247
  

248
  SET_SFRPAGE (SPI0_PAGE);

249
  SPIF = 0;

250
  SPI0DAT = (0x0D<<1);  // BitframingReg

251
  while (!SPIF);  // wait until transmission complete

252
  

253
  SPIF = 0;

254
  SPI0DAT = 0x87;  // StartSend, TxLastBits

255
  while (!SPIF);  // wait until transmission complete

256
  

257
  SET_SFRPAGE (CONFIG_PAGE);

258
  CS_RFID = 1;

259
  

260
  for(w_i=0;w_i<60000;w_i++);

261
                                              

262
  CS_RFID = 0;

263
  

264
  SET_SFRPAGE (SPI0_PAGE);

265
  SPIF = 0;

266
  SPI0DAT = (0x80|(0x06<<1));  // ErrorReg Register

267
  while (!SPIF);  // wait until transmission complete

268
  

269
  SPIF = 0;

270
  SPI0DAT = 0x00;  // error bits show ing the error status of the last command executed

271
  while (!SPIF);  // wait until transmission complete

272
  buf[6] = SPI0DAT;

273
  

274
  SET_SFRPAGE (CONFIG_PAGE);

275
  CS_RFID = 1;

276
  

277
  CS_RFID = 0;

278
                        

279
  SET_SFRPAGE (SPI0_PAGE);

280
  SPIF = 0;

281
  SPI0DAT = (0x80|(0x0A<<1));  // Read FIFOLevel

282
  while (!SPIF);  // wait until transmission complete

283
  

284
  SPIF = 0;

285
  SPI0DAT = 0x00;  // Read FIFOLevel

286
  while (!SPIF);  // wait until transmission complete

287
  buf[7] = SPI0DAT;

288
  

289
  SET_SFRPAGE (CONFIG_PAGE);

290
  CS_RFID = 1;

291
  i++;

292
}

293


294
if(buf[7] != 0x02)

295
{

296
  cmd_len=3;

297
  break; // abbrechen, falls kein Tag im RF-Feld erkannt wurde

298
}

299


300
// Antwort des erkannten Tags aus dem FIFO lesen

301
for(i=0; i<buf[7]; i++)

302
{

303
  CS_RFID = 0;

304
  

305
  SET_SFRPAGE (SPI0_PAGE);

306
  SPIF = 0;

307
  SPI0DAT = (0x80|(0x09<<1));  // Read FIFO

308
  while (!SPIF);  // wait until transmission complete

309
  

310
  SPIF = 0;

311
  SPI0DAT = 0x00;  // Byte

312
  while (!SPIF);  // wait until transmission complete

313
  buf[8+i] = SPI0DAT;

314
  

315
  SET_SFRPAGE (CONFIG_PAGE);

316
  CS_RFID = 1;

317
}

318


319
// Bis hier hin läuft alles ganz sauber, aber ab jetzt weis ich nicht mehr weiter.

320


321
//Flush FIFO

322
CS_RFID = 0;

323
  

324
SET_SFRPAGE (SPI0_PAGE);

325
SPIF = 0;

326
SPI0DAT = (0x0A<<1);  // Flush FIFO

327
while (!SPIF);  // wait until transmission complete

328


329
SPIF = 0;

330
SPI0DAT = 0x80;  // Flush FIFO

331
while (!SPIF);  // wait until transmission complete

332


333
SET_SFRPAGE (CONFIG_PAGE);

334
CS_RFID = 1;

335


336
//Enable CRC-checking for Tx

337
CS_RFID = 0;

338
  

339
SET_SFRPAGE (SPI0_PAGE);

340
SPIF = 0;

341
SPI0DAT = (0x12<<1);  // TxModeReg register

342
while (!SPIF);  // wait until transmission complete

343


344
SPIF = 0;

345
SPI0DAT = 0x80;  // enable CRC in Tx

346
while (!SPIF);  // wait until transmission complete

347


348
SET_SFRPAGE (CONFIG_PAGE);

349
CS_RFID = 1;

350


351
//Enable CRC-checking for Rx

352
CS_RFID = 0;

353
  

354
SET_SFRPAGE (SPI0_PAGE);

355
SPIF = 0;

356
SPI0DAT = (0x13<<1);  // RxModeReg register

357
while (!SPIF);  // wait until transmission complete

358


359
SPIF = 0;

360
SPI0DAT = 0x80;  // enable CRC in Rx

361
while (!SPIF);  // wait until transmission complete

362


363
SET_SFRPAGE (CONFIG_PAGE);

364
CS_RFID = 1;

365


366
// Da hier der Versuch der Anticollision gescheitert ist wird

367
// an dieser Stelle weitergemacht mit direktem READ durch

368
// Abfragen der Adresse 0, was die 2te Möglichkeit laut Datenblatt sein soll

369
// READ from Address 0

370
CS_RFID = 0;

371
  

372
SET_SFRPAGE (SPI0_PAGE);

373
SPIF = 0;

374
SPI0DAT = (0x09<<1);  // Write FIFO

375
while (!SPIF);  // wait until transmission complete

376


377
SPIF = 0;

378
SPI0DAT = 0x30;  // READ Command

379
while (!SPIF);  // wait until transmission complete

380
                    

381
SET_SFRPAGE (CONFIG_PAGE);

382
CS_RFID = 1;

383


384
CS_RFID = 0;

385
  

386
SET_SFRPAGE (SPI0_PAGE);

387
SPIF = 0;

388
SPI0DAT = (0x09<<1);  // write FIFO

389
while (!SPIF);  // wait until transmission complete

390


391
SPIF = 0;

392
SPI0DAT = 0x00;  // Address

393
while (!SPIF);  // wait until transmission complete

394
                    

395
SET_SFRPAGE (CONFIG_PAGE);

396
CS_RFID = 1;

397


398
CS_RFID = 0;

399
  

400
SET_SFRPAGE (SPI0_PAGE);

401
SPIF = 0;

402
SPI0DAT = (0x80|(0x0A<<1));  // Read FIFOLevel

403
while (!SPIF);  // wait until transmission complete

404


405
SPIF = 0;

406
SPI0DAT = 0x00;  // Read FIFOLevel

407
while (!SPIF);  // wait until transmission complete

408
buf[10] = SPI0DAT;

409


410
SET_SFRPAGE (CONFIG_PAGE);

411
CS_RFID = 1;

412
                      

413
CS_RFID = 0;

414


415
SET_SFRPAGE (SPI0_PAGE);

416
SPIF = 0;

417
SPI0DAT = (0x0D<<1);  // BitframingReg

418
while (!SPIF);  // wait until transmission complete

419


420
SPIF = 0;

421
SPI0DAT = 0x87;  // StartSend, TxLastBits

422
while (!SPIF);  // wait until transmission complete

423


424
SET_SFRPAGE (CONFIG_PAGE);

425
CS_RFID = 1;

426
  

427
for(w_i=0;w_i<60000;w_i++); // Kurze Wartepause, damit der Tag auch was senden kann

428


429
CS_RFID = 0;

430


431
SET_SFRPAGE (SPI0_PAGE);

432
SPIF = 0;

433
SPI0DAT = (0x80|(0x06<<1));  // read ErrorReg Register

434
while (!SPIF);  // wait until transmission complete

435


436
SPIF = 0;

437
SPI0DAT = 0x00;  // error bits show ing the error status of the last command executed

438
while (!SPIF);  // wait until transmission complete

439
buf[11] = SPI0DAT;

440


441
SET_SFRPAGE (CONFIG_PAGE);

442
CS_RFID = 1;

443
  

444
CS_RFID = 0;

445
                      

446
SET_SFRPAGE (SPI0_PAGE);

447
SPIF = 0;

448
SPI0DAT = (0x80|(0x0A<<1));  // Read FIFOLevel

449
while (!SPIF);  // wait until transmission complete

450


451
SPIF = 0;

452
SPI0DAT = 0x00;  // Read FIFOLevel

453
while (!SPIF);  // wait until transmission complete

454
buf[12] = SPI0DAT; // hier sollte jetzt eigentlich die empfangene Anzahl von 16 Bytes stehen, aber es kommt immer 0, wie auch beim Versuch der Anticollision

455


456
// Ich habe auch schon versucht die Wartezeit zu verlängern, was aber zu keinem anderen Ergebnis geführt hat

457


458
SET_SFRPAGE (CONFIG_PAGE);

459
CS_RFID = 1;

460


461


462
for(i=0; i<buf[12]; i++) // hier sollten die Daten ausgelesen werden, die vom Tag geschickt wurden

463
{

464
  CS_RFID = 0;

465
  

466
  SET_SFRPAGE (SPI0_PAGE);

467
  SPIF = 0;

468
  SPI0DAT = (0x80|(0x09<<1));  // Read FIFO

469
  while (!SPIF);  // wait until transmission complete

470
  

471
  SPIF = 0;

472
  SPI0DAT = 0x00;  // Byte

473
  while (!SPIF);  // wait until transmission complete

474
  buf[13+i] = SPI0DAT;

475
  

476
  SET_SFRPAGE (CONFIG_PAGE);

477
  CS_RFID = 1;

478
}


MfG, Daniel
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Maxx Gast #3317813
Lesenswert?
• ▲
▼ 
Ich sehe nirgends wo du denn das SEL/SELECT Kommando (9x + nvb + 
uidPattern) in den FIFO schreibst.

Der Code ist ledier etwas unübersichtlich dass ich das aber auch 
übersehen habe. Funktionen für SendRequest(..) und ReadResponse(..) 
wären ganz nett.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Daniel B. OP #3317864
Lesenswert?
• ▲
▼ 
Maxx schrieb:
> Ich sehe nirgends wo du denn das SEL/SELECT Kommando (9x + nvb +
> uidPattern) in den FIFO schreibst.
>
> Der Code ist ledier etwas unübersichtlich dass ich das aber auch
> übersehen habe. Funktionen für SendRequest(..) und ReadResponse(..)
> wären ganz nett.

Hallo Maxx,

das SELECT habe ich im Code nicht mehr gemacht, aber ich habe anstelle 
von SELECT jetzt direkt ein READ versucht, weil das ja die 2. Option 
sein soll, die laut Datenblatt (S. 7 Fig. 5) möglich ist.
Das READ Kommando findest du im unteren Drittel des Codes direkt nach 
folgendem Kommentar:
1
// Da hier der Versuch der Anticollision gescheitert ist wird

2
// an dieser Stelle weitergemacht mit direktem READ durch

3
// Abfragen der Adresse 0, was die 2te Möglichkeit laut Datenblatt sein soll

4
// READ from Address 0


Der Effekt ist bei SELECT wie auch bei READ der gleiche, ich erhalte 
einfach keine Antwort vom Tag.

@Robert S. :  Ich habe ein Oszi zur verfügung, ich werde es mir mal 
Ansehen.


MfG, Daniel
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Daniel B. OP #3323322
Lesenswert?
• ▲
▼ 
Hier ist der Code noch mal hoffentlich etwas verständlicher:


1
SET_SFRPAGE (CONFIG_PAGE);

2
CS_RST_RFID = 1;

3


4
for(i=0; i<64; i++)

5
{

6
  buf[5+i] = 0x00;

7
}

8


9
SET_SFRPAGE (SPI0_PAGE);

10
SPICFG (0,0);  // CLKPOL=0, CLKPHA=0 noch nicht getestet!!!

11


12
// Set Transmit and Receiver settings

13
NFC_executeCommand(CMD_SOFTRESET);

14
NFC_setRegister(0x14, 0x83); // TxControlReg - InvTx2On=1, Tx2RFEn, Tx1RFEn

15
NFC_setRegister(0x15, 0x40); // TxASKReg - Force100ASK

16
NFC_setRegister(0x17, 0x88 /*0x84*/); // RxSelReg - RxWait[5:0] = 0

17
NFC_setRegister(0x18, 0x55); // RxThresholdReg - MinLevel, CollLevel

18
NFC_setRegister(0x19, 0x4D); // DemodReg

19
NFC_setRegister(0x23, 0x6F); // GsNLoadMod

20
NFC_setRegister(0x24, 0x26); // ModwidthReg - Modwidth    

21
NFC_setRegister(0x25, 0x8F); // TxBitPhase

22
NFC_setRegister(0x26, 0x59); // RFCfgReg - RxGain

23
NFC_setRegister(0x27, 0xF4); // GsNReg - CWGsN, ModGsN

24
NFC_setRegister(0x28, 0x3F); // CWGsPReg - CWGsP

25
NFC_setRegister(0x29, 0x11); // ModGsPReg - ModGsP

26


27
NFC_executeCommand(CMD_TRANSCEIVE);

28


29
//Write Request code 0x26 = REQA or 0x52 = WUPA to FIFO

30
// and wait for an answer only 100 times, then stop

31
buf[7] = 0x00;

32
i=0;

33


34
while(buf[7] != 0x02 && i<100)

35
{

36
  NFC_setRegister(0x0A, 0x80); // Flush FIFO

37
  

38
  NFC_setByteInFIFO(0x26); // REQA - Request code

39
  //NFC_setByteInFIFO(0x52); // WUPA - Request code

40
                        

41
  buf[5] = NFC_getFIFOLevel();

42
  

43
  NFC_setRegister(0x0D, 0x87); // BitframingReg - StartSend, TxLastBits

44
                      

45
  for(w_i=0;w_i<60000;w_i++);

46
                                              

47
  CS_RFID = 0;

48
  

49
  buf[6] = NFC_getRegister(0x06); // ErrorReg

50
  

51
  buf[7] = NFC_getFIFOLevel();

52
  

53
  i++;

54
}

55


56


57


58
if(buf[7] < 0x02)

59
{

60
  cmd_len=3;

61
  break;

62
}

63


64


65
for(i=0; i<buf[7]; i++)

66
{

67
  buf[8+i] = NFC_getByteFromFIFO();

68
}

69
send(0x00, buf[7]);

70


71


72


73


74
// ANTICOLLISION of cascade level 1

75
buf[8+buf[7]+1] = 0x00;

76
i=0;

77


78
while(buf[8+buf[7]+1] < 0x05 && i<100)

79
{

80
  NFC_setRegister(0x0A, 0x80); // Flush FIFO

81


82
  NFC_setByteInFIFO(0x93); // ANTICOLLISION - Request code

83
  NFC_setByteInFIFO(0x28); // Parameter

84
  

85
  buf[8+buf[7]] = NFC_getFIFOLevel();

86
  

87
  NFC_setRegister(0x0D, 0x87); // BitframingReg - StartSend, TxLastBits

88
  

89
  for(w_i=0;w_i<60000;w_i++);

90
  

91
  buf[8+buf[7]+1] = NFC_getFIFOLevel();

92
  

93
  buf[8+buf[7]+2] = NFC_getRegister(0x06); // ErrorReg

94
  

95
  i++;

96
}

97


98


99


100
if(buf[8+buf[7]+1] < 0x05)

101
{

102
  cmd_len=3;

103
  break;

104
}

105


106
for(i=0; i<buf[8+buf[7]+1]; i++)

107
{

108
  buf[8+buf[7]+3+i] = NFC_getByteFromFIFO();

109
}

110
send(0x00, buf[8+buf[7]+1]);


MfG, Daniel
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Ralf Gast #3324022
Lesenswert?
• ▲
▼ 
Hi Daniel,

> Nach einer API habe ich auch geschaut und habe auch eine gefunden,
> nur ist mir bisher noch nicht klar, wie ich diese einbinden soll, da ich
> nicht den vollen Funktionsumfang benötige.
Du musst sie ja nicht unbedingt einbinden, es reicht ja auch einfach, 
wenn du darin schaust, wie etwas gelöst ist :)
Bisweilen ist ja auch gleich Beispielcode mit dabei. Ansonsten gibt's 
glaub ich auch noch diverse PC-Software von NxP, mit der ein MFRC523 
direkt angesprochen werden kann, inklusive Ausgabe der jeweiligen 
Kommandos, d.h. da kannst du auch "spicken".

Ralf
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren