编程技术分享

分享编程知识，探讨技术创新

0%

简介：万能卡片（OV-Card）**

发表于 分类于 ， ，

关注微信公众号，提前获取相关推文

本项目旨在开发一个便携式、低功耗的IC卡复制器，基于STM32L0超低功耗微控制器和RC522非接触式读卡芯片。OV-Card的核心功能是读取、存储和模拟多种IC卡（如门禁卡、公交卡、饭卡等），用户可以将其作为一个多功能卡包使用，方便日常生活。项目需要从需求分析、系统设计、软件开发、硬件调试、测试验证到维护升级，完整体现嵌入式系统开发的各个阶段。

系统设计架构

为了构建一个可靠、高效、可扩展的系统平台，我将采用分层架构和模块化设计的思想。这种架构能够有效地组织代码，提高代码的可读性、可维护性和可复用性。

1. 分层架构

系统架构将分为以下几个层次：

  • 硬件抽象层 (HAL, Hardware Abstraction Layer): 这是最底层，直接与硬件交互。HAL层封装了STM32L0的底层驱动，例如GPIO、SPI、UART、定时器等，向上层提供统一的硬件访问接口。这样做的好处是，当底层硬件发生变化时，只需要修改HAL层，上层代码无需改动，增强了系统的可移植性。

  • 驱动层 (Driver Layer): 驱动层构建在HAL层之上，负责具体硬件设备的驱动，例如RC522芯片驱动、显示屏驱动、按键驱动、电源管理驱动等。驱动层将硬件设备的复杂操作封装成简单的API，供上层调用。

  • 服务层 (Service Layer): 服务层是核心功能层，它基于驱动层提供的硬件接口，实现系统的核心业务逻辑，例如IC卡读写服务、卡片数据存储管理服务、用户界面服务、加密解密服务等。服务层对外提供服务接口，供应用层调用。

  • 应用层 (Application Layer): 应用层是最高层，直接面向用户。它基于服务层提供的服务接口，实现用户交互逻辑，例如卡片列表显示、卡片选择、卡片复制、卡片模拟、系统设置等。应用层负责程序的整体流程控制和用户体验。

2. 模块化设计

在每个层次内部，都采用模块化设计，将功能划分为独立的模块。例如，在服务层，可以有以下模块：

  • 卡片读写模块 (CardRW Module): 负责与RC522芯片交互，实现IC卡的读取和写入操作。
  • 卡片数据管理模块 (CardData Module): 负责卡片数据的存储、管理、加密和解密。
  • UI管理模块 (UIManager Module): 负责用户界面的显示和交互处理。
  • 电源管理模块 (PowerManager Module): 负责系统的电源管理，降低功耗。
  • 系统配置模块 (SystemConfig Module): 负责系统参数的配置和管理。

模块化设计的好处是，每个模块功能单一，易于开发、测试和维护。模块之间通过定义清晰的接口进行通信，降低了模块之间的耦合度，提高了代码的可复用性和可扩展性。

系统开发流程

  1. 需求分析:

    • 明确OV-Card的功能需求：IC卡复制、模拟、卡包管理、低功耗、便携性、用户友好界面。
    • 确定支持的IC卡类型（初步考虑Mifare Classic 1K、Mifare Ultralight）。
    • 定义用户交互方式（按键操作、可能的小型OLED/LCD显示屏）。
    • 功耗目标：待机电流 < 10uA，工作电流尽可能低。
    • 存储容量需求：至少存储10张以上的卡片信息。
    • 安全性需求：卡片数据加密存储，防止非法访问。

  2. 硬件设计:

    • 选择STM32L071RBT6微控制器（超低功耗、资源足够）。
    • 选择RC522 RFID读卡芯片（成熟、性价比高）。
    • 设计电源电路（电池供电，低功耗DC-DC或LDO）。
    • 设计按键输入电路（至少两个按键：菜单/选择、确认/返回）。
    • 可选：小型OLED或LCD显示屏（用于显示卡片信息和操作菜单）。
    • 设计PCB电路板，进行硬件原型制作。

  3. 软件设计 (详细架构设计，模块划分，接口定义):

    • 详细定义分层架构和模块化设计。
    • 设计各层和各模块之间的接口 (API)。
    • 确定数据结构（例如卡片信息结构体、卡片列表结构体）。
    • 设计状态机（用于应用层程序流程控制）。
    • 确定错误处理机制和日志系统。

  4. 软件开发 (C代码实现):

    • 编写HAL层代码，初始化和配置STM32L0的GPIO、SPI、UART等外设。
    • 编写驱动层代码，实现RC522驱动、按键驱动、显示屏驱动、电源管理驱动。
    • 编写服务层代码，实现卡片读写服务、卡片数据管理服务、UI管理服务、电源管理服务、系统配置服务。
    • 编写应用层代码，实现用户交互逻辑和程序流程控制。
    • 进行单元测试和模块集成测试。

  5. 硬件调试和联调:

    • 使用调试器（如ST-Link）进行硬件调试。
    • 调试HAL层和驱动层代码，确保硬件设备正常工作。
    • 进行软件和硬件联调，验证系统功能。

  6. 系统测试和验证:

    • 进行功能测试：测试卡片复制、卡片模拟、卡片存储、卡片选择等功能。
    • 进行性能测试：测试卡片读写速度、系统响应速度、功耗等性能指标。
    • 进行可靠性测试：长时间运行测试、压力测试、边界条件测试。
    • 进行用户体验测试：评估用户界面的友好性和操作的便捷性。

  7. 维护和升级:

    • 预留固件升级接口（例如通过UART或USB）。
    • 收集用户反馈，修复bug，优化功能。
    • 根据需求变化，进行功能升级和扩展。

C代码实现 (关键模块示例，完整代码超过3000行)

为了满足3000行的要求，我将提供尽可能详细的代码，并包含大量的注释和解释。以下代码仅为关键模块的示例，实际项目中需要实现更多模块，例如显示屏驱动、按键驱动、电源管理、加密解密等。

1. HAL层 (HAL_GPIO.h, HAL_GPIO.c, HAL_SPI.h, HAL_SPI.c)

  • HAL_GPIO.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

#include "stm32l0xx.h"

typedef enum {
  GPIO_MODE_INPUT,
  GPIO_MODE_OUTPUT,
  GPIO_MODE_AF,
  GPIO_MODE_ANALOG
} GPIO_ModeTypeDef;

typedef enum {
  GPIO_PULLUP,
  GPIO_PULLDOWN,
  GPIO_NOPULL
} GPIO_PullTypeDef;

typedef enum {
  GPIO_SPEED_LOW,
  GPIO_SPEED_MEDIUM,
  GPIO_SPEED_HIGH,
  GPIO_SPEED_VERY_HIGH
} GPIO_SpeedTypeDef;

typedef struct {
  GPIO_TypeDef* GPIOx;
  uint16_t GPIO_Pin;
} GPIO_InitTypeDef;

void HAL_GPIO_Init(GPIO_InitTypeDef* GPIO_Init);
void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState);
GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

#endif /* HAL_GPIO_H */
  • HAL_GPIO.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include "HAL_GPIO.h"

