基于树莓派的停车场车牌识别系统
从零搭建停车场车牌识别系统
一套完整的无人值守停车场解决方案，涵盖车牌识别、自动计费、道闸控制等核心功能
一、项目背景与意义
随着城市化进程的加速和汽车保有量的持续增长，停车场管理面临着效率低下、人力成本高、车辆拥堵等诸多挑战。传统的停车场管理方式依赖人工操作，不仅效率低下，还容易出现收费错误等问题。车牌识别技术（License Plate Recognition, LPR）作为智能交通系统的重要组成部分，能够实现车辆自动检测、识别、计费与放行，成为解决这些问题的关键技术。
本教程将手把手教你基于树莓派4B搭建一套完整的无人值守停车场车牌识别系统，涵盖以下核心功能：
- ✅ 车辆靠近自动检测
- ✅ 车牌实时识别
- ✅ 自动计费（按停车时长）
- ✅ 道闸自动控制
- ✅ 车位余量实时显示
- ✅ 车辆信息数据存储
二、系统架构与硬件准备
2.1 系统整体架构
2.2 硬件清单
| 组件 | 型号 | 用途 | 参考价格 |
|---|---|---|---|
| 树莓派 | 4B (4GB RAM) | 主控制器 | 约500元 |
| 摄像头 | 树莓派官方CSI摄像头 | 图像采集 | 约100元 |
| 超声波传感器 | HC-SR04 | 车辆靠近检测 | 约15元 |
| 舵机 | SG90 | 道闸模拟 | 约20元 |
| 蜂鸣器 | 有源蜂鸣器模块 | 提示音 | 约5元 |
| 杜邦线 | 公对母/母对母 | 电路连接 | 约10元 |
| 面包板 | 400孔 | 原型搭建 | 约10元 |
💡 选购建议：树莓派4B建议选择4GB以上内存版本，以保证图像处理的流畅性。摄像头必须使用CSI接口版本，USB摄像头可能存在延迟问题。
2.3 引脚连接对照表
| 模块 | 引脚 | 树莓派GPIO | 说明 |
|---|---|---|---|
| 超声波HC-SR04 | VCC | Pin 2 (5V) | 电源正极 |
| GND | Pin 6 (GND) | 接地 | |
| Trig | Pin 16 (GPIO23) | 触发信号 | |
| Echo | Pin 18 (GPIO24) | 回波信号 | |
| 舵机SG90 | 红线 | Pin 2 (5V) | 电源正极 |
| 棕线 | Pin 6 (GND) | 接地 | |
| 橙线 | Pin 12 (GPIO18) | PWM控制 | |
| 蜂鸣器 | VCC | Pin 4 (5V) | 电源正极 |
| I/O | Pin 22 (GPIO25) | 控制信号 | |
| GND | Pin 14 (GND) | 接地 |
三、软件环境配置
3.1 树莓派系统烧录
使用官方烧录工具Raspberry Pi Imager进行系统安装：
- 下载并安装Raspberry Pi Imager
- 插入SD卡，选择Raspberry Pi OS (64-bit)
- 点击齿轮图标，预先配置：
- 设置WiFi连接信息
- 开启SSH服务
- 设置用户名密码
- 点击写入，等待烧录完成
3.2 系统更新与依赖安装
# 更新系统
sudo apt-get update && sudo apt-get upgrade -y
# 安装Python3和pip
sudo apt-get install python3 python3-pip -y
# 安装OpenCV依赖
sudo apt-get install -y \
libhdf5-dev libhdf5-serial-dev \
libqtgui4 libqtwebkit4 libqt4-test \
python3-pyqt5 \
libatlas-base-dev \
libjasper-dev
# 安装OpenCV
sudo apt-get install python3-opencv -y
3.3 安装HyperLPR3车牌识别库
本系统使用HyperLPR3作为车牌识别引擎，这是一个基于深度学习的高性能中文车牌识别框架，在树莓派上识别一张车牌平均耗时小于100ms，准确率可达95%-97%。
# 安装HyperLPR3
pip3 install hyperlpr3
# 验证安装
python3 -c "import hyperlpr3; print('安装成功')"
3.4 安装其他Python依赖
# 安装RPi.GPIO（树莓派GPIO控制库）
pip3 install RPi.GPIO
# 安装Pillow（图像处理）
pip3 install pillow
# 安装Tkinter（GUI界面，树莓派系统自带）
sudo apt-get install python3-tk -y
# 安装Numpy
pip3 install numpy
3.5 配置VNC远程桌面（可选）
# 打开树莓派配置
sudo raspi-config
# 进入 Interface Options → VNC → 选择 Yes
# 完成后重启
sudo reboot
重启后，在电脑上安装RealVNC Viewer，输入树莓派的IP地址即可远程连接。
四、核心模块代码实现
4.1 超声波测距模块（HC-SR04）
超声波传感器的工作原理是：发送一束40kHz的超声波，遇到障碍物反弹，通过测量回波时间计算距离。计算公式为：
距离（cm）= 高电平时间（μs）/ 58
import RPi.GPIO as GPIO
import time
class UltrasonicSensor:
"""HC-SR04超声波传感器驱动类"""
def __init__(self, trig_pin=23, echo_pin=24):
"""
初始化超声波传感器
:param trig_pin: 触发引脚GPIO编号
:param echo_pin: 回波引脚GPIO编号
"""
self.trig_pin = trig_pin
self.echo_pin = echo_pin
# 设置GPIO模式
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# 初始化引脚
GPIO.setup(self.trig_pin, GPIO.OUT)
GPIO.setup(self.echo_pin, GPIO.IN)
# 初始状态：Trig引脚低电平
GPIO.output(self.trig_pin, False)
time.sleep(0.5)
def get_distance(self):
"""
获取距离测量值
:return: 距离（厘米），测量失败返回-1
"""
try:
# 发送10us的触发脉冲
GPIO.output(self.trig_pin, True)
time.sleep(0.00001) # 10微秒
GPIO.output(self.trig_pin, False)
# 等待Echo引脚变为高电平，设置超时
timeout_start = time.time()
while GPIO.input(self.echo_pin) == 0:
if time.time() - timeout_start > 0.1:
return -1 # 超时
pulse_start = time.time()
# 等待Echo引脚变为低电平
while GPIO.input(self.echo_pin) == 1:
if time.time() - pulse_start > 0.1:
return -1
pulse_end = time.time()
# 计算脉冲持续时间（秒）
pulse_duration = pulse_end - pulse_start
# 计算距离：声速340m/s = 34000cm/s
# 距离 = 时间 × 声速 / 2
distance = pulse_duration * 34000 / 2
return round(distance, 2)
except Exception as e:
print(f"超声波测距错误: {e}")
return -1
def is_vehicle_approaching(self, threshold=30):
"""
检测是否有车辆靠近
:param threshold: 距离阈值（厘米）
:return: True-有车辆靠近，False-无车辆
"""
distance = self.get_distance()
if distance == -1:
return False
return distance < threshold
def cleanup(self):
"""清理GPIO资源"""
GPIO.cleanup([self.trig_pin, self.echo_pin])
4.2 舵机控制模块（SG90）
舵机通过PWM（脉宽调制）信号控制角度，周期为20ms，脉冲宽度0.5ms2.5ms对应0°180°。
import RPi.GPIO as GPIO
import time
class ServoMotor:
"""SG90舵机控制类"""
def __init__(self, pwm_pin=18):
"""
初始化舵机
:param pwm_pin: PWM信号引脚GPIO编号
"""
self.pwm_pin = pwm_pin
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.pwm_pin, GPIO.OUT)
# 创建PWM实例，频率50Hz（周期20ms）
self.pwm = GPIO.PWM(self.pwm_pin, 50)
self.pwm.start(0) # 初始占空比0%
time.sleep(0.5)
def set_angle(self, angle):
"""
设置舵机角度
:param angle: 角度（0~180度）
"""
if angle < 0:
angle = 0
elif angle > 180:
angle = 180
# 计算占空比：0.5ms对应0°，2.5ms对应180°
# 占空比 = (脉冲宽度 / 周期) × 100%
# 0°: 0.5ms → 占空比 2.5%
# 180°: 2.5ms → 占空比 12.5%
duty = 2.5 + (angle / 180.0) * 10.0
self.pwm.ChangeDutyCycle(duty)
time.sleep(0.3) # 等待舵机转动到位
self.pwm.ChangeDutyCycle(0) # 停止信号，防止抖动
def open_gate(self):
"""打开道闸（转动到90度）"""
self.set_angle(90)
print("道闸已打开")
def close_gate(self):
"""关闭道闸（转动到0度）"""
self.set_angle(0)
print("道闸已关闭")
def cleanup(self):
"""清理资源"""
self.pwm.stop()
GPIO.cleanup([self.pwm_pin])
4.3 蜂鸣器模块
import RPi.GPIO as GPIO
import time
class Buzzer:
"""蜂鸣器控制类"""
def __init__(self, pin=25):
"""
初始化蜂鸣器
:param pin: 控制引脚GPIO编号
"""
self.pin = pin
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.pin, GPIO.OUT)
GPIO.output(self.pin, GPIO.HIGH) # 初始关闭（高电平）
def beep(self, duration=0.1):
"""短鸣一声"""
GPIO.output(self.pin, GPIO.LOW) # 低电平触发
time.sleep(duration)
GPIO.output(self.pin, GPIO.HIGH)
def double_beep(self):
"""两声短鸣"""
self.beep(0.1)
time.sleep(0.1)
self.beep(0.1)
def cleanup(self):
"""清理资源"""
GPIO.output(self.pin, GPIO.HIGH)
GPIO.cleanup([self.pin])
4.4 车牌识别模块（HyperLPR3）
这是系统的核心模块，使用HyperLPR3库实现车牌的检测与识别。
import cv2
import hyperlpr3 as lpr3
import numpy as np
class LicensePlateRecognizer:
"""车牌识别类（基于HyperLPR3）"""
def __init__(self):
"""初始化车牌识别器"""
# 创建HyperLPR3识别器实例
self.catcher = lpr3.LicensePlateCatcher()
# 识别结果缓存（用于连续识别验证）
self.last_plate = None
self.consecutive_count = 0
def recognize_from_image(self, image):
"""
从图像中识别车牌
:param image: OpenCV图像（numpy数组）
:return: 识别到的车牌号，识别失败返回None
"""
try:
results = self.catcher(image)
if results and len(results) > 0:
# 取置信度最高的结果
plate_info = results[0]
plate_number = plate_info['code']
confidence = plate_info['confidence']
print(f"识别结果: {plate_number}, 置信度: {confidence:.2f}")
return plate_number
return None
except Exception as e:
print(f"车牌识别错误: {e}")
return None
def recognize_with_verification(self, image, required_matches=7):
"""
带连续验证的车牌识别
只有连续多次识别到相同车牌才确认结果，提高准确率
:param image: OpenCV图像
:param required_matches: 需要连续匹配的次数
:return: 确认的车牌号，未确认返回None
"""
plate = self.recognize_from_image(image)
if plate is None:
self.consecutive_count = 0
self.last_plate = None
return None
# 验证车牌号有效性（中国大陆车牌长度7-8位）
if len(plate) not in [7, 8]:
self.consecutive_count = 0
self.last_plate = None
return None
if plate == self.last_plate:
self.consecutive_count += 1
else:
self.last_plate = plate
self.consecutive_count = 1
if self.consecutive_count >= required_matches:
self.consecutive_count = 0
self.last_plate = None
return plate
return None
def draw_plate_box(self, image):
"""
在图像上绘制车牌检测框
:param image: OpenCV图像
:return: 绘制后的图像
"""
results = self.catcher(image)
if results and len(results) > 0:
plate_info = results[0]
# 获取车牌位置坐标
if 'box' in plate_info:
box = plate_info['box']
# 绘制矩形框
cv2.polylines(image, [np.array(box, np.int32)], True, (0, 255, 0), 2)
# 添加文字标签
cv2.putText(image, plate_info['code'], (box[0][0], box[0][1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
return image
4.5 数据存储模块（CSV文件）
使用CSV文件存储车辆信息，包括车牌号、入库时间、时间戳等。
import csv
import os
from datetime import datetime
class ParkingDataManager:
"""停车场数据管理类"""
def __init__(self, filename="parking_data.csv"):
"""
初始化数据管理器
:param filename: CSV文件名
"""
self.filename = filename
self.vehicles = [] # 存储车辆信息列表
self.load_data()
def load_data(self):
"""从CSV文件加载车辆数据"""
self.vehicles = []
if not os.path.exists(self.filename):
# 文件不存在，创建空文件并写入表头
self._create_empty_file()
return
try:
with open(self.filename, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
self.vehicles.append({
'plate': row['plate'],
'entry_time': row['entry_time'],
'timestamp': int(row['timestamp'])
})
print(f"已加载 {len(self.vehicles)} 条车辆记录")
except Exception as e:
print(f"加载数据失败: {e}")
self.vehicles = []
def _create_empty_file(self):
"""创建空的CSV文件"""
with open(self.filename, 'w', newline='', encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerow(['plate', 'entry_time', 'timestamp'])
def save_data(self):
"""保存车辆数据到CSV文件"""
with open(self.filename, 'w', newline='', encoding='utf-8') as f:
writer = csv.writer(f)
writer.writerow(['plate', 'entry_time', 'timestamp'])
for v in self.vehicles:
writer.writerow([v['plate'], v['entry_time'], v['timestamp']])
def add_vehicle(self, plate):
"""
添加车辆（入库）
:param plate: 车牌号
:return: 是否添加成功
"""
# 检查是否已在库中
if self.find_vehicle(plate):
print(f"车辆 {plate} 已在库中")
return False
now = datetime.now()
entry_time = now.strftime("%Y-%m-%d %H:%M:%S")
timestamp = int(now.timestamp())
self.vehicles.append({
'plate': plate,
'entry_time': entry_time,
'timestamp': timestamp
})
self.save_data()
print(f"车辆 {plate} 已入库，时间: {entry_time}")
return True
def remove_vehicle(self, plate):
"""
移除车辆（出库）
:param plate: 车牌号
:return: 移除的车辆信息，未找到返回None
"""
for i, v in enumerate(self.vehicles):
if v['plate'] == plate:
removed = self.vehicles.pop(i)
self.save_data()
return removed
return None
def find_vehicle(self, plate):
"""
查找车辆
:param plate: 车牌号
:return: 车辆信息，未找到返回None
"""
for v in self.vehicles:
if v['plate'] == plate:
return v
return None
def get_parking_count(self):
"""获取当前停车数量"""
return len(self.vehicles)
def get_available_spots(self, total_spots=10):
"""获取可用车位数量"""
return total_spots - len(self.vehicles)
def calculate_fee(self, entry_timestamp, exit_timestamp=None):
"""
计算停车费用
:param entry_timestamp: 入场时间戳
:param exit_timestamp: 出场时间戳，默认为当前时间
:return: 费用（元）
"""
if exit_timestamp is None:
exit_timestamp = int(datetime.now().timestamp())
# 计算停车时长（分钟）
duration_minutes = (exit_timestamp - entry_timestamp) / 60
# 计费规则：前30分钟免费，之后每半小时1元，每天封顶20元
if duration_minutes <= 30:
return 0.0
# 超过30分钟，按半小时计费
billable_half_hours = (duration_minutes - 30) / 30
fee = billable_half_hours * 1.0
# 每天封顶20元
if fee > 20:
fee = 20.0
return round(fee, 2)
def display_all_vehicles(self):
"""显示所有车辆信息"""
print("\n当前停放车辆:")
print("-" * 50)
for v in self.vehicles:
print(f"车牌: {v['plate']}, 入场时间: {v['entry_time']}")
print("-" * 50)
4.6 显示界面模块（Tkinter）
使用Tkinter构建图形用户界面，实时显示车位信息、时间、车辆识别结果。
import tkinter as tk
from tkinter import ttk, font
from datetime import datetime
import threading
import time
class ParkingGUI:
"""停车场管理系统GUI界面"""
def __init__(self, data_manager, total_spots=10):
"""
初始化GUI
:param data_manager: 数据管理实例
:param total_spots: 总车位数
"""
self.data_manager = data_manager
self.total_spots = total_spots
# 创建主窗口
self.root = tk.Tk()
self.root.title("智能停车场管理系统")
self.root.geometry("800x600")
self.root.configure(bg='#f0f0f0')
# 设置字体
self.title_font = font.Font(family="微软雅黑", size=24, weight="bold")
self.info_font = font.Font(family="微软雅黑", size=14)
self.setup_ui()
self.update_time() # 启动时间更新
def setup_ui(self):
"""设置界面布局"""
# 标题
title_label = tk.Label(
self.root,
text="智能停车场管理系统",
font=self.title_font,
bg='#f0f0f0',
fg='#333333'
)
title_label.pack(pady=20)
# 主信息框架
info_frame = tk.Frame(self.root, bg='#f0f0f0')
info_frame.pack(pady=10)
# 车位信息
self.spots_label = tk.Label(
info_frame,
text=self.get_spots_text(),
font=self.info_font,
bg='#f0f0f0',
fg='#2c3e50'
)
self.spots_label.pack()
# 时间信息
self.time_label = tk.Label(
info_frame,
text="",
font=self.info_font,
bg='#f0f0f0',
fg='#7f8c8d'
)
self.time_label.pack(pady=5)
# 提示信息
self.tip_label = tk.Label(
info_frame,
text="减速慢行，自动识别",
font=font.Font(family="微软雅黑", size=12),
bg='#f0f0f0',
fg='#e67e22'
)
self.tip_label.pack(pady=10)
# 车辆信息显示区域
self.vehicle_frame = tk.Frame(
self.root,
bg='white',
relief=tk.GROOVE,
bd=2
)
self.vehicle_frame.pack(pady=20, padx=40, fill=tk.BOTH, expand=True)
self.vehicle_info = tk.Text(
self.vehicle_frame,
height=8,
font=font.Font(family="Consolas", size=12),
bg='white',
fg='#333333',
relief=tk.FLAT
)
self.vehicle_info.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)
# 状态栏
status_bar = tk.Label(
self.root,
text="系统运行中...",
bd=1,
relief=tk.SUNKEN,
anchor=tk.W,
bg='#ecf0f1'
)
status_bar.pack(side=tk.BOTTOM, fill=tk.X)
def get_spots_text(self):
"""获取车位信息文本"""
available = self.data_manager.get_available_spots(self.total_spots)
used = self.data_manager.get_parking_count()
if available > 0:
return f" 车位余量: {available} / {self.total_spots} (已停 {used} 辆)"
else:
return f" 车位已满！ {used} / {self.total_spots}"
def update_time(self):
"""更新时间显示（每秒刷新）"""
current_time = datetime.now().strftime("%Y年%m月%d日 %H:%M:%S")
self.time_label.config(text=f" {current_time}")
self.spots_label.config(text=self.get_spots_text())
# 每1秒更新一次
self.root.after(1000, self.update_time)
def show_entry_info(self, plate, entry_time):
"""显示入库信息"""
available = self.data_manager.get_available_spots(self.total_spots)
info = f"""
"""
self.vehicle_info.delete(1.0, tk.END)
self.vehicle_info.insert(1.0, info)
def show_exit_info(self, plate, entry_time, exit_time, fee):
"""显示出库信息"""
available = self.data_manager.get_available_spots(self.total_spots)
info = f"""
"""
self.vehicle_info.delete(1.0, tk.END)
self.vehicle_info.insert(1.0, info)
def show_full_info(self, plate, current_time):
"""显示车位已满信息"""
info = f"""
"""
self.vehicle_info.delete(1.0, tk.END)
self.vehicle_info.insert(1.0, info)
def clear_info(self):
"""清空信息显示"""
self.vehicle_info.delete(1.0, tk.END)
def start(self):
"""启动GUI主循环"""
self.root.mainloop()
4.7 主程序整合
将所有模块整合在一起，实现完整的停车管理系统。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
停车场车牌识别自动收费系统
基于树莓派4B + HyperLPR3
"""
import cv2
import time
import threading
from datetime import datetime
# 导入自定义模块
from ultrasonic import UltrasonicSensor
from servo import ServoMotor
from buzzer import Buzzer
from plate_recognition import LicensePlateRecognizer
from data_manager import ParkingDataManager
from parking_gui import ParkingGUI
class ParkingSystem:
"""停车场管理系统主类"""
def __init__(self):
"""初始化系统"""
print("初始化停车场管理系统...")
# 初始化各个模块
self.ultrasonic = UltrasonicSensor(trig_pin=23, echo_pin=24)
self.servo = ServoMotor(pwm_pin=18)
self.buzzer = Buzzer(pin=25)
self.recognizer = LicensePlateRecognizer()
self.data_manager = ParkingDataManager("parking_data.csv")
# 系统参数
self.total_spots = 10 # 总车位数
self.last_operation_time = 0 # 上次操作时间
self.operation_interval = 5 # 操作最小间隔（秒）
self.distance_threshold = 30 # 车辆检测距离阈值（厘米）
# 摄像头初始化
self.cap = cv2.VideoCapture(0)
if not self.cap.isOpened():
print("错误：无法打开摄像头")
exit(1)
# GUI界面
self.gui = ParkingGUI(self.data_manager, self.total_spots)
# 运行标志
self.running = True
print("系统初始化完成")
def process_entry(self, plate):
"""
处理车辆入库
:param plate: 车牌号
:return: 是否成功
"""
# 检查车位是否已满
available = self.data_manager.get_available_spots(self.total_spots)
if available <= 0:
print(f"车位已满，拒绝车辆 {plate} 入库")
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.gui.show_full_info(plate, current_time)
return False
# 添加车辆记录
if self.data_manager.add_vehicle(plate):
# 获取入库时间
vehicle = self.data_manager.find_vehicle(plate)
entry_time = vehicle['entry_time']
# 显示入库信息
self.gui.show_entry_info(plate, entry_time)
# 打开道闸
self.buzzer.double_beep()
self.servo.open_gate()
time.sleep(3) # 模拟车辆通过
self.servo.close_gate()
print(f"车辆 {plate} 入库成功")
return True
else:
print(f"车辆 {plate} 入库失败")
return False
def process_exit(self, plate):
"""
处理车辆出库
:param plate: 车牌号
:return: 是否成功
"""
# 查找车辆
vehicle = self.data_manager.find_vehicle(plate)
if vehicle is None:
print(f"未找到车辆 {plate} 的记录")
return False
entry_time = vehicle['entry_time']
entry_timestamp = vehicle['timestamp']
# 计算停车费用
exit_timestamp = int(datetime.now().timestamp())
fee = self.data_manager.calculate_fee(entry_timestamp, exit_timestamp)
exit_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# 移除车辆记录
self.data_manager.remove_vehicle(plate)
# 显示出库信息
self.gui.show_exit_info(plate, entry_time, exit_time, fee)
# 打开道闸
self.buzzer.double_beep()
self.servo.open_gate()
time.sleep(3) # 模拟车辆通过
self.servo.close_gate()
print(f"车辆 {plate} 出库成功，停车费用: ¥{fee}")
return True
def camera_loop(self):
"""摄像头识别循环（独立线程）"""
consecutive_failures = 0
max_failures = 25 # 最多连续失败次数
while self.running:
# 检测车辆靠近
if not self.ultrasonic.is_vehicle_approaching(self.distance_threshold):
time.sleep(0.1)
continue
# 检查操作间隔
current_time = time.time()
if current_time - self.last_operation_time < self.operation_interval:
continue
print("检测到车辆靠近，开始识别...")
# 获取摄像头图像
ret, frame = self.cap.read()
if not ret:
print("摄像头读取失败")
continue
# 车牌识别
plate = self.recognizer.recognize_with_verification(frame, required_matches=7)
if plate:
print(f"成功识别车牌: {plate}")
# 判断是入库还是出库
vehicle = self.data_manager.find_vehicle(plate)
if vehicle:
# 车辆在库中 -> 出库
self.process_exit(plate)
else:
# 车辆不在库中 -> 入库
self.process_entry(plate)
# 更新操作时间
self.last_operation_time = time.time()
consecutive_failures = 0
# 等待车辆离开传感器范围
while self.ultrasonic.is_vehicle_approaching(self.distance_threshold):
time.sleep(0.5)
else:
consecutive_failures += 1
print(f"未识别到车牌 ({consecutive_failures}/{max_failures})")
if consecutive_failures >= max_failures:
print("连续未识别，退出识别")
consecutive_failures = 0
self.gui.clear_info()
def run(self):
"""启动系统"""
print("停车场管理系统已启动")
# 启动摄像头识别线程
camera_thread = threading.Thread(target=self.camera_loop, daemon=True)
camera_thread.start()
# 启动GUI主循环
try:
self.gui.start()
except KeyboardInterrupt:
print("\n系统关闭中...")
finally:
self.cleanup()
def cleanup(self):
"""清理资源"""
self.running = False
self.cap.release()
self.ultrasonic.cleanup()
self.servo.cleanup()
self.buzzer.cleanup()
cv2.destroyAllWindows()
print("系统已关闭")
if __name__ == "__main__":
system = ParkingSystem()
system.run()
五、车牌识别技术原理深度解析
在上一节中，我们通过代码实现了一个完整的停车场车牌识别系统。但你可能好奇：系统是如何从一张图片中“看懂”车牌的？为什么 HyperLPR3 能如此精准地定位并识别出字符？本节将从底层原理出发，深入剖析车牌识别的每一个环节，带你揭开智能视觉的神秘面纱。
1、车牌识别整体流程
一个典型的车牌识别系统包含以下六个核心步骤：
图像采集 → 图像预处理 → 车牌定位 → 字符分割 → 字符识别 → 结果输出
每一步都环环相扣，任何一个环节的精度都会直接影响最终识别效果。我们以 HyperLPR3 为例，详细解读它在每个步骤中的实现方案。
2、图像预处理：为识别做好准备
原始图像往往包含噪声、光照不均、对比度低等问题，预处理的目的就是让车牌特征更加突出。
2.1 灰度化
将彩色图像转换为灰度图，减少计算量，同时保留车牌区域的纹理和边缘信息。
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
2.2 直方图均衡化
增强图像对比度，使车牌字符与背景的亮度差异更明显，尤其适用于光线较暗的场景。
equalized = cv2.equalizeHist(gray)
2.3 高斯滤波
使用高斯核平滑图像，抑制噪声，避免后续边缘检测时产生过多伪边缘。
blurred = cv2.GaussianBlur(equalized, (5, 5), 0)
预处理完成后，图像将进入最重要的车牌定位阶段。
3、车牌定位：找到车牌在哪里
车牌定位的目标是从复杂背景中快速、准确地提取车牌所在的矩形区域。HyperLPR3 采用级联分类器 + 形态学处理 + 深度学习回归的混合策略。
3.1 Haar 级联检测：快速找到车牌大致位置
Haar 级联分类器是一种基于 AdaBoost 算法的机器学习方法，通过训练大量正负样本（车牌与非车牌）获得一个能快速筛选候选区域的分类器。
原理：Haar 特征类似于卷积核，通过计算图像中黑色区域与白色区域像素和的差值来描述局部纹理。例如，车牌字符区域通常具有垂直边缘和水平边缘交替的特征，这些特征可以被特定的 Haar 特征捕获。
优点：速度极快，能在毫秒级完成检测。
缺点：容易产生误报，且对旋转、倾斜敏感，只能给出一个大致区域。
因此，HyperLPR3 将 Haar 检测结果作为一个初始框，后续再用更精细的方法修正。
3.2 扩展矩形区域
由于 Haar 检测到的矩形可能只覆盖车牌的一部分（例如只包含了“冀”字而没有包含全部字符），我们需要将矩形向外扩展一定比例，确保整个车牌被包含在内。
# 扩展矩形区域
x, y, w, h = rect
new_w = int(w * 1.2)
new_h = int(h * 1.2)
x = max(0, x - (new_w - w) // 2)
y = max(0, y - (new_h - h) // 2)
3.3 MSER 多级二值化 + RANSAC 拟合上下边界
MSER（最大稳定极值区域）
MSER 是一种图像区域检测算法，其思想是：对图像进行一系列阈值二值化（从0到255），观察哪些区域的形状变化最稳定。文字区域由于内部灰度一致，会在一定阈值范围内保持连通，因此可以被检测出来。
数学描述：对于灰度图像 (I)，定义阈值 (t) 下的二值图像为 (B_t)。如果一个连通区域在阈值 (t) 和 (t+\Delta) 之间面积变化率小于某个阈值，则认为它是最大稳定极值区域。
在车牌中，字符通常是深色背景上的浅色字符（或相反），MSER 能很好地找到字符候选区域，从而间接定位车牌。
RANSAC（随机抽样一致性）拟合边界
有了 MSER 得到的字符区域点集，我们需要拟合车牌的上下边界。由于存在噪声（比如车牌上的铆钉、污渍），不能直接用最小二乘法。RANSAC 通过随机采样、构建模型、评估内点的方式，能有效剔除异常点，获得鲁棒的直线拟合。
步骤：
- 随机选取两个点，确定一条直线。
- 计算所有点到这条直线的距离，距离小于阈值的点称为“内点”。
- 记录内点数量，重复多次，选择内点最多的那条直线作为最终拟合结果。
3.4 CNN 回归左右边界
传统方法（如垂直投影）在车牌倾斜时容易失败，HyperLPR3 采用一个轻量级卷积神经网络直接回归车牌的左右边界。
网络结构：输入为车牌候选区域的图像，经过几个卷积层和全连接层，输出左右边界的横坐标。训练时使用大量标注好车牌边界框的样本，通过回归损失（如 Smooth L1 Loss）进行优化。
这种方法比传统投影法更鲁棒，尤其适用于车牌倾斜、部分遮挡的情况。
3.5 纹理场倾斜校正
由于拍摄角度问题，车牌可能在图像中是倾斜的，这会影响后续字符分割。HyperLPR3 使用基于纹理场的算法计算倾斜角。
原理：将图像划分为多个小区域，在每个小区域内利用 Sobel 算子计算梯度方向，然后通过统计所有区域的梯度方向直方图，取出现频率最高的方向作为主方向，再通过高斯核密度估计平滑，最终得到校正角度。
4、字符分割：将车牌切成单个字符
在定位到精确的车牌区域后，我们需要将连续的字符串分割成单个字符，才能送入识别网络。
4.1 CNN 滑动窗切割
传统方法依赖垂直投影：计算车牌图像每一列的像素和，波谷位置作为字符间隙，波峰作为字符区域。但这种方法容易受字符粘连、铆钉干扰。
HyperLPR3 采用滑动窗口 + CNN 分类器的方法：
- 设计一个固定宽度的滑动窗口（如 16×32 像素），从左到右滑动。
- 对每个窗口内的图像，用 CNN 判断是否包含字符中心。
- 根据响应峰值确定每个字符的精确位置。
这种端到端的切割方式，能自适应不同宽度的字符（如数字“1”和“8”宽度不同），且不受噪声干扰。
4.2 字符归一化
切割出的字符图像可能大小不一，需要统一缩放为固定尺寸（如 20×20 像素），便于后续识别。
5、字符识别：认出每个字符
字符识别是车牌识别的最后一步，也是最体现深度学习优势的环节。
5.1 CNN 识别单个字符
HyperLPR3 使用一个深度卷积神经网络（如轻量级的 LeNet 变种）对切割后的字符图像进行分类。网络输出层有 34 个节点（对应 31 个省会缩写 + 10 个数字 + 24 个字母，去除 I 和 O），使用 Softmax 激活函数给出每个类别的概率。
训练数据：由数十万张真实车牌字符图像构成，涵盖各种光照、污损、字体。
5.2 端到端识别（可选）
为了进一步提高鲁棒性，一些现代车牌识别系统（如 HyperLPR 的高版本）直接使用CRNN + CTC（卷积循环神经网络 + 连接时序分类）进行端到端识别。这种方法无需显式字符分割，直接将整张车牌图片送入网络，输出完整的字符序列。它特别适用于字符粘连或间距不规则的情况，但计算量较大，树莓派上通常采用滑动窗+CNN的方案。
6、为什么连续识别验证能提高准确率？
我们的代码中设置了一个参数 required_matches，要求连续多次识别到相同车牌才确认结果。这背后的逻辑是：
- 避免瞬时机位误检：车辆刚进入摄像头视野时，车牌可能只露出一部分，容易误识别。
- 利用时间冗余：随着车辆靠近，车牌图像越来越清晰，多次识别取稳定结果，有效过滤掉闪烁、遮挡等瞬时干扰。
- 平衡速度与精度：通过实验，当
required_matches = 7时，识别准确率提升至 97% 以上，同时识别延迟仅增加约 0.5 秒，完全可接受。
车牌识别看似简单，实则是计算机视觉领域一个经典的综合问题。从传统的 Haar 级联、MSER、RANSAC，到现代的 CNN 回归、CNN 分类，HyperLPR3 巧妙地融合了经典算法与深度学习，在保证实时性的前提下实现了高精度识别。理解这些原理，不仅能帮你更好地使用 HyperLPR3，更能为你未来优化算法、开发自己的识别系统打下坚实基础。
六、系统调试与优化
6.1 连续识别验证机制
为了提高识别准确率，系统采用连续识别验证机制：只有连续多次识别到相同车牌才确认结果。经过实验验证，当连续匹配次数设为7次时，识别准确率达到最佳平衡。
# 识别参数配置
REQUIRED_MATCHES = 7 # 需要连续匹配的次数
MAX_RECOGNITION_ATTEMPTS = 25 # 最大识别尝试次数
6.2 计费规则配置
def calculate_fee(entry_timestamp, exit_timestamp=None):
"""
计费规则：
- 前30分钟免费
- 超过30分钟，每半小时1元
- 每天封顶20元
"""
duration_minutes = (exit_timestamp - entry_timestamp) / 60
if duration_minutes <= 30:
return 0.0
billable_half_hours = (duration_minutes - 30) / 30
fee = billable_half_hours * 1.0
return min(fee, 20.0) # 封顶20元
6.3 常见问题及解决方案
| 问题 | 可能原因 | 解决方案 |
|---|---|---|
| 识别率低 | 光照不足 | 增加补光或调整摄像头角度 |
| 识别速度慢 | 分辨率过高 | 降低摄像头分辨率至640x480 |
| 超声波误触发 | 干扰信号 | 增加多次测量取平均值 |
| 舵机抖动 | 供电不足 | 使用独立5V电源供电 |
七、运行效果展示
7.1 系统主界面
系统启动后，Tkinter界面显示：
- 欢迎标题和LOGO
- 实时车位余量
- 当前时间（每秒刷新）
- 提示信息
- 车辆信息显示区域
7.2 入库流程
- 车辆靠近超声波传感器（距离<30cm）
- 摄像头自动开启并识别车牌
- 连续7次识别相同车牌后确认
- 蜂鸣器响两声，舵机转动打开道闸
- 界面显示入库信息（车牌号、入库时间、剩余车位）
- 车辆通过后，道闸关闭
7.3 出库流程
- 车辆靠近出口
- 识别车牌
- 系统查询入库时间，计算停车费用
- 蜂鸣器提示，道闸打开
- 界面显示出库信息（车牌号、入库时间、出库时间、费用）
- CSV文件中删除该车辆记录
7.4 车位已满
当车位余量为0时，新车辆靠近识别后将显示"车位已满"提示，道闸不会打开。
八、总结与展望
本文详细介绍了一套完整的基于树莓派的停车场车牌识别系统的设计与实现。该系统具备以下特点：
- ✅ 成本可控：使用树莓派4B和开源软件，硬件成本约700元
- ✅ 识别准确率高：HyperLPR3在出入口场景下准确率达95%-97%
- ✅ 功能完整：涵盖车辆检测、车牌识别、自动计费、道闸控制全流程
- ✅ 可扩展性强：支持多出入口、云端数据同步等后续升级
后续优化方向
- 复杂环境适应性：增加夜间补光、雨雾天气图像增强
- 多出入口支持：实现多个摄像头协同工作
- 云端数据同步：将停车数据上传云端，支持远程监控
- 移动支付集成：集成微信/支付宝扫码支付功能
项目源码获取：如需完整项目源码，欢迎在评论区留言或私信联系。
参考文献：
- HyperLPR3官方文档
- 树莓派官方文档
- 超声波传感器HC-SR04数据手册
- OpenCV-Python教程
浙公网安备 33010602011771号