MFRC522单片机驱动源码 IO模拟spi接口 调试通过能正常读到M1卡

Diabloa

MFRC522单片机驱动源码 IO模拟spi接口 调试通过能正常读到M1卡
' l6 g: o: ]& V调试通过的RC522驱动源码，使用IO模拟spi接口。测试后能正常读到M1卡
- y6 ], U8 x! e7 C' g/ i. d% s" v单片机源程序：
#include "MFRC522.h"
#include "nRF_delay.h"
8 u' ?( u# ]8 S6 I( o6 b/ z#include "nrf_gpio.h"
#include <stdint.h>
/ X. ?6 [  ?* B3 F+ s2 u#include <string.h>
) P+ n0 v3 v& Z#include <stdio.h>
0 `; l. b& O6 i9 C! a) Z( G# L//#include "simple_uart.h"
extern uint32_t *p_spi_base_address;
4 x# i& N' W' E/ h# c- xtypedef  uint8_t u8;
typedef  uint16_t u16;
( ], u4 y6 A0 x  D3 \) h) w1 c* D#define _MFRC_SOFT_SPI
4 B4 J3 N+ T; M/ e2 h1 S#define Set_MFRC_CS(x)                x ? nrf_gpio_pin_set(SPI_PSELSS0):nrf_gpio_pin_clear(SPI_PSELSS0)
#define Set_MFRC_SCK(x)        x ? nrf_gpio_pin_set(SPI_PSELSCK0):nrf_gpio_pin_clear(SPI_PSELSCK0)
) x" ~5 I8 `9 }! m#define Set_MFRC_MOSI(x)        x ? nrf_gpio_pin_set(SPI_PSELMOSI0):nrf_gpio_pin_clear(SPI_PSELMOSI0)
% o6 E" D$ n' q) s1 C#define MFRC_MISO_STATUS()        nrf_gpio_pin_read(SPI_PSELMISO0)
//#define Set_MFRC_RST(x)                x ? HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_SET):HAL_GPIO_WritePin(GPIOC, GPIO_PIN_1, GPIO_PIN_RESET);


: U. e; \" n7 f) s4 x, H% Tvoid MFRC_Delay(u16 Delay_Time)
6 Q9 |8 @! B( e: I{
  u16 i, j;
1 L$ c. Y. d; }% I  for (i = 40; i > 0; i--)
9 p! O! P, P; K. S, O* \  {
    for (j = Delay_Time; j > 0; j--);
  }
}
#ifndef _MFRC_SOFT_SPI  
9 l8 r% n7 e* X# f8 ~8 A4 V# Rvoid SPI_TxByte(u8 Dat)
$ G3 e# Q8 v, E8 ^/ Y; V{
2 r. @% F1 E+ o0 w$ n* P" O        uint8_t state;
& e' j  @9 E- Q  f8 ^+ v- q) Z" h* o        state = spi_master_tx(p_spi_base_address, Dat);           
        if(state != true)
                state = true;