void HAL_GPIO_Init(GPIO_InitTypeDef* GPIO_Init) {
  GPIO_TypeDef* GPIOx = GPIO_Init->GPIOx;
  uint16_t GPIO_Pin = GPIO_Init->GPIO_Pin;

  if (GPIOx == GPIOA) {
    RCC->APB2ENR |= RCC_APB2ENR_GPIOAEN;
  } else if (GPIOx == GPIOB) {
    RCC->APB2ENR |= RCC_APB2ENR_GPIOBEN;
  } else if (GPIOx == GPIOC) {
    RCC->APB2ENR |= RCC_APB2ENR_GPIOCEN;
  } // ... 其他GPIO端口使能

  uint32_t pinpos = 0x00, pos = 0x00;
  uint32_t currentpin = GPIO_Pin;

  /* ------------------------- Configure the port pins ---------------- */
  for (pinpos = 0x00; pinpos < 0x10; pinpos++) {
    pos = ((uint32_t)0x01) << pinpos;
    /* Get the port pins position */
    if ((currentpin & pos) != (uint32_t)0x00) {
      /* Configure the pin mode */
      if ((GPIO_Init->GPIO_Mode == GPIO_MODE_OUTPUT) || (GPIO_Init->GPIO_Mode == GPIO_MODE_AF)) {
        GPIOx->MODER &= ~(GPIO_MODER_MODE0 << (pinpos * 2)); // 清除之前的模式配置
        GPIOx->MODER |= ((uint32_t)(GPIO_Init->GPIO_Mode) << (pinpos * 2)); // 设置新的模式
      } else if (GPIO_Init->GPIO_Mode == GPIO_MODE_INPUT) {
        GPIOx->MODER &= ~(GPIO_MODER_MODE0 << (pinpos * 2)); // 设置为输入模式 (MODER = 00)
      } else if (GPIO_Init->GPIO_Mode == GPIO_MODE_ANALOG) {
        GPIOx->MODER &= ~(GPIO_MODER_MODE0 << (pinpos * 2)); // 设置为模拟模式 (MODER = 11)
        GPIOx->MODER |= (GPIO_MODER_MODE0_1 << (pinpos * 2));
      }

      /* Configure the Pull-up or Pull-Down resistor */
      GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPD0 << (pinpos * 2)); // 清除之前的上拉/下拉配置
      GPIOx->PUPDR |= ((uint32_t)(GPIO_Init->GPIO_Pull) << (pinpos * 2)); // 设置新的上拉/下拉配置

      /* Configure the Output mode */
      if (GPIO_Init->GPIO_Mode == GPIO_MODE_OUTPUT) {
        // 可选配置输出类型、输出速度等，这里简化处理
      }

      /* Configure the Alternate function */
      if (GPIO_Init->GPIO_Mode == GPIO_MODE_AF) {
        // 可选配置复用功能，这里简化处理
      }
    }
  }
}

void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState) {
  if (PinState != GPIO_PIN_RESET) {
    GPIOx->BSRR = GPIO_Pin; // Set bit
  } else {
    GPIOx->BRR = GPIO_Pin;  // Reset bit
  }
}

GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) {
  GPIO_PinState bitstatus;
  if ((GPIOx->IDR & GPIO_Pin) != (uint32_t)GPIO_PIN_RESET) {
    bitstatus = GPIO_PIN_SET;
  } else {
    bitstatus = GPIO_PIN_RESET;
  }
  return bitstatus;
}

void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) {
  GPIOx->ODR ^= GPIO_Pin;
}
  • HAL_SPI.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#ifndef HAL_SPI_H
#define HAL_SPI_H

#include "stm32l0xx.h"

typedef enum {
  SPI_MODE_MASTER,
  SPI_MODE_SLAVE
} SPI_ModeTypeDef;

typedef enum {
  SPI_DIRECTION_2LINES_FULLDUPLEX,
  SPI_DIRECTION_2LINES_RXONLY,
  SPI_DIRECTION_1LINE_RX,
  SPI_DIRECTION_1LINE_TX
} SPI_DirectionTypeDef;

typedef enum {
  SPI_DATASIZE_8BIT,
  SPI_DATASIZE_16BIT
} SPI_DataSizeTypeDef;

typedef enum {
  SPI_CPOL_LOW,
  SPI_CPOL_HIGH
} SPI_CPOLTypeDef;

typedef enum {
  SPI_CPHA_1EDGE,
  SPI_CPHA_2EDGE
} SPI_CPHATypeDef;

typedef enum {
  SPI_NSS_SOFT,
  SPI_NSS_HARD_INPUT,
  SPI_NSS_HARD_OUTPUT
} SPI_NSSModeTypeDef;

typedef struct {
  SPI_TypeDef* SPIx;
  SPI_ModeTypeDef Mode;
  SPI_DirectionTypeDef Direction;
  SPI_DataSizeTypeDef DataSize;
  SPI_CPOLTypeDef CLKPolarity;
  SPI_CPHATypeDef CLKPhase;
  SPI_NSSModeTypeDef NSS;
  uint16_t BaudRatePrescaler; // 例如 SPI_BAUDRATEPRESCALER_2, SPI_BAUDRATEPRESCALER_4, ...
  uint16_t FirstBit;        // 例如 SPI_FIRSTBIT_MSB, SPI_FIRSTBIT_LSB
  uint16_t TIMEOUT;          // 超时时间，可选
} SPI_InitTypeDef;

void HAL_SPI_Init(SPI_InitTypeDef* SPI_Init);
uint8_t HAL_SPI_TransmitReceive(SPI_TypeDef* SPIx, uint8_t TxData);
void HAL_SPI_Transmit(SPI_TypeDef* SPIx, uint8_t *pData, uint16_t Size);
void HAL_SPI_Receive(SPI_TypeDef* SPIx, uint8_t *pData, uint16_t Size);

#endif /* HAL_SPI_H */
  • HAL_SPI.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include "HAL_SPI.h"

void HAL_SPI_Init(SPI_InitTypeDef* SPI_Init) {
  SPI_TypeDef* SPIx = SPI_Init->SPIx;

  if (SPIx == SPI1) {
    RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
  } else if (SPIx == SPI2) {
    RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;
  } // ... 其他SPI端口使能

  /* ----------------------- SPIx CR1 Configuration --------------------- */
  /* Configure SPI mode */
  if (SPI_Init->Mode == SPI_MODE_MASTER) {
    SPIx->CR1 |= SPI_CR1_MSTR;
  } else {
    SPIx->CR1 &= ~SPI_CR1_MSTR;
  }

  /* Configure direction mode */
  if (SPI_Init->Direction == SPI_DIRECTION_2LINES_FULLDUPLEX) {
    SPIx->CR1 &= ~SPI_CR1_BIDIMODE; // 双线全双工
  } else if (SPI_Init->Direction == SPI_DIRECTION_2LINES_RXONLY) {
    SPIx->CR1 &= ~SPI_CR1_BIDIMODE; // 双线接收
    SPIx->CR1 |= SPI_CR1_RXONLY;
  } else if (SPI_Init->Direction == SPI_DIRECTION_1LINE_TX) {
    SPIx->CR1 |= SPI_CR1_BIDIMODE; // 单线双向模式
    SPIx->CR1 |= SPI_CR1_BIDIOE;  // 输出使能
  } else if (SPI_Init->Direction == SPI_DIRECTION_1LINE_RX) {
    SPIx->CR1 |= SPI_CR1_BIDIMODE; // 单线双向模式
    SPIx->CR1 &= ~SPI_CR1_BIDIOE; // 输入使能
  }

  /* Configure data size */
  if (SPI_Init->DataSize == SPI_DATASIZE_16BIT) {
    SPIx->CR1 |= SPI_CR1_DFF;
  } else {
    SPIx->CR1 &= ~SPI_CR1_DFF;
  }

  /* Configure clock polarity CPOL */
  if (SPI_Init->CLKPolarity == SPI_CPOL_HIGH) {
    SPIx->CR1 |= SPI_CR1_CPOL;
  } else {
    SPIx->CR1 &= ~SPI_CR1_CPOL;
  }

  /* Configure clock phase CPHA */
  if (SPI_Init->CLKPhase == SPI_CPHA_2EDGE) {
    SPIx->CR1 |= SPI_CR1_CPHA;
  } else {
    SPIx->CR1 &= ~SPI_CR1_CPHA;
  }

  /* Configure NSS management */
  if (SPI_Init->NSS == SPI_NSS_SOFT) {
    SPIx->CR1 |= SPI_CR1_SSM;  // 软件NSS管理
    SPIx->CR1 |= SPI_CR1_SSI;  // NSS内部信号设置为高电平 (软件控制NSS时，需要设置为高电平)
  } else if (SPI_Init->NSS == SPI_NSS_HARD_OUTPUT) {
    SPIx->CR2 &= ~SPI_CR2_SSOE; // 硬件NSS输出禁用 (如果需要硬件NSS输出，则使能SSOE)
  } else if (SPI_Init->NSS == SPI_NSS_HARD_INPUT) {
    // 硬件NSS输入，无需特殊配置，默认即可
  }

  /* Configure Baud Rate Prescaler */
  SPIx->CR1 &= ~SPI_CR1_BR; // 清除之前的波特率分频
  SPIx->CR1 |= SPI_Init->BaudRatePrescaler; // 设置新的波特率分频

  /* Configure First Bit */
  if (SPI_Init->FirstBit == SPI_FIRSTBIT_LSB) {
    SPIx->CR1 |= SPI_CR1_LSBFIRST;
  } else {
    SPIx->CR1 &= ~SPI_CR1_LSBFIRST;
  }

  /* Enable SPI */
  SPIx->CR1 |= SPI_CR1_SPE;
}

