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

Diabloa

MFRC522单片机驱动源码 IO模拟spi接口 调试通过能正常读到M1卡
调试通过的RC522驱动源码，使用IO模拟spi接口。测试后能正常读到M1卡
单片机源程序：
4 g$ S8 N% G0 z% n! p4 w/ i#include "MFRC522.h"
#include "nRF_delay.h"
8 D/ o7 E+ g/ S% R+ R# m" o#include "nrf_gpio.h"
/ q* J/ ?/ S) L/ J5 E/ i#include <stdint.h>
#include <string.h>
#include <stdio.h>
//#include "simple_uart.h"
+ N: ?  g) @1 i& ^# V" Q( }; ^extern uint32_t *p_spi_base_address;
, V& i4 K9 Y; F1 [& ^& d" Ltypedef  uint8_t u8;
typedef  uint16_t u16;
  B( J5 r; N5 S$ l0 V3 J% v( g#define _MFRC_SOFT_SPI
, L% O% K9 |" D) D( n#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)
  D. R! F' r% V2 ^8 Y& R) s/ I" ]#define Set_MFRC_MOSI(x)        x ? nrf_gpio_pin_set(SPI_PSELMOSI0):nrf_gpio_pin_clear(SPI_PSELMOSI0)
#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);

7 H, F: r7 S# w
void MFRC_Delay(u16 Delay_Time)
9 p. r- o$ h4 A3 J: r2 X{
& W( O- o; T$ V  e! K' N2 g6 C  u16 i, j;
  for (i = 40; i > 0; i--)
4 W# V  r) P) U( w" ]  {
! V, z5 X0 q! R% O1 ]" [: e    for (j = Delay_Time; j > 0; j--);
  Z4 E* H* d+ @8 F0 O, z, x1 Y, G  }
7 X; |* Z$ {# a- k+ t" c}
#ifndef _MFRC_SOFT_SPI  
void SPI_TxByte(u8 Dat)
( G; o/ h3 i  z& E: y" ]" ^$ e{
        uint8_t state;
2 b3 _* e& l# j6 e/ F6 n+ f        state = spi_master_tx(p_spi_base_address, Dat);           
& d9 v; p4 w( i" F2 r        if(state != true)
9 ]& {9 c2 |  L7 M                state = true;
}

) `+ W: t( W$ K6 L
1 b9 u! r( }0 J7 K  B- L4 n& k" g# Xu8 SPI_RxByte(void)
{
8 m5 M2 o4 R( J" X" n6 y. m$ \' i; S        uint8_t state;
) R9 C+ K& b" O- ~6 G4 ?8 i  state = spi_master_rx(p_spi_base_address) ;
  return state;                             
8 g8 V0 c1 T  E" Z' q}
- p1 K" A3 Y" `; F#endif
/*
/////////////////////////////////////////////////////////////////////
//?    ?:?RC632???
//????:Address[IN]:?????
//?    ?:????
* X3 t( `9 w! \/ E* ?* A; k/////////////////////////////////////////////////////////////////////
3 u1 Y8 s2 v& z' S4 Gunsigned char ReadRawRC(unsigned char Address)
{
    unsigned char ucResult=0;
                uint8_t ucAddr;
9 ~0 ]8 C6 }/ b5 p4 u/ e9 D                uint8_t tx_data[2]={0x00,0x00};
3 m  A& \) j* u9 u; \4 L/ p                uint8_t rx_data[2]={0x00,0x00};
* L3 v3 P  R$ _8 \                ucAddr = ((Address << 1) & 0x7E) | 0x80;
                tx_data[0] = ucAddr;
1 U/ }0 j# r) l+ P                spi_master_tx_rx(p_spi_base_address, 1, tx_data, rx_data);
: X. Y% W8 w8 z9 Q# t                ucResult = rx_data[0];
    return ucResult;
. A8 {5 P, c  }2 e}
9 {8 k7 I/ S4 b- w, _" r8 w' H
, x/ x+ O& H6 ?
; ~8 t" T1 e0 K( \/////////////////////////////////////////////////////////////////////
//?    ?:?RC632???
//????:Address[IN]:?????
//          value[IN]:????
/////////////////////////////////////////////////////////////////////
void WriteRawRC(unsigned char Address, unsigned char value)
9 w5 L$ y9 q7 P8 J7 Y  c4 E' V{  
                uint8_t tx_data[2]={0x00,0x00};
: ], x; z2 Q/ Z, ~                uint8_t rx_data[2]={0x00,0x00};
                uint8_t ucAddr;
; C* B3 m" B+ [1 ^2 i, k5 b2 F                ucAddr = ((Address << 1) & 0x7E);
                tx_data[0] = ucAddr;
, l: v$ b. U2 c4 v) _$ B, K* s                tx_data[1] = value;
                spi_master_tx_rx(p_spi_base_address, 2, tx_data, rx_data);
2 e( S% }; G5 \/ v3 |0 T; X' H! s}*/

+ w5 A. ]. d9 O/ p: I$ [" _& X+ r
/////////////////////////////////////////////////////////////////////
5 O: H$ p0 E* X( m+ A7 Y//功    能：读RC632寄存器
0 n' J9 E) b: i' a+ h//参数说明：Address[IN]:寄存器地址
//返    回：读出的值
2 S4 |$ _& ~5 M" P  y4 V/////////////////////////////////////////////////////////////////////
* M5 Z% M# _& tstatic u8 ReadRawRC(u8 Address)
; c; i. b1 R8 w( Y{
  u8 ucAddr;
- K  ?  K5 B! ?" n. ~. T  u8 ret = 0;
#ifdef _MFRC_SOFT_SPI
  u8 i;
  Set_MFRC_SCK(0);
7 Z" ^4 s) E  z% f3 `#endif  
1 {, U/ ^4 n  c& s! N! b1 j  g  
  Set_MFRC_CS(0);

4 ^8 q) {: J; q. F% Q8 K, t6 ]
  ucAddr = ((Address << 1) & 0x7E) | 0x80;
#ifdef _MFRC_SOFT_SPI  
  for(i=8; i>0; i--)
  {
2 o  A# }7 s3 \    Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
) R( @1 [! Z: @! @. d) b    Set_MFRC_SCK(1);
- o7 ^! u% o+ I. G  |/ l- ~$ {    ucAddr <<= 1;
    Set_MFRC_SCK(0);
' O  n9 S4 r( C  c' J  }


  for(i=8; i>0; i--)
  {
    Set_MFRC_SCK(1);
    ret <<= 1;
    ret |= MFRC_MISO_STATUS();
+ B% ?1 W3 x- N7 O  ]    Set_MFRC_SCK(0);
; L. Z. h/ O0 Z% R  }
#else
  SPI_TxByte(ucAddr);
. Y7 s: E3 d* [% }1 Z  ret = SPI_RxByte();
! C4 \. A1 G0 M6 P        
#endif
8 v2 C5 i7 U5 e' L2 @: [3 e  Set_MFRC_CS(1);
#ifdef _MFRC_SOFT_SPI
% W. |) U1 X6 [+ F  Set_MFRC_SCK(1);
#endif
+ J& n3 q3 l3 Y% q6 U" N        printf("REG ADDR:0x%x  Val: 0x%02x\r\n",Address,ret);
  return ret;
}
# r9 O5 E; a2 ]

. s6 y( `5 a9 P# C8 N4 T/////////////////////////////////////////////////////////////////////
//功    能：写RC632寄存器
& O: m3 o: z' [, i! ~# A$ L4 S//参数说明：Address[IN]:寄存器地址
5 r* _& J- F) C  o& x. |//          value[IN]:写入的值
/////////////////////////////////////////////////////////////////////
/ y; `, K& @; I! B' L1 xvoid WriteRawRC(u8 Address, u8 value)
{
5 N5 p$ h0 X% K/ p  u8 ucAddr;
& S6 J2 L# j% ~3 `; e: c5 J#ifdef _MFRC_SOFT_SPI
6 f% k; x/ N0 B( y. F  u8 i;
! d1 ^' A0 j0 g5 y' r! ^  Set_MFRC_SCK(0);
, K: J0 x* ?* o1 c/ k#endif
3 Q) W; H- x  `5 L' j5 n$ S' H  Set_MFRC_CS(0);
" Z0 F8 F$ |' X

# ^4 g* \- q' ~" q+ i/ S  ucAddr = ((Address << 1) & 0x7E);
, b# D9 L6 t8 u3 N% y# @#ifdef _MFRC_SOFT_SPI
7 e% P8 b! j" M        printf("---write---REG ADDR:0x%x  Val: 0x%02x\r\n",Address,value);
( q1 |( E/ A+ C8 b5 c; \% e3 ]  for(i=8; i>0; i--)
6 [4 n) A: O' L6 ?+ c! a1 c; B% }  {
/ Y+ j7 a- s2 F. z    Set_MFRC_MOSI((ucAddr & 0x80) == 0x80);
    Set_MFRC_SCK(1);
$ ^- P, Z( [5 A, _) X2 @" C. l    ucAddr <<= 1;
4 W! D7 V) ^6 E# j    Set_MFRC_SCK(0);
5 G" F. g  V( S2 C  }


% y- k( O9 n/ ~+ l4 I  for(i=8; i>0; i--)
  {
    Set_MFRC_MOSI((value & 0x80) == 0x80);
/ @( @0 ~2 l! ~# f* n; P; I    Set_MFRC_SCK(1);
    value <<= 1;
    Set_MFRC_SCK(0);
  }
#else
  SPI_TxByte(ucAddr);
. M2 f* h  r" |# p  SPI_TxByte(value);
        printf("---write---REG ADDR:0x%x  Val: 0x%x\r\n",Address,value);
) w7 i9 R* o: m7 X  L#endif
& G" X# R% \5 b) e/ r# E  Set_MFRC_CS(1);
0 l# x/ W# Z+ R" f3 E8 \. f#ifdef _MFRC_SOFT_SPI
# w! i! o1 _  k3 l! A  Set_MFRC_SCK(1);
#endif
        
8 k& T7 I! V( h* N}
. g$ g: X" [, w. l5 T5 t$ }% ]
- X8 Y' K* ~4 Y* u; X
/////////////////////////////////////////////////////////////////////
3 T3 {3 O3 V& h# i//功    能：清RC522寄存器位
9 m& t+ w& y, R# I" t6 B! c# }//参数说明：reg[IN]:寄存器地址
' c& n, V/ S/ C$ u3 b//          mask[IN]:清位值
  B8 E2 G4 [& S) G/////////////////////////////////////////////////////////////////////
static void ClearBitMask(u8 reg, u8 mask)
{
        u8 tmp = 0x0;
; c5 X0 C3 _* p; ^2 O        tmp = ReadRawRC(reg);
        WriteRawRC(reg, tmp & ~mask);  // clear bit mask
}


/////////////////////////////////////////////////////////////////////
4 @& `, [- b4 m//功    能：置RC522寄存器位
//参数说明：reg[IN]:寄存器地址
//          mask[IN]:置位值
$ t. t1 A  @. q. X1 E8 Q9 x/////////////////////////////////////////////////////////////////////
static void SetBitMask(u8 reg, u8 mask)
{
* q1 {- N: v- z/ M* x6 i  |/ M- ~        u8 tmp = 0x0;
& }" w7 j( P5 a        tmp = ReadRawRC(reg);
- @: w8 E9 {4 t3 V" k7 l" q        WriteRawRC(reg, tmp | mask);  // set bit mask
, b% S$ I$ T8 H0 X9 k0 c' {! ?}
6 L# Y& i2 x0 A5 u: N* S


2 d+ e' a, H) D! m$ ?* A
//开启天线  
1 X" k- a1 U, x- q  c: R) ]//每次启动或关闭天险发射之间应至少有1ms的间隔
: c) S$ n" U4 R1 Y2 uvoid PcdAntennaOn(void)
{
9 r/ w9 d- B  p$ O" u        u8 i;
        i = ReadRawRC(TxControlReg);
. r+ X7 Y* e  ]9 q( T7 Q        if (!(i & 0x03))
/ }8 l: ~5 ^- a) [9 t        {
                SetBitMask(TxControlReg, 0x03);
        }
}

6 @- }" Q0 H" ?6 Z
# {6 \7 Z! \( r( y//关闭天线
  o# w' |* Q# evoid PcdAntennaOff(void)
{
+ H6 D: _. ?9 Z) S2 M* V        ClearBitMask(TxControlReg, 0x03);
}
3 `) w8 D/ I- [% e! s
# a/ p! Z- {, i* d% R
/////////////////////////////////////////////////////////////////////
  Q0 F; Y% U6 K2 |+ r8 t//功    能：通过RC522和ISO14443卡通讯
//参数说明：Command[IN]:RC522命令字
0 g$ o; B  ]7 f6 }//          pIn [IN]:通过RC522发送到卡片的数据
5 Y& c6 T$ w: W//          InLenByte[IN]:发送数据的字节长度
" S& d1 A! r3 X" f, ?# |//          pOut [OUT]:接收到的卡片返回数据
//          *pOutLenBit[OUT]:返回数据的位长度
/ |. z' R; e: R1 @& @/////////////////////////////////////////////////////////////////////
#define MAXRLEN                       18
static char PcdComMF522(unsigned char Command,
                 unsigned char *pInData,
                 unsigned char InLenByte,
- G- u( X3 ~# {: u" @( t                 unsigned char *pOutData,
4 x# T, D  f' t! ~, g                 unsigned int  *pOutLenBit)
{
        char status = MI_ERR;
+ B3 V. c2 C7 z  F0 N+ Q        unsigned char irqEn   = 0x00;
$ ]/ \9 E& F& M+ ^$ H; S/ X        unsigned char waitFor = 0x00;
        unsigned char lastBits;
        unsigned char n;
" N  Q6 [5 i  y        unsigned int i;


        switch (Command)
6 R. ]) t6 j2 L( g" F% S. D        {
$ {$ C, `0 W, d9 X$ r( y, o        case PCD_AUTHENT:
                irqEn = 0x12;
( G5 c" x- f! e5 [6 U7 M& F+ Q                waitFor = 0x10;
                break;
4 k7 s& F# t. v* D% k        case PCD_TRANSCEIVE:
                irqEn = 0x77;
% n7 d8 ^* T& h6 |2 [2 _/ }                waitFor = 0x30;
8 `- L8 Y- C8 R& V2 l% B2 n                break;
        default:
7 i' P2 x1 O5 P' H                break;
* I' h2 o/ X  W+ |7 t% d        }
/ B/ V& p3 Q7 I: f
1 U3 P( P) l3 n2 o0 E
        WriteRawRC(ComIEnReg, irqEn | 0x80);
        ClearBitMask(ComIrqReg, 0x80);
9 h  P3 V  Y7 {6 b! r$ y" G- g- j" n        WriteRawRC(CommandReg, PCD_IDLE);
6 ]# l2 F/ g' `9 w  x        SetBitMask(FIFOLevelReg, 0x80);
  b) X7 ^; z, J

        for (i = 0; i < InLenByte; i++)
        {
                WriteRawRC(FIFODataReg, pInData);
        }
0 V3 Z! q$ W- L! z        WriteRawRC(CommandReg, Command);
. q. _7 c4 j5 F! z4 F

( k. x" |, G( ]  ]' _: O6 Z        if (Command == PCD_TRANSCEIVE)
2 Q' |; a' b( ]) M$ v        {
/ w( i! m* s3 e$ v& A4 A                SetBitMask(BitFramingReg, 0x80);
        }

6 F; N& |' ?* |9 f0 S
+ e3 a7 N9 p7 Q+ k$ p6 B6 b        i = 3000;//800;
6 N' x9 F' j9 h( s        do
        {
                n = ReadRawRC(ComIrqReg);
                i--;
/ {! v$ k/ y9 Z; y' f7 A        } while ((i != 0) && !(n & 0x01) && !(n & waitFor));
' m; g" |, g; H5 |        ClearBitMask(BitFramingReg, 0x80);
7 K! @/ y' b: H8 C

        if (i != 0)
        {
                if (!(ReadRawRC(ErrorReg) & 0x1B))
                {
                        status = MI_OK;
% g$ X& y6 h8 H/ X: k. D0 g" [% @                        if (n & irqEn & 0x01)
* A/ W* J, V! p! S! v                        {
' y) x& u- ?: W) Q                                status = MI_NOTAGERR;
0 q& ~# Z! A3 C8 p( k                        }
0 d8 r% }* O( T                        if (Command == PCD_TRANSCEIVE)
                        {
                                n = ReadRawRC(FIFOLevelReg);
$ T) z; q) l2 Q4 @                                lastBits = ReadRawRC(ControlReg) & 0x07;
8 M- c% Y1 d0 M# q0 @                                if (lastBits)
                                {
9 K4 F: U) S$ d7 S4 q                                        *pOutLenBit = (n - 1) * 8 + lastBits;
                                }
( M0 y1 Z; \- v, _2 e$ F) |4 ^& q, c                                else
2 `2 ?% m! w+ S3 Q                                {
: \3 d$ u9 c' g, G! h1 X# U                                        *pOutLenBit = n * 8;
6 r, I0 O3 ?, G, {. ^- v, n9 V                                }
                                if (n == 0)
                                {
: c3 N8 q$ |: G                                        n = 1;
  e2 b) d- K& ]# B" e. r% Q2 h5 b( }2 v                                }
, `. b5 M: m8 h* x                                if (n > MAXRLEN)
* G; Q( Q; M+ C& F# w4 G                                {
' q; y% A/ C3 }' ^; }2 c2 Z7 c                                        n = MAXRLEN;
                                }
4 }0 w9 M9 P/ C9 `0 E0 `                                for (i = 0; i < n; i++)
* K( k  x* G3 S9 L( G+ J                                {
                                        pOutData = ReadRawRC(FIFODataReg);
                                }
/ q& ]5 p$ `& U; q, c: p                        }
, Q  M( A7 w7 ]1 l+ v9 S4 B! ?                }
5 z5 v2 x3 l2 `$ c; E                else
8 T! Q. [5 C0 s# k                {
+ C. C2 V2 M2 [7 ]/ R* l1 k3 s7 S                        status = MI_ERR;
. u7 ~% ]. |0 c3 I* V$ R/ c- m                }
        }
2 I0 ]2 e# f1 e! J+ e5 _6 L        SetBitMask(ControlReg, 0x80);           // stop timer now
        WriteRawRC(CommandReg, PCD_IDLE);
        return status;
}


1 @: a: b% m9 t: n3 m1 ^

/////////////////////////////////////////////////////////////////////
8 z. s- y( n' [1 [2 I//功    能：复位RC522
2 o! ^& O' K# N8 Q) ^//返    回: 成功返回MI_OK
+ P) q' S% n" ^, U/////////////////////////////////////////////////////////////////////
char PcdReset(void)
/ S7 R+ Y$ |- ~) y) [. [{
        nrf_gpio_pin_set(SPI_RST);
        MFRC_Delay(10);  
9 M! L! |6 [6 q4 o' u; p  ]        nrf_gpio_pin_clear(SPI_RST);
" f! m7 z9 K, g' \  ]1 ]) O3 l2 q, A        MFRC_Delay(60000);  
        nrf_gpio_pin_set(SPI_RST);
8 a, e' ?1 i: I" Y" U        MFRC_Delay(500);  
# U8 W- ?% U' p7 X        WriteRawRC(CommandReg, PCD_RESETPHASE);
1 e  m3 m7 J) h' \# [3 `8 t        MFRC_Delay(2000);  
6 `5 |) y# G/ m! a
5 n" N8 K7 V, e7 d9 p7 [8 h2 Z/ S
        WriteRawRC(ModeReg, 0x3D);            
        WriteRawRC(TReloadRegL, 30);            
        WriteRawRC(TReloadRegH, 0);
8 a$ |/ j/ a4 C! I        WriteRawRC(TModeReg, 0x8D);
3 {( k* [6 j+ l  \0 O4 a% W        WriteRawRC(TPrescalerReg, 0x3E);
        WriteRawRC(TxAutoReg, 0x40);
4 s/ L. m/ c$ R* x7 z        
        ClearBitMask(TestPinEnReg, 0x80);         //off MX and DTRQ out
        WriteRawRC(TxAutoReg, 0x40);
: w/ m  G4 A. _5 D

) {. b3 ?7 p2 v! E+ _        return MI_OK;
- z' n' E+ Z" g! [( A}        
1 ^. S- `9 K$ i( ^& M

' m- \2 m& O: y. ]* P/////////////////////////////////////////////////////////////////////
- {5 ]! p7 l7 C  T//用MF522计算CRC16函数
/////////////////////////////////////////////////////////////////////
void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
# q5 n* J' @: P0 c7 x6 }# j& C% L{
    unsigned char i,n;
9 |( g# G+ h5 M9 ?) V- o8 U        
3 p; M5 a+ [8 y+ Q5 t" ]    ClearBitMask(DivIrqReg,0x04);
    WriteRawRC(CommandReg,PCD_IDLE);
4 W2 e  R9 n& i7 Q1 N5 k    SetBitMask(FIFOLevelReg,0x80);
    for (i=0; i<len; i++)
    {   
        WriteRawRC(FIFODataReg, *(pIndata+i));  
2 l( R/ A) b+ o( U' A    }
% a* p% l5 K& s6 D5 A/ ]    WriteRawRC(CommandReg, PCD_CALCCRC);
    i = 0xFF;
, }8 a# f1 _; o* n. I& t, c    do
    {
: [! b7 b/ z% B        n = ReadRawRC(DivIrqReg);
- W* @) A4 T, t) |4 N        i--;
( G0 j8 z& v& J    }
    while ((i!=0) && !(n&0x04));
/ k/ B0 R; c  n    pOutData[0] = ReadRawRC(CRCResultRegL);
    pOutData[1] = ReadRawRC(CRCResultRegM);
}

' O+ c+ d2 ~! A4 e
' i* {4 ~0 H! o7 h+ `

//////////////////////////////////////////////////////////////////////
//设置RC522的工作方式
//////////////////////////////////////////////////////////////////////
signed char M500PcdConfigISOType(unsigned char type)
% d* N4 Q2 c/ f3 p' I* T{
  if('A' == type)
- ?+ \8 O0 t# }) W  {
    ClearBitMask(Status2Reg,0x08);
, j/ f$ u; h7 o  n7 o$ G! K    WriteRawRC(ModeReg,0x3D);
- T) a% ]& ?- m! K0 u) w# c) u* y    WriteRawRC(RxSelReg,0x86);
' p- o4 Z# m: m! d, r    WriteRawRC(RFCfgReg,0x7F);   
' r( T' v& D1 |3 e4 L    WriteRawRC(TReloadRegL,30);
    WriteRawRC(TReloadRegH,0);
    WriteRawRC(TModeReg,0x8D);
. E* \  i1 T9 T: I5 Y7 J    WriteRawRC(TPrescalerReg,0x3E);
( k8 I8 U& L& N3 b/ P8 L    MFRC_Delay(10000);
    PcdAntennaOn();
  }
- F0 P8 x/ M1 ]0 _  else
  {
    return -1;
  }
        
  return MI_OK;
7 p9 H. o/ E: C6 J}

; B6 F1 Y. W9 \/ I
/***
初始化RC522
*/

4 }; z6 c! N8 M1 L
void MFRC522_Init(void)
0 y4 i9 g' |" Q& y8 i  j7 J# Q{
$ Y4 a' \: I( ]4 S/ t" S, q$ P//  MFRC_GPIOConfigure();
        
  PcdReset();
! ~$ k* p6 G- [# t  PcdAntennaOff();
  MFRC_Delay(2000);
1 I2 c7 B. F; J, V3 ^: L  PcdAntennaOn();
  M500PcdConfigISOType('A');
}


6 L! q( \2 x2 R# J: _" r; @- d/////////////////////////////////////////////////////////////////////
  w7 h% `1 J: A: i6 A! |//功    能：寻卡
//参数说明: req_code[IN]:寻卡方式
//                0x52 = 寻感应区内所有符合14443A标准的卡
# g7 Q+ H- ]7 ?0 \. ?2 C//                0x26 = 寻未进入休眠状态的卡
1 U& l$ u. Q$ e( z2 ^  R9 O9 T//          pTagType[OUT]：卡片类型代码
/ `: W2 R1 o4 j& [3 Y//                0x4400 = Mifare_UltraLight
$ w- ]/ x3 r5 C' Q, u' p' g//                0x0400 = Mifare_One(S50)
//                0x0200 = Mifare_One(S70)
//                0x0800 = Mifare_Pro(X)
//                0x4403 = Mifare_DESFire
/ G4 N! `) S% y. K) P% G//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
( E% E4 D6 _* dchar PcdRequest(u8 req_code, u8 *pTagType)
. W* ?9 b, K7 T# }, l3 l7 T{
  char status;  
! r3 g! V: g$ h' _0 t+ Y5 w9 b$ J( p        unsigned int  unLen;
        unsigned char ucComMF522Buf[MAXRLEN];


6 j- i( q. `  l: H        ClearBitMask(Status2Reg, 0x08);
' z4 H8 S* G& w0 l        WriteRawRC(BitFramingReg, 0x07);
0 ]4 @8 N! ~0 @( U6 M        SetBitMask(TxControlReg, 0x03);
//   
3 @7 f$ E. D% ~        ucComMF522Buf[0] = req_code;
6 y; R+ j4 Q% z! S

        status = PcdComMF522(PCD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf,
- N" F) _! a( O$ M                        &unLen);
//   UART_send_byte(status);
        if ((status == MI_OK) && (unLen == 0x10))
5 R; }* U" ]1 y% `4 g2 }        {
                *pTagType = ucComMF522Buf[0];
                *(pTagType + 1) = ucComMF522Buf[1];
        }
# J4 N  |3 p8 h6 H' i- H1 m        else
        {
          status = MI_ERR;
4 v/ p/ h% h# S$ V        }
: t. }2 U: [' r( ^8 v
1 |( a1 W$ q# [" B8 v2 g
7 b9 M" p0 W4 W! c+ ^5 L& P        return status;
# t7 M3 n. D+ ^7 ~}

4 L# H# q+ q5 v+ P1 T
# i. c' k% Z9 }# c2 A5 d' @

/////////////////////////////////////////////////////////////////////
//功    能：防冲撞
+ S" H0 N3 N8 q$ y* H- v0 G//参数说明: pSnr[OUT]:卡片序列号，4字节
//返    回: 成功返回MI_OK
; L) ^; F1 a5 q7 o8 T4 h1 T' t/////////////////////////////////////////////////////////////////////  
8 h. y  n7 r: I  z1 ?' ]% ~' h/ Dchar PcdAnticoll(unsigned char *pSnr)
{
    char status;
    unsigned char i,snr_check=0;
    unsigned int  unLen;
* b3 i  E' R8 L3 P5 R+ n1 R) ?* t    unsigned char ucComMF522Buf[MAXRLEN];
   

6 A  m5 u: |# J" ]* v. E4 W
" `' D  d4 I( ~6 o  T    ClearBitMask(Status2Reg,0x08);
    WriteRawRC(BitFramingReg,0x00);
    ClearBitMask(CollReg,0x80);
" b, w3 _" g; D
, ~+ K7 F# T6 x    ucComMF522Buf[0] = PICC_ANTICOLL1;
" t9 Y# E5 O% i6 x    ucComMF522Buf[1] = 0x20;


3 q( `# N  H5 M9 G/ m! G$ T5 f$ D# i    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

9 c( m7 P5 g. \
    if (status == MI_OK)
    {
             for (i=0; i<4; i++)
4 L2 r9 J- D0 N2 R% ]" }7 L7 _         {   
5 x3 c$ _9 W1 p$ Y. M% i- u             *(pSnr+i)  = ucComMF522Buf;
( Y+ W* r0 i! t% i5 C( H             snr_check ^= ucComMF522Buf;
         }
         if (snr_check != ucComMF522Buf)
$ s! g+ X4 v' F& h! k6 u, l         {   status = MI_ERR;    }
    }
   
7 U$ P5 c7 d3 a4 n" M- D1 x/ D, [; i    SetBitMask(CollReg,0x80);
    return status;
}
, ?; M, m! P/ X* X# V9 p

/////////////////////////////////////////////////////////////////////
% n4 U5 y+ `* k0 b1 g- E9 v& }, z1 c//功    能：选定卡片
//参数说明: pSnr[IN]:卡片序列号，4字节
# b7 ^2 |( }; f- |5 B8 I//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
char PcdSelect(unsigned char *pSnr)
9 D  N& m0 B7 h# U# m0 F- F% |; u{
, p9 j) j: h; n# F    char status;
    unsigned char i;
* X# L  e$ x3 ^/ ?. U( b    unsigned int  unLen;
    unsigned char ucComMF522Buf[MAXRLEN];
2 @5 l7 W9 H0 k7 W! v; g  V! z   
+ W; m" _" r7 G+ r( q3 P( n    ucComMF522Buf[0] = PICC_ANTICOLL1;
$ g- O8 ?) D& L, ?    ucComMF522Buf[1] = 0x70;
! T- X4 l4 {, ~+ _& W+ O2 G    ucComMF522Buf[6] = 0;
    for (i=0; i<4; i++)
    {
            ucComMF522Buf[i+2] = *(pSnr+i);
            ucComMF522Buf[6]  ^= *(pSnr+i);
7 x+ |! C# h) Q5 y. p: _+ q    }
" d. {7 q; f7 g- h# C1 n7 K    CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
  
5 k/ L0 s0 H" p3 s9 d  ?    ClearBitMask(Status2Reg,0x08);
. @  d* \, D5 f, T- V4 K1 t8 L

- W7 X. h' z! s+ y' X7 t    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
   
6 i( |9 E3 n3 Q7 o: F7 P8 n: I    if ((status == MI_OK) && (unLen == 0x18))
) l/ Y: O0 `3 d+ }1 ], Q% O) [    {   status = MI_OK;  }
2 Z, {8 J9 a( N$ x. G7 x' ~, `& {    else
4 @# W7 s7 n5 D/ U6 g7 n# m, O    {   status = MI_ERR;    }


  f$ Q9 {" n; N# c# G& O! u, m# E5 }    return status;
( q3 u$ o3 V$ O6 q% C1 X}
8 v, v% y7 @" w

/////////////////////////////////////////////////////////////////////
//功    能：命令卡片进入休眠状态
9 w: b+ G$ U6 q8 M# v+ ~6 `" d//返    回: 成功返回MI_OK
4 P" e2 `$ `& H! G- |5 z9 N/////////////////////////////////////////////////////////////////////
char PcdHalt(void)
0 m+ y2 O( f  i2 P5 w( [- G{
//    int status;
    unsigned int  unLen;
0 T1 ~. t0 m# d* Q% b    unsigned char ucComMF522Buf[MAXRLEN];
( J- K. g0 [7 U' C' T* d
# P1 d. G7 o8 \! L9 V: f
! j! Z% b0 U* x, J- U# Q7 |    ucComMF522Buf[0] = PICC_HALT;
' V) u( U  |" ^- U    ucComMF522Buf[1] = 0;
& |/ m! j" L) S' n1 O3 Z3 t    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
2 V- D3 ]3 j; A- u( h
/ o- u2 l% x& K1 b, W+ J0 F- N1 ~  @    //status =
    PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);


" O+ \' V5 s* A    return MI_OK;
3 n' |% ~2 I+ Q+ w1 L}


# a  y' h5 p1 @( ^% k2 c  H& \/////////////////////////////////////////////////////////////////////
: x7 F1 e3 t; b+ u0 P! k% [//功    能：验证卡片密码
% e0 n' \) W7 U; _2 A7 L0 C//参数说明: auth_mode[IN]: 密码验证模式
//                 0x60 = 验证A密钥
//                 0x61 = 验证B密钥
//          addr[IN]：块地址
3 f  p4 ~: p  s. K//          pKey[IN]：密码
//          pSnr[IN]：卡片序列号，4字节
//返    回: 成功返回MI_OK
1 o7 _6 B# k4 G! v" @$ b/////////////////////////////////////////////////////////////////////               
char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
7 M) I/ s6 g( r: w{
" ?2 n4 I) m6 }- G5 L+ X5 X    char status;
    unsigned int  unLen;
    unsigned char i,ucComMF522Buf[MAXRLEN];
0 l6 M, X3 ]+ Z9 ?  V7 C/ f

    ucComMF522Buf[0] = auth_mode;
    ucComMF522Buf[1] = addr;
    for (i=0; i<6; i++)
    {    ucComMF522Buf[i+2] = *(pKey+i);   }
    for (i=0; i<6; i++)
    {    ucComMF522Buf[i+8] = *(pSnr+i);   }
//   mEMCpy(&ucComMF522Buf[2], pKey, 6);
  ]9 L$ I( b# t0 `4 `. s. t //   memcpy(&ucComMF522Buf[8], pSnr, 4);
   
: `" b2 p1 x$ f$ y- T& c    status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
    if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
    {   status = MI_ERR;   }
- Z6 e: }9 Q. M& `' |/ `8 w   
2 P% w5 L2 j7 j1 L5 \    return status;
1 E$ e. {! N7 C% S0 O" s}

' ]) n. x2 L! s9 @+ r
" F8 {, x3 x( C3 Q$ ~/////////////////////////////////////////////////////////////////////
  O2 T; U0 l4 |- R2 N//功    能：读取M1卡一块数据
//参数说明: addr[IN]：块地址
//          pData[OUT]：读出的数据，16字节
//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////
, u: u- |  Z: Z0 {$ S8 ^6 jchar PcdRead(unsigned char addr,unsigned char *pData)
{
- R, X' B# F8 ?" z( O: M    char status;
    unsigned int  unLen;
    unsigned char i,ucComMF522Buf[MAXRLEN];
& M0 R7 C& K! d! q

    ucComMF522Buf[0] = PICC_READ;
% O7 ~' m; s+ g- ?% K' L    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
* G2 b  O/ h1 y9 h' x7 ?, E   
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
7 m/ ^2 c1 G( J6 V) k    if ((status == MI_OK) && (unLen == 0x90))
//   {   memcpy(pData, ucComMF522Buf, 16);   }
& R, t4 F. u5 V" E9 t& U; r6 [    {
        for (i=0; i<16; i++)
7 X: s3 W+ D& Y2 ]5 e% a" d        {    *(pData+i) = ucComMF522Buf;   }
) }! t1 h' {; d3 C0 ~( J0 `    }
    else
    {   status = MI_ERR;   }
   
    return status;
}
2 l' P+ K7 G  |. q3 T' q

/////////////////////////////////////////////////////////////////////
//功    能：写数据到M1卡一块
//参数说明: addr[IN]：块地址
//          pData[IN]：写入的数据，16字节
//返    回: 成功返回MI_OK
; \# m% r. O" X/ o/////////////////////////////////////////////////////////////////////                  
$ z( y! F, F" o. x, W' l3 b1 v# }char PcdWrite(unsigned char addr,unsigned char *pData)
{
    char status;
    unsigned int  unLen;
% z6 N3 g7 F3 E7 r3 V2 y    unsigned char i,ucComMF522Buf[MAXRLEN];
( L$ u7 M+ Q9 ~* I" e+ l2 g   
; C9 m# W+ |) r5 C1 b7 ^    ucComMF522Buf[0] = PICC_WRITE;
    ucComMF522Buf[1] = addr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
; B' r! F* g1 R
    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
; O! F' G7 n: @2 L9 C+ o2 p, K
" \" _1 F; H2 K% d0 i. a0 ^: K
8 O) W# B" _! m2 {    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
9 V7 \. R  n7 z& K1 m/ O! S6 q    {   status = MI_ERR;   }
; G6 D' {$ w8 A$ G% r        
    if (status == MI_OK)
    {
        //memcpy(ucComMF522Buf, pData, 16);
        for (i=0; i<16; i++)
) O6 K$ X9 s! H, w4 m! T4 X7 W8 m' \+ {9 k        {    ucComMF522Buf = *(pData+i);   }
        CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

  L$ O* a: j2 @, \, a  o
1 A% o  }6 r9 k+ S" T        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
1 K' ?1 |9 L' N+ i4 p1 ^7 x        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  p$ q/ M: g* d& T; {8 [- S        {   status = MI_ERR;   }
    }
$ F3 _9 c) w& X" A* @7 }4 ~   
    return status;
}


0 {, [% |- o/ ~/////////////////////////////////////////////////////////////////////
( n# r% P$ ~  ]//功    能：扣款和充值
3 O: e2 ^7 n& j9 j//参数说明: dd_mode[IN]：命令字
//               0xC0 = 扣款
//               0xC1 = 充值
5 I) B* b9 s  p8 ?) z//          addr[IN]：钱包地址
4 p* u/ @5 a4 a6 ]- `4 O//          pValue[IN]：4字节增(减)值，低位在前
6 ^8 ^8 _' ^! N5 v. q. S9 ^//返    回: 成功返回MI_OK
/////////////////////////////////////////////////////////////////////                 
char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue)
5 r- C! B/ @( C( t2 f, _{
4 k" }# f8 o' z3 {4 G' h8 }+ e- d! V    char status;
; W# [4 C; D- V    unsigned int  unLen;
' y# k" d- G" _0 z4 p    unsigned char ucComMF522Buf[MAXRLEN];
: j+ }" j* c: p" m  w2 J) S   
5 g0 |+ Q  Q# M% y    ucComMF522Buf[0] = dd_mode;
: ?8 Y6 a4 [$ a' F& j    ucComMF522Buf[1] = addr;
8 W: Q# j3 q  c  c    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
! o6 Q( n1 u# e( f; e3 v

2 U+ k- b& \# O, d0 }: u6 T    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    {   status = MI_ERR;   }
        
: K/ g( b2 ?2 c/ b0 x% L! j    if (status == MI_OK)
$ H5 }% R4 h* X    {
% f8 b8 s3 o5 F  t3 _# G! x( ~        memcpy(ucComMF522Buf, pValue, 4);
" a/ p% c- r/ O! K: g% n //       for (i=0; i<16; i++)
5 ?' J4 y  q2 x' f* D7 o8 U //       {    ucComMF522Buf = *(pValue+i);   }
        CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
* q& S" j; \; ]8 M) l        unLen = 0;
        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
        if (status != MI_ERR)
        {    status = MI_OK;    }
8 z, z( V* |5 w; H0 K3 e3 ^    }
   
2 k0 t4 n: B; |: N8 a    if (status == MI_OK)
    {
3 f7 |3 X( C1 F        ucComMF522Buf[0] = PICC_TRANSFER;
        ucComMF522Buf[1] = addr;
        CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
   
        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
- F/ G# e' J7 Z3 T

! g% G( B2 F* V5 y" h; l        if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
        {   status = MI_ERR;   }
$ ^* P. Q( J# `' E6 h! N    }
. G' Q. J6 G1 b5 N6 ^9 m    return status;
}


/////////////////////////////////////////////////////////////////////
//功    能：备份钱包
3 D5 k0 p" b6 k* Y% R//参数说明: sourceaddr[IN]：源地址
! h+ d/ ^  G' e% n& v* u5 V5 M4 N3 L//          goaladdr[IN]：目标地址
//返    回: 成功返回MI_OK
  L" J: R6 l+ F; e/////////////////////////////////////////////////////////////////////
$ G/ k. C1 G6 K2 e4 ochar PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
{
    char status;
) j+ M; i5 `2 ^0 J) e    unsigned int  unLen;
5 a* G1 ?, F# _    unsigned char ucComMF522Buf[MAXRLEN];
% w! v; Q5 r1 S7 Y. f" Y
6 P6 }+ F* u" N: N7 p
    ucComMF522Buf[0] = PICC_RESTORE;
    ucComMF522Buf[1] = sourceaddr;
    CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

; Y  D' C0 Z0 R    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
7 k7 D* a: t! F; ^
! u- J4 y% Y* m9 _$ B- j
    if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
    {   status = MI_ERR;   }
   
    if (status == MI_OK)
    {
        ucComMF522Buf[0] = 0;
( h: Y6 r0 g6 E; a( ~        ucComMF522Buf[1] = 0;
# u8 y' [: t; O) P3 o  H        ucComMF522Buf[2] = 0;
        ucComMF522Buf[3] = 0;
: L5 c8 f" ~0 R* Z5 q! j        CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);

7 X/ _/ M5 `7 `6 J' d, I9 K2 f        status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
! E" F8 K5 e/ F        if (status != MI_ERR)
        {    status = MI_OK;    }
    }
) O; ]* F. |8 [( u" j% a+ h
+ J5 M, _# X8 s6 g7 X& T% Q1 m

1 R. x! p! O/ O
…………限于本文篇幅 余下代码请从论坛下载附件…………

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

6 g! m: }& ?2 B/ `) n5 E' N

Mhza

学习下