+ F3 B4 {; p0 z) X, S1 O}
( ^# ~5 q$ @; Y1 Z7 N/ @3 t3 K+ O$ y3 W

# |2 s% B# b7 xu8 SPI_RxByte(void)
' Y7 h' p$ b$ s( X$ A{
/ O! q0 G: j+ Z        uint8_t state;
  state = spi_master_rx(p_spi_base_address) ;
  return state;                             
) H$ G$ D% X3 n}
& u( J7 C8 ]2 q  g1 T#endif
/*
# k( x6 L4 j. J2 ~, m/////////////////////////////////////////////////////////////////////
//?    ?:?RC632???
//????:Address[IN]:?????
" w7 e& T+ z( x% E% U- h//?    ?:????
/////////////////////////////////////////////////////////////////////
unsigned char ReadRawRC(unsigned char Address)
* [/ j6 ~, M: h8 L; d2 B{
: A+ x) \1 }% m- \" {8 E! m    unsigned char ucResult=0;
                uint8_t ucAddr;
1 g- U7 L" v5 {                uint8_t tx_data[2]={0x00,0x00};
                uint8_t rx_data[2]={0x00,0x00};
. i4 p: N9 g2 w, d$ p0 ^0 R) `, |                ucAddr = ((Address << 1) & 0x7E) | 0x80;
" x& u- B+ K* F                tx_data[0] = ucAddr;
* F! }5 c0 l* r                spi_master_tx_rx(p_spi_base_address, 1, tx_data, rx_data);
                ucResult = rx_data[0];
    return ucResult;
7 U* X$ H6 x# _# K  o' w}
% r3 [! d( q' `) \) M
* f% G! B: f' ~$ ]; v7 x/ G
/////////////////////////////////////////////////////////////////////
7 d+ ~9 F$ c2 B& {7 W//?    ?:?RC632???
; n! e. O7 F' h6 q$ R3 f3 U//????:Address[IN]:?????
. ]7 _8 v1 J1 b! K' U( Q: l, L//          value[IN]:????
  V+ b" E% x' {: _4 P. n/////////////////////////////////////////////////////////////////////
void WriteRawRC(unsigned char Address, unsigned char value)
{  
0 M+ s6 {1 q; h. E                uint8_t tx_data[2]={0x00,0x00};
3 P0 L$ F7 `. q* p$ F9 b# E' J  o' @                uint8_t rx_data[2]={0x00,0x00};
% `6 ]3 ]9 s( g' `, s8 a                uint8_t ucAddr;
                ucAddr = ((Address << 1) & 0x7E);
                tx_data[0] = ucAddr;
: G2 t8 C: e  q! Z                tx_data[1] = value;
                spi_master_tx_rx(p_spi_base_address, 2, tx_data, rx_data);
6 K1 [2 I$ _5 O3 N}*/

' ~2 `2 y. F: V2 E, w
/////////////////////////////////////////////////////////////////////
, v& E/ i4 r& Q" Y& ]0 I//功    能：读RC632寄存器
//参数说明：Address[IN]:寄存器地址
//返    回：读出的值
+ z, o6 h, @8 ?3 [' _/////////////////////////////////////////////////////////////////////
static u8 ReadRawRC(u8 Address)
{
  u8 ucAddr;
( _  Z# w- Y8 b( k5 _1 d/ p) x  u8 ret = 0;
#ifdef _MFRC_SOFT_SPI
- S. ~0 P+ F# Q5 ~' o5 Z; E7 M! e% E  u8 i;
  Set_MFRC_SCK(0);
; `( }+ j% C8 n# ^5 z" |0 j# Q6 A#endif  
  
( c  }: B* T& x2 t( O1 K  Set_MFRC_CS(0);
5 o- A& x7 p8 y4 t
; N/ R" O4 N* r5 w
; P4 \4 x" M. H0 y1 n8 ]/ {) d  ucAddr = ((Address << 1) & 0x7E) | 0x80;
$ M4 s; D2 e' y" P' O1 j! h  {#ifdef _MFRC_SOFT_SPI  
  for(i=8; i>0; i--)
* ~( Z5 f# [% X9 q  {
9 B( Z; g3 r; X    Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
, U1 O/ J& R) d8 S: s    Set_MFRC_SCK(1);
0 ~" u. ^+ l4 Z    ucAddr <<= 1;
9 w& T) k6 C5 E) K5 t, p* S    Set_MFRC_SCK(0);
  }
' o0 u9 D$ P& \2 D& k( ]

  for(i=8; i>0; i--)
  {
( |7 j" _; c. v5 S9 f    Set_MFRC_SCK(1);
    ret <<= 1;
; e, ~, C6 z( @. l9 n- R    ret |= MFRC_MISO_STATUS();
1 p$ D- \2 z) B3 U    Set_MFRC_SCK(0);
  }
#else
) s/ I! h# O, g! Z& r# h  SPI_TxByte(ucAddr);
  ret = SPI_RxByte();
0 l0 B- }  s* O        
#endif
  Set_MFRC_CS(1);
#ifdef _MFRC_SOFT_SPI
  Set_MFRC_SCK(1);
8 @# Y9 E' V1 E" [; R/ R#endif
! {3 W. f5 u$ b4 a        printf("REG ADDR:0x%x  Val: 0x%02x\r\n",Address,ret);
  return ret;
}

' A  N' N; l/ o% y% A. e
" b" S' d! c  D' y7 }% O! o; s* i/////////////////////////////////////////////////////////////////////
//功    能：写RC632寄存器
//参数说明：Address[IN]:寄存器地址
//          value[IN]:写入的值
9 q  t- \, q' r1 o! O/////////////////////////////////////////////////////////////////////
void WriteRawRC(u8 Address, u8 value)
{
2 U  Y! {; E+ Q4 f) r4 [  u8 ucAddr;
#ifdef _MFRC_SOFT_SPI
  u8 i;
  Set_MFRC_SCK(0);
#endif
  Set_MFRC_CS(0);
* D8 h0 B; J" K4 l! o+ S
- Z& k+ {7 k4 B4 l2 C
  ucAddr = ((Address << 1) & 0x7E);
#ifdef _MFRC_SOFT_SPI
% Z9 [9 V" C( V9 j* g, B/ d- [* f        printf("---write---REG ADDR:0x%x  Val: 0x%02x\r\n",Address,value);
  for(i=8; i>0; i--)
7 Z6 {, i+ o' q- Y9 F5 J2 M' i  {
' U* M$ W: }, J( I    Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
$ k3 E/ t! C* k8 j; ]0 j# _$ c    Set_MFRC_SCK(1);
3 U: G& `0 X1 ^9 Q1 ^7 z* `% A    ucAddr <<= 1;
  q' M" ]8 @( d- y/ b    Set_MFRC_SCK(0);
  }
1 B+ V/ A+ k' v5 t* B& p% l& ~
7 ~$ H7 L6 b- ~2 O' A: Q, H+ t, M
  for(i=8; i>0; i--)
) R, F; i1 c* h) }+ }! B  {
    Set_MFRC_MOSI((value & 0x80) == 0x80);
- R( P% D: {1 S& Z    Set_MFRC_SCK(1);
    value <<= 1;
3 |; ?9 k! _. H; B    Set_MFRC_SCK(0);
+ R7 }. M3 t0 p. K  }
- U6 _2 H3 _$ j#else
  SPI_TxByte(ucAddr);
' ^8 h, }+ l& r7 J4 W" c' G+ \  SPI_TxByte(value);
+ Q4 t9 `8 f# @8 u+ P$ n( L: Y        printf("---write---REG ADDR:0x%x  Val: 0x%x\r\n",Address,value);
5 H) s: ?% \. _2 M" Z#endif
$ J/ {. o) k3 Q1 Y0 x8 K) y  Set_MFRC_CS(1);
#ifdef _MFRC_SOFT_SPI
  Set_MFRC_SCK(1);
#endif
        
}
1 `5 S( \* [# c* @* Q! L7 q

/////////////////////////////////////////////////////////////////////
$ z8 u  B7 x* f  ]//功    能：清RC522寄存器位
4 T4 D% l5 v6 [% p- X% ~, S+ ~" J: h//参数说明：reg[IN]:寄存器地址
//          mask[IN]:清位值
- Z7 X( N1 e, {% `, d7 O/////////////////////////////////////////////////////////////////////
static void ClearBitMask(u8 reg, u8 mask)
  _+ O  g: G/ N/ M{
        u8 tmp = 0x0;
; r5 X$ E+ {$ {' Q9 l        tmp = ReadRawRC(reg);
( n7 _* I! ^, H$ V# e9 c* v        WriteRawRC(reg, tmp & ~mask);  // clear bit mask
0 F0 A: I7 w8 d* Y/ Z# e}

( t0 }7 _9 T9 G7 @  u1 Z- G. w8 I
$ S3 l: k0 }$ s6 D$ ~+ p/////////////////////////////////////////////////////////////////////
) Z4 `9 p$ `( O//功    能：置RC522寄存器位
2 U. w# S. l1 e0 ^. d2 ?//参数说明：reg[IN]:寄存器地址
- j5 H8 V5 ^8 ~2 T' p5 A  g//          mask[IN]:置位值
/////////////////////////////////////////////////////////////////////
static void SetBitMask(u8 reg, u8 mask)
{
2 a$ l5 N" c9 H. `( L% m        u8 tmp = 0x0;
- x- r8 t$ m9 [        tmp = ReadRawRC(reg);
+ ^8 q9 c: E; J8 X4 J/ }' |        WriteRawRC(reg, tmp | mask);  // set bit mask
! V. k( q( A, N9 `}
- s3 U! _9 Z8 `7 @; L



2 n: j/ \/ `, F//开启天线  
  f& r; ?/ b+ n- w* p: @1 ?' b5 a7 E//每次启动或关闭天险发射之间应至少有1ms的间隔
void PcdAntennaOn(void)
. H" n9 ^( X2 N/ N* A4 l; T, H{
        u8 i;
- B; z' c' h3 g" F        i = ReadRawRC(TxControlReg);
        if (!(i & 0x03))
        {
* H0 J  d2 ?. U' [+ L3 y* `                SetBitMask(TxControlReg, 0x03);
3 V  {  l$ x' g! g5 {        }
}
1 n9 a3 x8 w( _% R
2 J' ]) s! o, B; X
//关闭天线
void PcdAntennaOff(void)
{
4 U/ P# c: F8 z        ClearBitMask(TxControlReg, 0x03);
! k6 ^; o0 ?1 M$ [7 w}
0 P4 T1 V. j- U8 o4 w1 n+ F* Y1 S+ p

2 I! y1 l5 x8 _& x) S( z6 `/////////////////////////////////////////////////////////////////////
//功    能：通过RC522和ISO14443卡通讯
9 b, P2 e- |  `4 Z$ l: P7 _//参数说明：Command[IN]:RC522命令字
//          pIn [IN]:通过RC522发送到卡片的数据
5 F" t: X, K* k( F2 w5 y( i4 }5 O//          InLenByte[IN]:发送数据的字节长度
: a; ]( c2 g3 s+ Q* u9 f//          pOut [OUT]:接收到的卡片返回数据
% i" n, a. s6 X$ s2 r+ v//          *pOutLenBit[OUT]:返回数据的位长度
! \# n$ _; y& N% T6 v9 ~% _3 a; G/////////////////////////////////////////////////////////////////////
) S* o' e  a2 I" ]#define MAXRLEN                       18
1 x0 }6 \% E5 T6 ?- L; zstatic char PcdComMF522(unsigned char Command,
                 unsigned char *pInData,
                 unsigned char InLenByte,
                 unsigned char *pOutData,
                 unsigned int  *pOutLenBit)
" a( g" d; m2 a& ~8 A# q4 B$ \{
2 k9 \0 b! ^' u) C        char status = MI_ERR;
        unsigned char irqEn   = 0x00;
1 o& G+ I3 x4 t; ~; }# }+ m        unsigned char waitFor = 0x00;
        unsigned char lastBits;
        unsigned char n;
        unsigned int i;

6 J- n/ n. @/ w  P, b/ u; ~
        switch (Command)
+ p+ D& [7 s; C2 Z+ N        {
        case PCD_AUTHENT:
                irqEn = 0x12;
- w6 M8 {) n3 e, |                waitFor = 0x10;
( ^( @; E1 R$ r                break;
) J1 w3 a) c" w2 I$ |        case PCD_TRANSCEIVE:
3 Z$ n+ y/ P+ b% @- |1 U; ^4 o" ~                irqEn = 0x77;
3 n/ e& _0 v3 O8 Z                waitFor = 0x30;
: O1 E4 M% ~. I. ^2 ]# x! ^                break;
        default:
                break;
        }
* q% V9 c+ m  X4 J7 P; T, `! W

) ~  U" ~- o- v% A        WriteRawRC(ComIEnReg, irqEn | 0x80);
        ClearBitMask(ComIrqReg, 0x80);
! d- r. O9 X% N$ n/ ~        WriteRawRC(CommandReg, PCD_IDLE);
7 |. \: ]6 @! _1 m  Z8 U. a        SetBitMask(FIFOLevelReg, 0x80);
3 f1 q7 X% h/ e) f8 P
/ ^2 U( ^5 F+ I) ~& {6 z: ]7 n
        for (i = 0; i < InLenByte; i++)
        {
                WriteRawRC(FIFODataReg, pInData);
        }
2 ?5 ^, V5 H% w) V        WriteRawRC(CommandReg, Command);
) |' \- w3 L5 q) c1 J+ i
! d1 m5 [! I2 p6 d. ^% C
        if (Command == PCD_TRANSCEIVE)
        {
! [( C' y" \9 ?/ R" j7 ~. z                SetBitMask(BitFramingReg, 0x80);
        }
" O: ?# r, g/ R9 R

; r; T7 A& {$ E2 s7 L        i = 3000;//800;
0 |5 W' p4 e* t" [# T        do
$ f5 w6 y1 [9 \+ p        {
/ G4 Y4 |- H/ y/ {- [6 y" U# o                n = ReadRawRC(ComIrqReg);
                i--;
/ d, g' O0 N' @) k" \; e0 U7 N' |        } while ((i != 0) && !(n & 0x01) && !(n & waitFor));
        ClearBitMask(BitFramingReg, 0x80);


        if (i != 0)
        {
7 f0 E0 P$ d& o0 n+ S7 r                if (!(ReadRawRC(ErrorReg) & 0x1B))
                {
                        status = MI_OK;
                        if (n & irqEn & 0x01)
$ [7 {& i4 o) ~/ k3 D6 [: D. @5 m                        {
                                status = MI_NOTAGERR;
                        }
1 Q. i  D0 K1 p* f: d                        if (Command == PCD_TRANSCEIVE)
9 F8 Q% z; b& H/ S                        {
* U5 I, t  _* K+ J' p* {7 H2 j6 p                                n = ReadRawRC(FIFOLevelReg);
                                lastBits = ReadRawRC(ControlReg) & 0x07;
$ I1 a# S/ i. N0 C( ^. m3 [                                if (lastBits)
: W) J+ q; O5 B& V3 T                                {
( c" b/ G8 d; h1 x! ]  c0 @                                        *pOutLenBit = (n - 1) * 8 + lastBits;
                                }
                                else
1 a9 z5 \& W& f) M$ _6 T                                {
  |0 r* s" j$ u3 s7 D                                        *pOutLenBit = n * 8;
                                }
                                if (n == 0)
                                {
5 a! k$ B% p* E% s                                        n = 1;
                                }
                                if (n > MAXRLEN)
                                {
                                        n = MAXRLEN;
2 P2 B0 a1 s* y# A4 Y! \, n                                }
                                for (i = 0; i < n; i++)
                                {
) _9 w5 ?$ f- Q' ^+ N                                        pOutData = ReadRawRC(FIFODataReg);
; k/ ^6 q* j$ R3 ^9 a+ o/ l                                }
: Q( ~! C1 e& Z2 ?) g3 [                        }
                }
                else
                {
6 s) q  @& e$ D# r! V- D                        status = MI_ERR;
! u, n  V- x4 Y! K5 c2 S                }
# A" z# |) n2 v3 V3 N9 P: t4 J1 G        }
; q% K: p# D0 v. k        SetBitMask(ControlReg, 0x80);           // stop timer now
# K+ [% X# g( n4 G! D        WriteRawRC(CommandReg, PCD_IDLE);
        return status;
}
, z( y" ~0 d) M, M5 [


7 D  d) s& w) j$ ^/ D
/////////////////////////////////////////////////////////////////////
, {' p5 u9 {) U+ d. e' v//功    能：复位RC522
/ `* B- k+ h4 ~3 V% `$ U+ S//返    回: 成功返回MI_OK
8 `; I- k9 E6 w/////////////////////////////////////////////////////////////////////
char PcdReset(void)
{
        nrf_gpio_pin_set(SPI_RST);
6 Z- u: D' E% y' d) Q        MFRC_Delay(10);  
        nrf_gpio_pin_clear(SPI_RST);
        MFRC_Delay(60000);  
        nrf_gpio_pin_set(SPI_RST);
        MFRC_Delay(500);  
* q4 }7 j1 H8 C9 s        WriteRawRC(CommandReg, PCD_RESETPHASE);
        MFRC_Delay(2000);  
, _7 y2 \, T  M; a/ [' a
- Y& g. @/ R- k
        WriteRawRC(ModeReg, 0x3D);            
        WriteRawRC(TReloadRegL, 30);            
        WriteRawRC(TReloadRegH, 0);
; I! t* b' v: S' _        WriteRawRC(TModeReg, 0x8D);
6 L3 q2 f$ R/ \. ~/ @        WriteRawRC(TPrescalerReg, 0x3E);
        WriteRawRC(TxAutoReg, 0x40);
5 I! N0 M- [$ _& L7 M6 K% [        
        ClearBitMask(TestPinEnReg, 0x80);         //off MX and DTRQ out
        WriteRawRC(TxAutoReg, 0x40);

+ _# r) x$ g0 Q7 O
        return MI_OK;
3 F. x7 x2 `& V$ o}        
: s4 R, q' [8 ^* S0 L0 Z
& h& r7 n% z- J4 f
/////////////////////////////////////////////////////////////////////
//用MF522计算CRC16函数
/////////////////////////////////////////////////////////////////////
void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
0 i' D/ j3 o. S( h; p: o8 N! T# [{
. R- P4 A$ S. b  s    unsigned char i,n;
% Z6 k5 H( r2 `1 H8 t! O        
# u# K/ n6 r) a( X2 o/ O0 B    ClearBitMask(DivIrqReg,0x04);
3 ~* o3 D4 e! J) \    WriteRawRC(CommandReg,PCD_IDLE);
0 {* J1 M! g2 W, p    SetBitMask(FIFOLevelReg,0x80);
8 N! ?% j8 U7 `/ M& \/ T4 [    for (i=0; i<len; i++)
8 o. G; N2 P5 j' f3 E    {   
        WriteRawRC(FIFODataReg, *(pIndata+i));  
    }
9 U9 E/ f. V/ P5 \1 Q# e1 j# m    WriteRawRC(CommandReg, PCD_CALCCRC);
    i = 0xFF;
    do
    {
+ J: I' l8 E# {' u0 R- g* Y# K        n = ReadRawRC(DivIrqReg);
1 h1 q! U. a# B1 |9 E        i--;
    }
    while ((i!=0) && !(n&0x04));
    pOutData[0] = ReadRawRC(CRCResultRegL);
- O; s4 M, z  N, e1 f+ H    pOutData[1] = ReadRawRC(CRCResultRegM);
* e3 a: V( ~& ]9 ^}

* N7 v: ^" n- B) U$ C0 K5 O7 ?
; {3 a. \1 H. V" x! Q7 a( }

//////////////////////////////////////////////////////////////////////
//设置RC522的工作方式
//////////////////////////////////////////////////////////////////////
signed char M500PcdConfigISOType(unsigned char type)
4 Z5 T: i2 |7 L' J- T1 ~9 H{
  if('A' == type)
  {
    ClearBitMask(Status2Reg,0x08);
    WriteRawRC(ModeReg,0x3D);
    WriteRawRC(RxSelReg,0x86);
    WriteRawRC(RFCfgReg,0x7F);   
    WriteRawRC(TReloadRegL,30);
    WriteRawRC(TReloadRegH,0);
    WriteRawRC(TModeReg,0x8D);
8 r5 y' n0 V+ Y1 @9 i    WriteRawRC(TPrescalerReg,0x3E);
9 p" w9 X- I) |) z. D    MFRC_Delay(10000);
    PcdAntennaOn();
  }
  else
9 X, N6 V6 `9 Q( {' N' `' C  {
    return -1;
  }
8 p/ _& ~$ M* _8 U& t        
+ J) I5 E: o) [  return MI_OK;
  z' q4 h9 u. H& M6 {6 y6 W5 @}
$ O4 A; X/ Z9 ]' z$ J. @- m

" }+ f* {3 I0 c+ v( ^/***
初始化RC522
7 H0 c% j. E4 K- X2 z1 i# j  n3 y*/
) ]4 \7 g; s' \% Y4 s
+ u1 v" _# H. P, }) Q
void MFRC522_Init(void)
{
* k: |, V: R8 H//  MFRC_GPIOConfigure();
! ]$ F8 Z* |5 L7 ?$ C        
  PcdReset();
2 u" \$ E3 }" d3 C+ {  PcdAntennaOff();
2 n1 h5 A7 P& `  S# J6 ]2 M  MFRC_Delay(2000);
  u+ p+ }$ q/ s# [0 ^/ y  PcdAntennaOn();
  M500PcdConfigISOType('A');
7 ]* e9 g) @6 M}
9 J2 |3 n4 p! v1 x

/////////////////////////////////////////////////////////////////////
//功    能：寻卡
3 S: Y( W4 a& F" q0 y! Y1 x! C* T//参数说明: req_code[IN]:寻卡方式
( O+ p: s; u% N- ]" l% t8 T( u& c5 R//                0x52 = 寻感应区内所有符合14443A标准的卡
//                0x26 = 寻未进入休眠状态的卡
2 V" ^$ T; }; Z  r( K) f//          pTagType[OUT]：卡片类型代码
//                0x4400 = Mifare_UltraLight
- \* b$ f0 i3 ?) [% V! b& q" r//                0x0400 = Mifare_One(S50)
//                0x0200 = Mifare_One(S70)
' f+ V2 c6 Y! U( N5 W4 |( O//                0x0800 = Mifare_Pro(X)
+ w, r1 y1 n8 f; J, A6 r//                0x4403 = Mifare_DESFire
//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
/ p' W# ?) [2 e6 z, z* jchar PcdRequest(u8 req_code, u8 *pTagType)
: x2 H" Z, b0 H{
% e' g  X9 @8 R+ B( i7 f1 j6 k  char status;  
        unsigned int  unLen;
        unsigned char ucComMF522Buf[MAXRLEN];


        ClearBitMask(Status2Reg, 0x08);
) z. `; T* v4 B" G( O4 z        WriteRawRC(BitFramingReg, 0x07);
: o: s/ V( u$ C        SetBitMask(TxControlReg, 0x03);
2 ~0 C0 Z% l5 m/ Z' U//   
        ucComMF522Buf[0] = req_code;
0 p8 z2 C; X# J8 A% O7 j1 D
( V" ?" c$ {6 t) i- B' G$ T  q
        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf,
                        &unLen);
9 v9 k) n% y  D  h5 j//   UART_send_byte(status);
        if ((status == MI_OK) && (unLen == 0x10))
        {
                *pTagType = ucComMF522Buf[0];
                *(pTagType + 1) = ucComMF522Buf[1];
7 ?2 c$ S2 `' _; C        }
        else
        {
4 H) ?0 ?6 W. O7 m* `          status = MI_ERR;
/ P9 H9 c0 w  }4 k! @        }
6 l/ Z' M! n8 j2 C; \" k: {

" S/ }4 z$ p9 m/ C, @- S  X        return status;
}

% G. R8 }, d9 r0 u4 F
& x+ P- U7 s5 Z

! w/ K: x5 W2 j5 d  W- N( X, T/////////////////////////////////////////////////////////////////////
2 |; @% o9 t2 U* d  _5 W//功    能：防冲撞
" s( Z/ z' l+ t6 T, N, y//参数说明: pSnr[OUT]:卡片序列号，4字节
6 F3 y, \: d5 `. W2 E; x# W6 e. L/ `//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////  
1 t- ?* q8 x/ Echar PcdAnticoll(unsigned char *pSnr)
& R& J4 b4 r( s0 b( h{
' r% g/ W3 L' F9 e: x) J    char status;
$ |2 ?7 ]  q7 D4 {3 U8 s' i    unsigned char i,snr_check=0;
0 b  y2 g" H5 I( V    unsigned int  unLen;
2 N: d! w7 J" D- h( {' o* K    unsigned char ucComMF522Buf[MAXRLEN];
   
6 c  u( Y$ F  t% m, D/ F! H; G! V
  S2 i: b8 J- }8 U. L7 V* y
    ClearBitMask(Status2Reg,0x08);
1 A& ~6 l% D- t5 Z: d9 R0 m    WriteRawRC(BitFramingReg,0x00);
: J( Z- d) K* h8 x5 W    ClearBitMask(CollReg,0x80);

1 |! M3 n9 q5 g3 G+ g  D: D9 O    ucComMF522Buf[0] = PICC_ANTICOLL1;
    ucComMF522Buf[1] = 0x20;
2 B+ x* {0 v1 D6 ]% \  a9 X3 d
9 v% w/ _$ L4 {3 D" B( ?$ m: \
% N* _7 x- P# i9 ]    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

4 S3 g' T. m: t, B. `
1 g1 Q; C3 {- X7 ^7 w/ w    if (status == MI_OK)
    {
$ v. {2 i; p. e5 r) l; K             for (i=0; i<4; i++)
1 [9 i1 J" C* D: D# Y         {   
             *(pSnr+i)  = ucComMF522Buf;
5 H0 R- g" @% l+ U             snr_check ^= ucComMF522Buf;
+ S) H& ?- q1 M  z3 R+ P2 o$ c         }
" y4 S" l+ w+ D         if (snr_check != ucComMF522Buf)
0 g7 u1 N/ N! \, e0 v$ \" _7 ]6 V1 J         {   status = MI_ERR;    }
3 Y7 Y0 L4 T+ q" h3 b! `3 I    }
7 K  i! O, o" o0 `   
    SetBitMask(CollReg,0x80);
9 }+ U# G4 B; Y9 s4 B% _0 H8 l    return status;
}


, N: w# j' j" K/////////////////////////////////////////////////////////////////////
//功    能：选定卡片
8 \# h) F3 R4 {$ B//参数说明: pSnr[IN]:卡片序列号，4字节
//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
3 I3 }7 z9 h# F0 b6 ^char PcdSelect(unsigned char *pSnr)
{
1 [, ^& ]+ C, X2 c5 \' m" n1 |    char status;
    unsigned char i;
5 P* V8 k* C4 k5 V4 h% ^4 p( ^    unsigned int  unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
" v" G. h. f; H0 E: W# J* M   
    ucComMF522Buf[0] = PICC_ANTICOLL1;
9 A0 x6 w* {2 B+ \* K    ucComMF522Buf[1] = 0x70;
    ucComMF522Buf[6] = 0;
    for (i=0; i<4; i++)
    {
            ucComMF522Buf[i+2] = *(pSnr+i);
            ucComMF522Buf[6]  ^= *(pSnr+i);
    }
    CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
  
& I) V* m: N6 b5 E  j2 u& w2 y    ClearBitMask(Status2Reg,0x08);

. U* e+ ]; X2 |  U. @6 o4 K0 i
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
" d" `% n; X* C) F   
    if ((status == MI_OK) && (unLen == 0x18))
    {   status = MI_OK;  }
    else
    {   status = MI_ERR;    }

5 E( o5 a, y- J+ w2 i) A
    return status;
3 [7 P& i, S1 y! Q9 v}


/////////////////////////////////////////////////////////////////////
//功    能：命令卡片进入休眠状态
& `# S$ m. \% b! J$ p' r; O5 i2 o//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
9 o+ ]3 m1 R6 b4 E+ u$ _char PcdHalt(void)
3 S) L( u% O7 m6 I{
//    int status;
    unsigned int  unLen;
- g# S& A" h7 N8 u6 h0 q: {2 U    unsigned char ucComMF522Buf[MAXRLEN];

8 Y- R! [! B) k0 X& r( U" K8 o
    ucComMF522Buf[0] = PICC_HALT;
' o2 k0 A3 w6 h$ J    ucComMF522Buf[1] = 0;
. U) ]$ l' @: i- L) ?) E    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

    //status =
1 g/ q% }( ?: |8 k$ F$ n    PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
+ G9 ?* g6 B) D& Y6 ~$ i

+ B7 K$ q6 }0 U; ~& `    return MI_OK;
}

/ O( v8 n1 z$ ]( P7 [& v- s- {# G* A
( I( F  K" L( S8 ]/////////////////////////////////////////////////////////////////////
- V  ~6 M2 G3 W; ^- e7 U//功    能：验证卡片密码
+ [* C' g2 G( K  g//参数说明: auth_mode[IN]: 密码验证模式
4 d2 c7 }# g; t//                 0x60 = 验证A密钥
! d9 N/ ^- f6 _//                 0x61 = 验证B密钥
% G3 N2 `4 M1 U# Q//          addr[IN]：块地址
" z& z( S. h, W* X9 E$ h9 x( A- C//          pKey[IN]：密码
' t- h' q, @2 [( f1 P//          pSnr[IN]：卡片序列号，4字节
//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////               
char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
{
    char status;
$ R" ]2 A3 b. H. ^9 z    unsigned int  unLen;
    unsigned char i,ucComMF522Buf[MAXRLEN];
9 s, A% f7 b4 Y. W
% R* n$ j8 y2 j/ S% h
$ I! f( [/ G- f+ S    ucComMF522Buf[0] = auth_mode;
    ucComMF522Buf[1] = addr;
6 W/ t" u4 T, N  B+ w    for (i=0; i<6; i++)
9 W" S$ V3 S; F& S5 q4 }" o$ N' Q* k    {    ucComMF522Buf[i+2] = *(pKey+i);   }
% V; K3 C; i  N" J1 y' ^+ Z' |3 j    for (i=0; i<6; i++)
    {    ucComMF522Buf[i+8] = *(pSnr+i);   }
5 V" z; [: l. f4 I8 F0 k //   mEMCpy(&ucComMF522Buf[2], pKey, 6);
9 _, [, a# X8 D9 ] //   memcpy(&ucComMF522Buf[8], pSnr, 4);
& k7 \5 c" Y) i1 q5 h0 K: i% |& h   
4 k6 V8 \  B( C( P; H* t, G( [    status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
* B. p8 u2 i; k! b8 l/ O    if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
5 I0 r* }" m1 V8 X. }" n, ~    {   status = MI_ERR;   }
   
    return status;
}

' _0 E. [! Q) T
/ S9 Q7 |; Y) n# `1 M: ]) f7 J/////////////////////////////////////////////////////////////////////
7 @; k8 H0 s9 P7 ?6 {6 [//功    能：读取M1卡一块数据
& m/ ^! W/ W* j! e//参数说明: addr[IN]：块地址
//          pData[OUT]：读出的数据，16字节
//返    回: 成功返回MI_OK
& Z1 Y0 m4 [  e- X# R$ E/////////////////////////////////////////////////////////////////////
; A3 ?) s1 k& X4 U5 fchar PcdRead(unsigned char addr,unsigned char *pData)
+ L; E. E8 D3 {* w6 N% t{
- D2 q' [4 D  ^5 p% }  l2 H6 Z    char status;
/ C1 z- v4 s3 |, s    unsigned int  unLen;
5 Q4 n/ x+ v9 [" A  F' L# o) s    unsigned char i,ucComMF522Buf[MAXRLEN];


    ucComMF522Buf[0] = PICC_READ;
3 l" X% D' w( e& I' s( k" K1 I, N    ucComMF522Buf[1] = addr;
2 }- e- R; h7 ~" j+ h7 {# j: e    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
7 X1 T! u) X) ]( F1 v( s2 A& J   
0 P; _/ C  o  C( M( U    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
+ I5 y9 n2 E. r    if ((status == MI_OK) && (unLen == 0x90))
//   {   memcpy(pData, ucComMF522Buf, 16);   }
& ^$ t% K* a5 }  V9 p. W    {
; b- B4 y/ |9 }) ^/ G; N" ?4 V% c        for (i=0; i<16; i++)
        {    *(pData+i) = ucComMF522Buf;   }
( p% a9 i# J. e0 t    }
    else
    {   status = MI_ERR;   }
1 @. ?1 n2 q, s, v; B   
    return status;
% c) `+ ^! y' y}

. M3 }, }$ R9 G( N" W3 O6 A7 u
/////////////////////////////////////////////////////////////////////
//功    能：写数据到M1卡一块
//参数说明: addr[IN]：块地址
//          pData[IN]：写入的数据，16字节
% a, c+ N1 G" s5 |" M! b//返    回: 成功返回MI_OK
2 B" c8 |: M5 G: {/////////////////////////////////////////////////////////////////////                  
' Z, u- h0 ]# Achar PcdWrite(unsigned char addr,unsigned char *pData)
( }6 o8 B2 J4 X: E' K{
* `1 u- u! v3 G! M, c6 \    char status;
/ P) `3 Q1 L, J9 K* n% b6 H- s    unsigned int  unLen;
    unsigned char i,ucComMF522Buf[MAXRLEN];
   
; z' k* g/ Y; }; h    ucComMF522Buf[0] = PICC_WRITE;
, S5 @* y- w; t& b# w+ T& b) i    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  t( }7 X( v6 g7 {5 ^" W$ T
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
. ~5 B* y& Y( C& Q; Q1 }) L

/ v* }( p0 ^6 E6 O1 a; G    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
& T- J! K; ]# \  R% j- p    {   status = MI_ERR;   }
        
+ y. M& v' P# t+ b3 }4 d$ K    if (status == MI_OK)
, ]" [( Q- U7 e  g" Y) S4 l    {
# l% h) J" T$ I  S1 A' m3 A9 Q: _        //memcpy(ucComMF522Buf, pData, 16);
        for (i=0; i<16; i++)
# N# O2 c6 i' ^# }! g        {    ucComMF522Buf = *(pData+i);   }
        CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);


, C3 e7 `, C6 O- x        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
$ e# a* w$ R+ [$ N% t1 D- u        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
        {   status = MI_ERR;   }
$ j$ \4 A5 [* B! ^    }
   
% H9 W: N. I4 v6 T* [& T! d    return status;
}

6 v. T! U+ A) Q9 W/ |2 W9 z! T3 J
/////////////////////////////////////////////////////////////////////
: u* E5 y7 O. e7 E//功    能：扣款和充值
//参数说明: dd_mode[IN]：命令字
3 ?1 N3 }+ i! @7 H8 ~6 ^//               0xC0 = 扣款
//               0xC1 = 充值
//          addr[IN]：钱包地址
. I0 j6 w! U) f//          pValue[IN]：4字节增(减)值，低位在前
//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////                 
char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue)
* E6 \( q! _( I; P- H& U" Y  q( v{
/ J( u9 H" P$ T% F8 ~# `" x  p    char status;
5 [* U5 a- j) d0 j) j1 C# c8 R    unsigned int  unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
, X/ X- S# d8 w- ]. G   
4 E: ?/ X: p2 \' s9 w/ q: `/ Q- K    ucComMF522Buf[0] = dd_mode;
6 f6 H/ C0 o2 h3 D! q& T    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
- u) F( L+ f" L& ]& u

3 f# ?5 L, f/ t  i# d    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
9 _2 O5 i& O8 d6 E+ n# Z# N! b    {   status = MI_ERR;   }
        
    if (status == MI_OK)
8 I" I3 c0 t/ f. d5 ]) p' G    {
8 \3 g7 f  j  A. f( Q. Q        memcpy(ucComMF522Buf, pValue, 4);
//       for (i=0; i<16; i++)
//       {    ucComMF522Buf = *(pValue+i);   }
        CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
        unLen = 0;
5 C$ h5 U7 u" G! T* K2 o1 ?7 `        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
. Y5 P3 X3 |/ j( K3 j  B        if (status != MI_ERR)
  O$ E  Q3 y. m1 m8 j2 }        {    status = MI_OK;    }
$ ~6 l9 ?/ x, Y    }
   
  G9 N: U- e+ C  d& v    if (status == MI_OK)
    {
0 q* h+ L8 [% V# H  n        ucComMF522Buf[0] = PICC_TRANSFER;
, u# W4 \. A, r4 j        ucComMF522Buf[1] = addr;
        CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
) E% U9 V4 i1 K# B5 m/ P' S$ ]# N  c   
2 V. a+ g) Q0 K" Y3 i3 V. n        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);


' z' e1 p( t; p! j        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
8 _% a/ c5 w5 j( e$ L) x, L        {   status = MI_ERR;   }
    }
    return status;
9 ]3 e9 `/ z; }8 `( C. E}
! R9 v4 d* w  }( Q$ ], C3 u
( c0 s% U2 f! e4 y) _! |# h& v
/////////////////////////////////////////////////////////////////////
//功    能：备份钱包
& `# S$ N2 J$ Q//参数说明: sourceaddr[IN]：源地址
7 P0 f& J; S1 w  g( S- z2 |) j" Z! a//          goaladdr[IN]：目标地址
) l+ Z. ^8 ~/ b# V$ S7 E//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
{
    char status;
/ q9 v* ^% O9 X9 K+ }0 A    unsigned int  unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
% J( e7 U) s& R5 z/ U  l
3 Y" d% h; f& _& T' U2 {8 s
9 ?  h7 {, F; U5 R- e) n$ |    ucComMF522Buf[0] = PICC_RESTORE;
    ucComMF522Buf[1] = sourceaddr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
$ b# e1 w5 ~8 L/ r4 ?
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
- M; V" P  ]; v7 `0 k5 {+ G- N

    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
1 T, u8 l: z1 i    {   status = MI_ERR;   }
   
$ \' w- r2 q! }6 {& }    if (status == MI_OK)
* [7 [3 M: j5 i% m9 G4 Z    {
; N3 S2 G3 H/ z8 i7 B        ucComMF522Buf[0] = 0;
5 _: `( V0 m6 D        ucComMF522Buf[1] = 0;
        ucComMF522Buf[2] = 0;
        ucComMF522Buf[3] = 0;
        CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
2 ?# g0 T, d9 w( [9 L" @
        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
        if (status != MI_ERR)
: B2 I: A- ?" u- z3 Z! a+ j        {    status = MI_OK;    }
    }
0 x+ V# [# \; z- t+ Q9 a0 U/ L
" `) a7 F: K- ]

: E1 x: k; P0 {
…………限于本文篇幅 余下代码请从论坛下载附件…………

游客，如果您要查看本帖隐藏内容请回复

4 `6 P+ f: m: {3 w1 t

Mhza

学习下