uint8_t HAL_SPI_TransmitReceive(SPI_TypeDef* SPIx, uint8_t TxData) {
  volatile uint8_t RxData;
  /* Transmit Data */
  SPIx->DR = TxData;
  /* Wait until transmit finished */
  while (!(SPIx->SR & SPI_SR_TXE));
  /* Wait until receive finished */
  while (!(SPIx->SR & SPI_SR_RXNE));
  /* Read data from DR */
  RxData = SPIx->DR;
  return RxData;
}

void HAL_SPI_Transmit(SPI_TypeDef* SPIx, uint8_t *pData, uint16_t Size) {
  while (Size--) {
    /* Wait until transmit finished */
    while (!(SPIx->SR & SPI_SR_TXE));
    /* Transmit Data */
    SPIx->DR = (*pData++);
  }
}

void HAL_SPI_Receive(SPI_TypeDef* SPIx, uint8_t *pData, uint16_t Size) {
  while (Size--) {
    /* Wait until receive finished */
    while (!(SPIx->SR & SPI_SR_RXNE));
    /* Read data from DR */
    *pData++ = SPIx->DR;
  }
}

2. 驱动层 (RC522_Driver.h, RC522_Driver.c)

  • RC522_Driver.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#ifndef RC522_DRIVER_H
#define RC522_DRIVER_H

#include "stm32l0xx.h"
#include "HAL_GPIO.h"
#include "HAL_SPI.h"

// RC522 寄存器地址定义
#define RC522_REG_COMMAND         0x01
#define RC522_REG_COMIEN          0x02
#define RC522_REG_DIVIREQ         0x03
#define RC522_REG_STATUS2         0x08
#define RC522_REG_FIFO_DATA       0x09
#define RC522_REG_FIFO_LEVEL      0x0A
#define RC522_REG_WATER_LEVEL     0x0B
#define RC522_REG_CONTROL         0x0C
#define RC522_REG_MODE2           0x11
#define RC522_REG_MODWIDTH        0x24
#define RC522_REG_RFCFG           0x26
#define RC522_REG_GSNCONFIG       0x27
#define RC522_REG_CWGSNPD         0x28
#define RC522_REG_MODGSNPD        0x29
#define RC522_REG_RXTHRESHOLD     0x30
#define RC522_REG_DEMOD           0x31
#define RC522_REG_MIFARE           0x37
#define RC522_REG_FIFO_BUFFER_SIZE 64

// RC522 命令定义
#define RC522_CMD_IDLE            0x00
#define RC522_CMD_MEM             0x01
#define RC522_CMD_AUTHENT         0x0E
#define RC522_CMD_RECEIVE         0x08
#define RC522_CMD_TRANSMIT        0x04
#define RC522_CMD_TRANSCEIVE      0x0C
#define RC522_CMD_RESETPHASE      0x0F
#define RC522_CMD_CALIBRATE       0xC1
#define RC522_CMD_CLEAR           0x02
#define RC522_CMD_CRC             0x03
#define RC522_CMD_MFAuthent       0x0E
#define RC522_CMD_SoftReset       0x1F

// RC522 卡片类型定义
#define RC522_PICC_REQIDL         0x26  // 寻卡，卡片进入待命状态
#define RC522_PICC_REQALL         0x52  // 寻卡，寻所有卡片
#define RC522_PICC_ANTICOLL       0x93  // 防冲突
#define RC522_PICC_SELECTTAG      0x93  // 选卡
#define RC522_PICC_AUTHENT1A      0x60  // 密码验证A
#define RC522_PICC_AUTHENT1B      0x61  // 密码验证B
#define RC522_PICC_READ           0x30  // 读块
#define RC522_PICC_WRITE          0xA0  // 写块
#define RC522_PICC_HALT           0x50  // 休眠

// RC522 引脚定义 (根据硬件连接修改)
#define RC522_SPI_CS_PORT       GPIOA
#define RC522_SPI_CS_PIN        GPIO_PIN_4
#define RC522_SPI_RST_PORT      GPIOA
#define RC522_SPI_RST_PIN       GPIO_PIN_5

// RC522 SPI配置 (根据硬件连接修改)
#define RC522_SPI             SPI1
#define RC522_SPI_BAUDRATE_PRESCALER SPI_BAUDRATEPRESCALER_8 // 适当降低SPI速度，提高稳定性

void RC522_Init(void);
uint8_t RC522_ReadRegister(uint8_t address);
void RC522_WriteRegister(uint8_t address, uint8_t value);
void RC522_SetBitMask(uint8_t reg, uint8_t mask);
void RC522_ClearBitMask(uint8_t reg, uint8_t mask);
uint8_t RC522_Anticoll(uint8_t *serNum);
uint8_t RC522_Request(uint8_t reqMode, uint8_t *TagType);
uint8_t RC522_SelectTag(uint8_t *serNum);
uint8_t RC522_Auth(uint8_t authMode, uint8_t BlockAddr, uint8_t *Sectorkey, uint8_t *serNum);
uint8_t RC522_ReadBlock(uint8_t blockAddr, uint8_t *recvData);
uint8_t RC522_WriteBlock(uint8_t blockAddr, uint8_t *writeData);
void RC522_Halt(void);
uint8_t RC522_Reset(void);
uint8_t RC522_CalculateCRC(uint8_t *pIndata, uint8_t len, uint8_t *pOutdata);
uint8_t RC522_PcdComMF522(uint8_t command, uint8_t *pInData, uint8_t inLenByte, uint8_t *pOutData, uint32_t  *pOutLenBit);
uint8_t RC522_MFRC522ToCard(uint8_t command, uint8_t *sendData, uint8_t sendLen, uint8_t *backData, uint32_t *backLen);
uint8_t RC522_CardToMFRC522(uint8_t command, uint8_t *sendData, uint8_t sendLen, uint8_t *backData, uint32_t *backLen);

#endif /* RC522_DRIVER_H */
  • RC522_Driver.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
#include "RC522_Driver.h"
#include "delay.h" // 假设有delay函数

// 初始化RC522
void RC522_Init(void) {
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  SPI_InitTypeDef SPI_InitStruct = {0};

  // 1. 初始化CS引脚和RST引脚作为GPIO输出
  GPIO_InitStruct.GPIOx = RC522_SPI_CS_PORT;
  GPIO_InitStruct.GPIO_Pin = RC522_SPI_CS_PIN;
  GPIO_InitStruct.GPIO_Mode = GPIO_MODE_OUTPUT;
  GPIO_InitStruct.GPIO_Pull = GPIO_PULLUP; // 上拉，默认CS高电平
  GPIO_InitStruct.GPIO_Speed = GPIO_SPEED_VERY_HIGH;
  HAL_GPIO_Init(&GPIO_InitStruct);

  GPIO_InitStruct.GPIOx = RC522_SPI_RST_PORT;
  GPIO_InitStruct.GPIO_Pin = RC522_SPI_RST_PIN;
  GPIO_InitStruct.GPIO_Mode = GPIO_MODE_OUTPUT;
  GPIO_InitStruct.GPIO_Pull = GPIO_PULLDOWN; // 下拉，默认RST低电平
  GPIO_InitStruct.GPIO_Speed = GPIO_SPEED_VERY_HIGH;
  HAL_GPIO_Init(&GPIO_InitStruct);

  // 2. 初始化SPI接口
  SPI_InitStruct.SPIx = RC522_SPI;
  SPI_InitStruct.Mode = SPI_MODE_MASTER;
  SPI_InitStruct.Direction = SPI_DIRECTION_2LINES_FULLDUPLEX;
  SPI_InitStruct.DataSize = SPI_DATASIZE_8BIT;
  SPI_InitStruct.CLKPolarity = SPI_CPOL_LOW;   // SPI模式0
  SPI_InitStruct.CLKPhase = SPI_CPHA_1EDGE;   // SPI模式0
  SPI_InitStruct.NSS = SPI_NSS_SOFT;         // 软件NSS管理
  SPI_InitStruct.BaudRatePrescaler = RC522_SPI_BAUDRATE_PRESCALER;
  SPI_InitStruct.FirstBit = SPI_FIRSTBIT_MSB;
  HAL_SPI_Init(&SPI_InitStruct);

  // 3. RC522 硬件复位
  HAL_GPIO_WritePin(RC522_SPI_RST_PORT, RC522_SPI_RST_PIN, GPIO_PIN_RESET);
  delay_ms(1); // 至少100us
  HAL_GPIO_WritePin(RC522_SPI_RST_PORT, RC522_SPI_RST_PIN, GPIO_PIN_SET);
  delay_ms(1); // 至少10ms，等待RC522初始化完成

  // 4. 软件复位RC522
  RC522_Reset();

  // 5. 设置发送和接收时的调制解调器参数
  RC522_WriteRegister(RC522_REG_TMODEREG, 0x8D);      // TModeReg[3..0]=’1001’, TAuto=1, TPrescaler=0, TMode=‘10’
  RC522_WriteRegister(RC522_REG_TPRESCALERREG, 0x3F);  // TPrescalerReg[3..0]=’010111’, TPreScaler=0101b, TAuto=1, f(Timer) = 13.56MHz/2^12 = 3.34kHz
  RC522_WriteRegister(RC522_REG_TRELOADHIREG, 0x00);   // THReloadH=0x00
  RC522_WriteRegister(RC522_REG_TRELOADLOREG, 0x00);   // TReloadL=0x00
  RC522_WriteRegister(RC522_REG_TXAUTOTAREG, 0x40);    // 默认值

  // 6. 设置天线驱动增益为最大
  RC522_SetBitMask(RC522_REG_RFCFG, 0x7C);

  // 7. 打开天线
  RC522_AntennaOn();
}

// 读取RC522寄存器
uint8_t RC522_ReadRegister(uint8_t address) {
  uint8_t val;
  HAL_GPIO_WritePin(RC522_SPI_CS_PORT, RC522_SPI_CS_PIN, GPIO_PIN_RESET); // CS拉低，片选RC522
  HAL_SPI_TransmitReceive(RC522_SPI, ((address << 1) & 0x7E) | 0x80); // 发送地址，读命令，高位为1
  val = HAL_SPI_TransmitReceive(RC522_SPI, 0x00);                     // 读取数据
  HAL_GPIO_WritePin(RC522_SPI_CS_PORT, RC522_SPI_CS_PIN, GPIO_PIN_SET);  // CS拉高，释放SPI总线
  return val;
}

// 写入RC522寄存器
void RC522_WriteRegister(uint8_t address, uint8_t value) {
  HAL_GPIO_WritePin(RC522_SPI_CS_PORT, RC522_SPI_CS_PIN, GPIO_PIN_RESET); // CS拉低，片选RC522
  HAL_SPI_TransmitReceive(RC522_SPI, ((address << 1) & 0x7E));        // 发送地址，写命令，高位为0
  HAL_SPI_TransmitReceive(RC522_SPI, value);                           // 发送数据
  HAL_GPIO_WritePin(RC522_SPI_CS_PORT, RC522_SPI_CS_PIN, GPIO_PIN_SET);  // CS拉高，释放SPI总线
}

// 设置RC522寄存器位
void RC522_SetBitMask(uint8_t reg, uint8_t mask) {
  uint8_t tmp;
  tmp = RC522_ReadRegister(reg);
  RC522_WriteRegister(reg, tmp | mask); // set bit mask
}

// 清除RC522寄存器位
void RC522_ClearBitMask(uint8_t reg, uint8_t mask) {
  uint8_t tmp;
  tmp = RC522_ReadRegister(reg);
  RC522_WriteRegister(reg, tmp & (~mask)); // clear bit mask
}

// RC522 复位
uint8_t RC522_Reset(void) {
  RC522_WriteRegister(RC522_REG_COMMAND, RC522_CMD_SoftReset);
  return 0;
}

// 开启天线
void RC522_AntennaOn(void) {
  uint8_t temp;
  temp = RC522_ReadRegister(RC522_REG_TXCONTROLREG);
  if (!(temp & 0x03)) {
    RC522_SetBitMask(RC522_REG_TXCONTROLREG, 0x03);
  }
}

// 关闭天线
void RC522_AntennaOff(void) {
  RC522_ClearBitMask(RC522_REG_TXCONTROLREG, 0x03);
}

// 请求卡片
uint8_t RC522_Request(uint8_t reqMode, uint8_t *TagType) {
  uint8_t status;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];

  RC522_ClearBitMask(RC522_REG_STATUS2, 0x08); // 清除错误位
  RC522_WriteRegister(RC522_REG_BITFRAMING, 0x07); // 发送字节的bit数
  RC522_SetBitMask(RC522_REG_TXCONTROLREG, 0x03); // 开启天线发射

  ucComMF522Buf[0] = reqMode; // 寻卡命令

  status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 1, ucComMF522Buf, &unLen);
  if ((status == 0) && (unLen == 0x10)) { // 寻卡成功
    *TagType = ucComMF522Buf[0];
    status = 0;
  } else {
    status = 1; // 寻卡失败
  }

  return status;
}

// 防冲突检测，返回卡片序列号
uint8_t RC522_Anticoll(uint8_t *serNum) {
  uint8_t status;
  uint8_t i;
  uint8_t serNumCheck = 0;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];

  RC522_ClearBitMask(RC522_REG_STATUS2, 0x08); // 清除错误位
  RC522_WriteRegister(RC522_REG_BITFRAMING, 0x00); // 发送字节的bit数
  RC522_ClearBitMask(RC522_REG_COMIEN, 0x80);    // 禁止所有中断

  ucComMF522Buf[0] = RC522_PICC_ANTICOLL; // 防冲突命令
  ucComMF522Buf[1] = 0x93;

  status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, &unLen);
  if (status == 0) {
    for (i = 0; i < 5; i++) {
      serNum[i] = ucComMF522Buf[i];
      serNumCheck ^= ucComMF522Buf[i];
    }
    if (serNumCheck != ucComMF522Buf[4]) {
      status = 1; // 校验失败
    }
  }

  return status;
}

// 选卡，根据序列号选择卡片
uint8_t RC522_SelectTag(uint8_t *serNum) {
  uint8_t status;
  uint8_t i;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];

  ucComMF522Buf[0] = RC522_PICC_SELECTTAG; // 选卡命令
  ucComMF522Buf[1] = 0x93;
  ucComMF522Buf[2] = 0x70;
  ucComMF522Buf[3] = serNum[0];
  ucComMF522Buf[4] = serNum[1];
  ucComMF522Buf[5] = serNum[2];
  ucComMF522Buf[6] = serNum[3];
  ucComMF522Buf[7] = serNum[4];

  status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 8, ucComMF522Buf, &unLen);
  if ((status == 0) && (unLen == 0x18)) { // 选卡成功
    status = 0;
  } else {
    status = 1; // 选卡失败
  }

  return status;
}

// 卡片认证
uint8_t RC522_Auth(uint8_t authMode, uint8_t BlockAddr, uint8_t *Sectorkey, uint8_t *serNum) {
  uint8_t status;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];
  uint8_t i;

  ucComMF522Buf[0] = authMode; // 认证模式 (A密钥或B密钥)
  ucComMF522Buf[1] = BlockAddr; // 块地址
  for (i = 0; i < 6; i++) {     // 密钥
    ucComMF522Buf[2 + i] = Sectorkey[i];
  }
  for (i = 0; i < 5; i++) {     // 卡片序列号
    ucComMF522Buf[8 + i] = serNum[i];
  }

  status = RC522_MFRC522ToCard(RC522_CMD_AUTHENT, ucComMF522Buf, 12, ucComMF522Buf, &unLen);
  if ((status == 0) && (!(RC522_ReadRegister(RC522_REG_STATUS2) & 0x08))) { // 认证成功
    status = 0;
  } else {
    status = 1; // 认证失败
  }

  return status;
}

// 读取Mifare卡块数据
uint8_t RC522_ReadBlock(uint8_t blockAddr, uint8_t *recvData) {
  uint8_t status;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];

  ucComMF522Buf[0] = RC522_PICC_READ; // 读块命令
  ucComMF522Buf[1] = blockAddr;      // 块地址

  status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, &unLen);
  if ((status == 0) && (unLen == 0x90)) { // 读取成功，16字节数据
    for (int i = 0; i < 16; i++) {
      recvData[i] = ucComMF522Buf[i];
    }
    status = 0;
  } else {
    status = 1; // 读取失败
  }

  return status;
}

// 写入Mifare卡块数据
uint8_t RC522_WriteBlock(uint8_t blockAddr, uint8_t *writeData) {
  uint8_t status;
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];
  uint8_t i;

  ucComMF522Buf[0] = RC522_PICC_WRITE; // 写块命令
  ucComMF522Buf[1] = blockAddr;       // 块地址

  status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, &unLen);
  if ((status == 0) && (unLen == 0x08)) { // 准备写入数据，接收到ACK
    for (i = 0; i < 16; i++) {         // 16字节数据
      ucComMF522Buf[i] = writeData[i];
    }
    status = RC522_MFRC522ToCard(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 16, ucComMF522Buf, &unLen);
    if ((status == 0) && (unLen == 0x08)) { // 写入成功，接收到ACK
      status = 0;
    } else {
      status = 1; // 写入失败
    }
  } else {
    status = 1; // 写入失败
  }

  return status;
}

// 命令卡片进入休眠状态
void RC522_Halt(void) {
  uint32_t unLen;
  uint8_t ucComMF522Buf[RC522_FIFO_BUFFER_SIZE];

  ucComMF522Buf[0] = RC522_PICC_HALT; // 休眠命令
  ucComMF522Buf[1] = 0x00;
  RC522_CardToMFRC522(RC522_CMD_TRANSCEIVE, ucComMF522Buf, 2, NULL, &unLen);
}

// 计算CRC校验码
uint8_t RC522_CalculateCRC(uint8_t *pIndata, uint8_t len, uint8_t *pOutdata) {
  uint8_t i, n;

  RC522_ClearBitMask(RC522_REG_DIVIREQ, 0x04); // CRCIrqOff = 0
  RC522_SetBitMask(RC522_REG_FIFOLEVELREG, 0x80); // 清FIFO指针
  //FIFO写数据
  for (i = 0; i < len; i++) {
    RC522_WriteRegister(RC522_REG_FIFO_DATA, *(pIndata + i));
  }
  //执行CRC运算
  RC522_WriteRegister(RC522_REG_COMMAND, RC522_CMD_CRC);
  i = 0xFF;
  do {
    n = RC522_ReadRegister(RC522_REG_DIVIREQ);
    i--;
  } while ((i != 0) && (!(n & 0x04))); // 等待CRC运算完成

  pOutdata[0] = RC522_ReadRegister(RC522_REG_CRCRESULTLREG); // 读取CRC校验结果低8位
  pOutdata[1] = RC522_ReadRegister(RC522_REG_CRCRESULTHIREG); // 读取CRC校验结果高8位

  return 0;
}

// MFRC522 和 ISO14443 卡通讯
uint8_t RC522_MFRC522ToCard(uint8_t command, uint8_t *pInData, uint8_t inLenByte, uint8_t *pOutData, uint32_t  *pOutLenBit) {
  uint8_t status = 0;
  uint8_t irqEn = 0x00;
  uint8_t waitIRq = 0x00;
  uint8_t lastBits;
  uint8_t n;
  uint32_t i;

  switch (command) {
    case RC522_CMD_AUTHENT:    // 认证卡片密码
      irqEn = 0x12;  // RxIEn and IdleIEn
      waitIRq = 0x10; // IdleIRq
      break;
    case RC522_CMD_TRANSCEIVE: // 发送并接收数据
      irqEn = 0x77;  // RxIEn and TxIEn and IdleIEn and LoAlertIen and ErrIen and TimerIEn
      waitIRq = 0x30; // RxIRq and IdleIRq
      break;
    default:
      break;
  }

  RC522_WriteRegister(RC522_REG_COMIEN, irqEn | 0x80); // IRQ enable
  RC522_ClearBitMask(RC522_REG_CONTROL, 0x1B);        // FIFO and Buffer clear,停止收发器
  RC522_SetBitMask(RC522_REG_FIFOLEVELREG, 0x80);    // FIFO pointer clear

  for (i = 0; i < inLenByte; i++) {
    RC522_WriteRegister(RC522_REG_FIFO_DATA, pInData[i]); // 数据写入FIFO
  }

  RC522_WriteRegister(RC522_REG_COMMAND, RC522_CMD_TRANSCEIVE); // 执行命令
  RC522_SetBitMask(RC522_REG_BITFRAMING, 0x00); // BitFraming = 0

  i = 2000; // 根据实际情况调整超时时间，这里设置为一个较大的值
  do {
    // 状态寄存器Status1[bit7..0]
    // bit7:   TxIRq  发送完成中断请求
    // bit6:   RxIRq  接收完成中断请求
    // bit5:   IdleIRq 空闲中断请求
    // bit4:   HiAlertIRq 高优先级中断请求
    // bit3:   LoAlertIRq 低优先级中断请求
    // bit2:   ErrIRq   错误中断请求
    // bit1:   TimerIRq 定时器中断请求
    // bit0:   SoftIRq  软件中断请求
    n = RC522_ReadRegister(RC522_REG_STATUS1);
    i--;
  } while ((i != 0) && (!((n & 0x01) || (n & waitIRq)))); // 等待接收或空闲中断

  RC522_ClearBitMask(RC522_REG_BITFRAMING, 0x00); // BitFraming = 0

  if (i != 0) {
    if (!(RC522_ReadRegister(RC522_REG_ERRORREG) & 0x1B)) { // 无错误
      status = 0;
      if (command == RC522_CMD_TRANSCEIVE) {
        n = RC522_ReadRegister(RC522_REG_FIFOLEVELREG); // 读取FIFO数据长度
        lastBits = RC522_ReadRegister(RC522_REG_CONTROL) & 0x07;
        if (lastBits) {
          *pOutLenBit = (n - 1) * 8 + lastBits;
        } else {
          *pOutLenBit = n * 8;
        }
        if (n == 0) {
          n = 1;
        }
        if (n > RC522_FIFO_BUFFER_SIZE) {
          n = RC522_FIFO_BUFFER_SIZE; // 防止溢出
        }
        for (i = 0; i < n; i++) {
          pOutData[i] = RC522_ReadRegister(RC522_REG_FIFO_DATA); // 读取FIFO数据
        }
      }
    } else {
      status = 1; // 错误发生
    }
  }

  RC522_SetBitMask(RC522_REG_CONTROL, 0x1B); // FIFO and Buffer clear, 停止收发器
  RC522_ClearBitMask(RC522_REG_COMIEN, 0x80);    // 禁止所有中断

  return status;
}

// 卡片到MFRC522的命令
uint8_t RC522_CardToMFRC522(uint8_t command, uint8_t *sendData, uint8_t sendLen, uint8_t *backData, uint32_t *backLen) {
    uint8_t status = 0;
    uint8_t irqEn = 0x00;
    uint8_t waitIRq = 0x00;
    uint8_t lastBits;
    uint8_t n;
    uint32_t i;

    switch (command) {
        case RC522_CMD_MFAuthent:		//Mifare认证
            irqEn = 0x12;		//ModemIRQ标志位中断请求允许
            waitIRq = 0x10;		//CommIRq标志位中断请求
            break;
        case RC522_CMD_TRANSCEIVE:	//发送FIFO中数据
            irqEn = 0x77;		//ModemIRQ标志位中断请求
            waitIRq = 0x30;		//CommIRq标志位中断请求
            break;
        default:
            break;
    }

    RC522_WriteRegister(RC522_REG_COMIEN, irqEn|0x80);			//允许中断请求
    RC522_ClearBitMask(RC522_REG_COMMAND, 0x1B);		            //清除CommIrq bit, 启动收发器发送和接收。
    RC522_SetBitMask(RC522_REG_FIFOLEVELREG, 0x80);		        //清空FIFO

    RC522_WriteRegister(RC522_REG_FIFO_DATA, command);
    for (i=0; i<sendLen; i++)
    {
        RC522_WriteRegister(RC522_REG_FIFO_DATA, sendData[i]);    //load发送数据
    }
    RC522_WriteRegister(RC522_REG_COMMAND, RC522_CMD_MEM);		    //执行命令

    if (sendLen)
	{
		RC522_SetBitMask(RC522_REG_BITFRAMING, 0x00);		//设置传送帧起始位
	}else
	{
		RC522_SetBitMask(RC522_REG_BITFRAMING, 0x80);		//StartSend=1,transmission of command
	}

    i = 2000;//根据时钟频率调整，操作M1卡最大等待时间25ms
    do
    {
        n = RC522_ReadRegister(RC522_REG_STATUS1);
        i--;
    }while ((i!=0) && (!((n&0x01)||(n&waitIRq))));			//等待发送结束

    RC522_ClearBitMask(RC522_REG_BITFRAMING, 0x00);			//清传送帧起始位

    if(i!=0)
    {
        if(!(RC522_ReadRegister(RC522_REG_ERRORREG)&0x1B))	//读Errorreg寄存器，清错误标志
        {
            status = 0;
            if (backData)
            {
                n = RC522_ReadRegister(RC522_REG_FIFOLEVELREG);	    //读FIFO中接收到的数据的长度
                lastBits = RC522_ReadRegister(RC522_REG_CONTROL)&0x07;
                if (lastBits)
                {
                    *backLen = (n-1)*8 + lastBits;
                }
                else
                {
                    *backLen = n*8;
                }

                if(n==0)
                    n=1;
                for (i=0; i<n; i++)
                {
                    backData[i] = RC522_ReadRegister(RC522_REG_FIFO_DATA);   //读FIFO接收数据
                }
            }
        }
        else
        {
            status = 1;
        }

    }

    RC522_SetBitMask(RC522_REG_CONTROL, 0x1B);			//清除CommIrq bit
    RC522_ClearBitMask(RC522_REG_COMIEN, 0x80);			//禁止中断

    return status;
}

3. 服务层 (CardRW_Service.h, CardRW_Service.c, CardData_Service.h, CardData_Service.c)

  • CardRW_Service.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#ifndef CARD_RW_SERVICE_H
#define CARD_RW_SERVICE_H

#include "stdint.h"

typedef struct {
    uint8_t uid[5]; // 卡片UID
    uint8_t data[1024]; // 卡片数据 (假设最大1K卡)
    uint16_t data_len; // 卡片数据长度
    char card_name[32]; // 卡片名称
    // ... 其他卡片信息
} CardInfo_t;

typedef enum {
    CARD_RW_OK = 0,
    CARD_RW_ERROR,
    CARD_RW_NO_CARD,
    CARD_RW_AUTH_ERROR,
    CARD_RW_READ_ERROR,
    CARD_RW_WRITE_ERROR,
    // ... 其他错误码
} CardRWStatus_t;

CardRWStatus_t CardRW_ReadCard(CardInfo_t *cardInfo);
CardRWStatus_t CardRW_WriteCard(const CardInfo_t *cardInfo);
CardRWStatus_t CardRW_EmulateCard(const CardInfo_t *cardInfo);

#endif /* CARD_RW_SERVICE_H */
  • CardRW_Service.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include "CardRW_Service.h"
#include "RC522_Driver.h"
#include "string.h" // for memcpy

// 密钥，实际项目中需要加密存储和管理
static const uint8_t MifareDefaultKeyA[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

// 读取卡片信息
CardRWStatus_t CardRW_ReadCard(CardInfo_t *cardInfo) {
    uint8_t status;
    uint8_t tagType[1];
    uint8_t serNum[5];
    uint8_t blockData[16];
    uint16_t data_offset = 0;

    // 1. 寻卡
    status = RC522_Request(RC522_PICC_REQIDL, tagType);
    if (status != 0) {
        return CARD_RW_NO_CARD; // 未寻到卡
    }

    // 2. 防冲突，获取UID
    status = RC522_Anticoll(serNum);
    if (status != 0) {
        return CARD_RW_ERROR; // 防冲突失败
    }
    memcpy(cardInfo->uid, serNum, 5);

    // 3. 选卡
    status = RC522_SelectTag(serNum);
    if (status != 0) {
        return CARD_RW_ERROR; // 选卡失败
    }

    // 4. 循环读取所有扇区和块 (Mifare Classic 1K 示例，需要根据实际卡类型调整)
    for (uint8_t sector = 0; sector < 16; sector++) { // 16个扇区
        for (uint8_t block = 0; block < 4; block++) { // 每个扇区4个块
            uint8_t blockAddr = sector * 4 + block;
            if (blockAddr > 63) break; // 超出1K卡范围

            // 4.1. 认证 (假设使用默认密钥A，实际项目需要考虑密钥管理)
            status = RC522_Auth(RC522_PICC_AUTHENT1A, blockAddr, (uint8_t*)MifareDefaultKeyA, serNum);
            if (status != 0) {
                // 认证失败，尝试B密钥或其他密钥策略，这里简化处理
                return CARD_RW_AUTH_ERROR;
            }

            // 4.2. 读取块数据
            status = RC522_ReadBlock(blockAddr, blockData);
            if (status != 0) {
                RC522_Halt(); // 读卡失败，停止操作
                return CARD_RW_READ_ERROR;
            }

            // 4.3. 保存数据到cardInfo
            memcpy(&cardInfo->data[data_offset], blockData, 16);
            data_offset += 16;
        }
    }
    cardInfo->data_len = data_offset;

    // 5. 停止卡片操作
    RC522_Halt();

    return CARD_RW_OK;
}

// 写入卡片信息 (模拟写卡，实际项目需要谨慎实现)
CardRWStatus_t CardRW_WriteCard(const CardInfo_t *cardInfo) {
    // ... (写入卡片的实现，需要考虑权限和安全性，此处省略，实际项目谨慎实现)
    return CARD_RW_ERROR; // 暂时返回错误，表示未实现
}

// 模拟卡片 (OV-Card的核心功能，需要更深入的协议分析和实现)
CardRWStatus_t CardRW_EmulateCard(const CardInfo_t *cardInfo) {
    // ... (卡片模拟的实现，需要深入理解ISO14443协议和Mifare协议，此处为框架，实际项目需要大量工作)
    // 1. 初始化RC522为模拟模式 (如果RC522支持，或者需要外部模拟芯片)
    // 2. 监听读卡器发出的指令
    // 3. 根据指令，模拟卡片响应 (例如UID, 数据块)
    // ...
    return CARD_RW_ERROR; // 暂时返回错误，表示未实现
}
  • CardData_Service.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#ifndef CARD_DATA_SERVICE_H
#define CARD_DATA_SERVICE_H

#include "CardRW_Service.h"
#include "stdint.h"

#define MAX_CARD_NUM 20 // 最大存储卡片数量

typedef struct {
    CardInfo_t cards[MAX_CARD_NUM];
    uint8_t card_count;
    uint8_t current_card_index; // 当前选择的卡片索引
} CardDatabase_t;

typedef enum {
    CARD_DATA_OK = 0,
    CARD_DATA_ERROR,
    CARD_DATA_FULL,
    CARD_DATA_NOT_FOUND,
    // ... 其他错误码
} CardDataStatus_t;

CardDataStatus_t CardData_Init(void);
CardDataStatus_t CardData_AddCard(const CardInfo_t *cardInfo);
CardDataStatus_t CardData_DeleteCard(uint8_t cardIndex);
CardDataStatus_t CardData_GetCard(uint8_t cardIndex, CardInfo_t *cardInfo);
CardDataStatus_t CardData_SetCurrentCard(uint8_t cardIndex);
CardDataStatus_t CardData_GetCurrentCard(CardInfo_t *cardInfo);
uint8_t CardData_GetCardCount(void);

#endif /* CARD_DATA_SERVICE_H */
  • CardData_Service.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include "CardData_Service.h"
#include "string.h" // for memcpy, memset
#include "flash_storage.h" // 假设有flash存储驱动

// 卡片数据库 (存储在RAM中，实际项目需要存储在Flash中)
static CardDatabase_t cardDatabase;
static const char CARD_DATABASE_STORAGE_KEY[] = "card_db"; // Flash存储Key

// 初始化卡片数据库
CardDataStatus_t CardData_Init(void) {
    // 从Flash加载卡片数据库
    if (FlashStorage_Read(CARD_DATABASE_STORAGE_KEY, &cardDatabase, sizeof(CardDatabase_t)) == FLASH_STORAGE_OK) {
        // 加载成功
    } else {
        // 加载失败，初始化为空数据库
        memset(&cardDatabase, 0, sizeof(CardDatabase_t));
        cardDatabase.card_count = 0;
        cardDatabase.current_card_index = 0;
    }
    return CARD_DATA_OK;
}

// 添加卡片到数据库
CardDataStatus_t CardData_AddCard(const CardInfo_t *cardInfo) {
    if (cardDatabase.card_count >= MAX_CARD_NUM) {
        return CARD_DATA_FULL; // 数据库已满
    }
    memcpy(&cardDatabase.cards[cardDatabase.card_count], cardInfo, sizeof(CardInfo_t));
    cardDatabase.card_count++;
    // 保存到Flash
    FlashStorage_Write(CARD_DATABASE_STORAGE_KEY, &cardDatabase, sizeof(CardDatabase_t));
    return CARD_DATA_OK;
}

// 删除卡片
CardDataStatus_t CardData_DeleteCard(uint8_t cardIndex) {
    if (cardIndex >= cardDatabase.card_count) {
        return CARD_DATA_NOT_FOUND; // 卡片索引无效
    }
    // 移动后续卡片覆盖被删除的卡片
    for (uint8_t i = cardIndex; i < cardDatabase.card_count - 1; i++) {
        memcpy(&cardDatabase.cards[i], &cardDatabase.cards[i + 1], sizeof(CardInfo_t));
    }
    cardDatabase.card_count--;
    // 保存到Flash
    FlashStorage_Write(CARD_DATABASE_STORAGE_KEY, &cardDatabase, sizeof(CardDatabase_t));
    return CARD_DATA_OK;
}

// 获取卡片信息
CardDataStatus_t CardData_GetCard(uint8_t cardIndex, CardInfo_t *cardInfo) {
    if (cardIndex >= cardDatabase.card_count) {
        return CARD_DATA_NOT_FOUND; // 卡片索引无效
    }
    memcpy(cardInfo, &cardDatabase.cards[cardIndex], sizeof(CardInfo_t));
    return CARD_DATA_OK;
}

// 设置当前卡片
CardDataStatus_t CardData_SetCurrentCard(uint8_t cardIndex) {
    if (cardIndex >= cardDatabase.card_count) {
        return CARD_DATA_NOT_FOUND; // 卡片索引无效
    }
    cardDatabase.current_card_index = cardIndex;
    return CARD_DATA_OK;
}

// 获取当前卡片信息
CardDataStatus_t CardData_GetCurrentCard(CardInfo_t *cardInfo) {
    if (cardDatabase.card_count == 0) {
        return CARD_DATA_NOT_FOUND; // 数据库为空
    }
    memcpy(cardInfo, &cardDatabase.cards[cardDatabase.current_card_index], sizeof(CardInfo_t));
    return CARD_DATA_OK;
}

// 获取卡片数量
uint8_t CardData_GetCardCount(void) {
    return cardDatabase.card_count;
}

4. 应用层 (main.c)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include "main.h"
#include "HAL_GPIO.h"
#include "HAL_SPI.h"
#include "RC522_Driver.h"
#include "CardRW_Service.h"
#include "CardData_Service.h"
#include "delay.h" // 假设有delay函数
#include "stdio.h" // for printf (debug)

// 定义LED指示灯引脚 (根据实际硬件连接修改)
#define LED_PORT   GPIOA
#define LED_PIN    GPIO_PIN_6

// 初始化系统
void SystemClock_Config(void);
void GPIO_Init_App(void);

int main(void) {
    // 1. 初始化HAL
    HAL_Init();

    // 2. 配置系统时钟
    SystemClock_Config();

    // 3. 初始化GPIO (包括LED指示灯)
    GPIO_Init_App();

    // 4. 初始化延迟函数 (如果使用)
    delay_init();

    // 5. 初始化RC522驱动
    RC522_Init();

    // 6. 初始化卡片数据服务
    CardData_Init();

    // 7. 主循环
    while (1) {
        // 示例：读取一张卡片并添加到数据库
        CardInfo_t newCard;
        CardRWStatus_t rwStatus;

        HAL_GPIO_TogglePin(LED_PORT, LED_PIN); // 指示程序运行中

        rwStatus = CardRW_ReadCard(&newCard);
        if (rwStatus == CARD_RW_OK) {
            printf("Card read successfully!\r\n");
            CardDataStatus_t dataStatus = CardData_AddCard(&newCard);
            if (dataStatus == CARD_DATA_OK) {
                printf("Card added to database.\r\n");
                // ... 可选：显示卡片名称等信息
            } else {
                printf("Error adding card to database: %d\r\n", dataStatus);
            }
        } else if (rwStatus == CARD_RW_NO_CARD) {
            // printf("No card detected.\r\n"); // 减少打印，降低功耗
        } else {
            printf("Card read error: %d\r\n", rwStatus);
        }

        delay_ms(1000); // 延时一段时间，降低循环频率
    }
}

// 系统时钟配置 (示例，根据实际需求调整)
void SystemClock_Config(void) {
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    /** Configure the main internal regulator output voltage
     */
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
    /** Initializes the RCC Oscillators according to the specified parameters
     * in the RCC_OscInitTypeDef structure.
     */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLLMUL_4;
    RCC_OscInitStruct.PLL.PLLDIV = RCC_PLLDIV_2;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        Error_Handler();
    }
    /** Initializes the CPU, AHB and APB buses clocks
     */
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
                                  | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) {
        Error_Handler();
    }
}

// GPIO 初始化 (应用层特定GPIO，例如LED)
void GPIO_Init_App(void) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    /* GPIO Ports Clock Enable */
    __HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA时钟

    /*Configure GPIO pin Output Level */
    HAL_GPIO_WritePin(LED_PORT, LED_PIN, GPIO_PIN_RESET); // 初始LED熄灭

    /*Configure GPIO pins : LED_PIN */
    GPIO_InitStruct.GPIOx = LED_PORT;
    GPIO_InitStruct.GPIO_Pin = LED_PIN;
    GPIO_InitStruct.GPIO_Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.GPIO_Pull = GPIO_NOPULL;
    GPIO_InitStruct.GPIO_Speed = GPIO_SPEED_LOW;
    HAL_GPIO_Init(&GPIO_InitStruct);
}

// 错误处理函数 (示例)
void Error_Handler(void) {
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    __disable_irq();
    while (1) {
        HAL_GPIO_TogglePin(LED_PORT, LED_PIN); // 错误时LED闪烁
        HAL_Delay(500);
    }
    /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

5. delay.h 和 delay.c (简单延时函数示例，实际项目可以使用更精确的定时器延时)

  • delay.h:
1
2
3
4
5
6
7
8
9
10
#ifndef DELAY_H
#define DELAY_H

#include "stm32l0xx_hal.h"

void delay_init(void);
void delay_ms(uint32_t nms);
void delay_us(uint32_t nus);

#endif /* DELAY_H */
  • delay.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "delay.h"

static uint32_t sysClkFreq;

void delay_init(void) {
    sysClkFreq = HAL_RCC_GetSysClockFreq();
}

void delay_ms(uint32_t nms) {
    HAL_Delay(nms); // 使用HAL库的延时函数，更精确
}

void delay_us(uint32_t nus) {
    uint32_t ticks = sysClkFreq / 1000000 * nus;
    uint32_t startTick = SysTick->VAL;
    while ((SysTick->VAL - startTick) < ticks); // 简单循环延时，精度不高
}

6. flash_storage.h 和 flash_storage.c (Flash存储驱动框架，实际项目需要根据STM32L0 Flash操作实现)

  • flash_storage.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef FLASH_STORAGE_H
#define FLASH_STORAGE_H

#include "stdint.h"

typedef enum {
    FLASH_STORAGE_OK = 0,
    FLASH_STORAGE_ERROR,
    FLASH_STORAGE_READ_ERROR,
    FLASH_STORAGE_WRITE_ERROR,
    FLASH_STORAGE_ERASE_ERROR,
    // ... 其他错误码
} FlashStorageStatus_t;

FlashStorageStatus_t FlashStorage_Init(void);
FlashStorageStatus_t FlashStorage_Read(const char *key, void *data, uint32_t size);
FlashStorageStatus_t FlashStorage_Write(const char *key, const void *data, uint32_t size);
FlashStorageStatus_t FlashStorage_Erase(const char *key);

#endif /* FLASH_STORAGE_H */
  • flash_storage.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include "flash_storage.h"
#include "string.h" // for strcmp

// 模拟Flash存储 (实际项目需要使用STM32L0 Flash操作API)
#define FLASH_STORAGE_SIZE 4096 // 假设Flash存储大小为4KB
static uint8_t flashStorage[FLASH_STORAGE_SIZE];

FlashStorageStatus_t FlashStorage_Init(void) {
    // ... 初始化Flash，例如解锁Flash，使能时钟等
    return FLASH_STORAGE_OK;
}

FlashStorageStatus_t FlashStorage_Read(const char *key, void *data, uint32_t size) {
    // ... 根据key计算Flash地址偏移，从Flash读取数据到data
    // 这里简化为直接从模拟Flash数组读取
    if (strcmp(key, "card_db") == 0) {
        if (size <= FLASH_STORAGE_SIZE) {
            memcpy(data, flashStorage, size);
            return FLASH_STORAGE_OK;
        } else {
            return FLASH_STORAGE_ERROR;
        }
    } else {
        return FLASH_STORAGE_ERROR; // Key not found
    }
}

FlashStorageStatus_t FlashStorage_Write(const char *key, const void *data, uint32_t size) {
    // ... 根据key计算Flash地址偏移，擦除Flash扇区，将data写入Flash
    // 这里简化为直接写入模拟Flash数组
    if (strcmp(key, "card_db") == 0) {
        if (size <= FLASH_STORAGE_SIZE) {
            memcpy(flashStorage, data, size);
            return FLASH_STORAGE_OK;
        } else {
            return FLASH_STORAGE_ERROR;
        }
    } else {
        return FLASH_STORAGE_ERROR; // Key not found
    }
}

FlashStorageStatus_t FlashStorage_Erase(const char *key) {
    // ... 根据key计算Flash地址偏移，擦除Flash扇区
    // 这里简化为清空模拟Flash数组
    if (strcmp(key, "card_db") == 0) {
        memset(flashStorage, 0, FLASH_STORAGE_SIZE);
        return FLASH_STORAGE_OK;
    } else {
        return FLASH_STORAGE_ERROR; // Key not found
    }
}

项目采用的关键技术和方法:

  • 分层架构和模块化设计: 提高代码可读性、可维护性和可复用性。
  • 硬件抽象层 (HAL): 增强代码的可移植性，隔离硬件差异。
  • 状态机: 用于应用层程序流程控制，清晰管理系统状态。
  • 错误处理机制: 提高系统鲁棒性，处理异常情况。
  • 低功耗设计: STM32L0的超低功耗特性，结合软件优化，实现低功耗运行。
  • SPI通信: 高速可靠的RC522芯片通信接口。
  • Mifare Classic协议: 理解和实现Mifare Classic卡片的读写和模拟。
  • Flash存储: 用于存储卡片数据，掉电不丢失。
  • C语言编程: 高效、灵活，适合嵌入式系统开发。
  • 实践验证: 代码和架构设计均基于嵌入式系统开发的实践经验。

总结:

以上代码和架构设计提供了一个完整的OV-Card项目框架。虽然部分代码（例如卡片模拟、Flash存储驱动、UI界面等）只是框架或示例，但已经涵盖了嵌入式系统开发的关键要素，包括分层架构、模块化设计、HAL层、驱动层、服务层、应用层，以及关键的RC522驱动和卡片读写服务。

要实现一个真正可用的OV-Card产品，还需要进行以下工作：

  1. 完善各模块代码: 例如，实现完整的Flash存储驱动、按键驱动、显示屏驱动、电源管理驱动、UI界面等。
  2. 深入研究卡片模拟技术: 卡片模拟是本项目最核心和最复杂的部分，需要深入理解ISO14443和Mifare协议，并可能需要特殊的硬件支持。
  3. 优化功耗: 进一步优化软件和硬件设计，降低系统功耗，延长电池续航时间。
  4. 安全性加固: 加强卡片数据存储的安全性，防止数据泄露和非法复制。
  5. 用户界面设计: 设计友好的用户界面，提高用户体验。
  6. 详细测试和验证: 进行全面的功能测试、性能测试、可靠性测试和用户体验测试。

希望这份详细的解答和代码示例能够帮助您理解OV-Card项目的嵌入式系统开发流程和代码设计架构。请记住，这只是一个基础框架，实际项目开发需要根据具体需求进行更深入的开发和优化。

欢迎关注我的其它发布渠道