《2024 DigiKey 汽车应用创意挑战赛》基于树莓派的汽车安全...

eefocus_3897960

一、项目名称：基于树莓派的汽车安全防护系统
二、项目概述：随着汽车保有量的增加，交通事故频发，尤其在倒车、变道、盲区等场景下安全隐患突出。传统车载安全系统（如倒车雷达）存在检测范围有限、抗干扰能力弱等问题。本项目基于树莓派4B/5主控平台，结合超声波传感器（近距离探测）、毫米波雷达（中远距离探测）、LED灯（光提示）和蜂鸣器（声音警告），设计一套低成本、高精度、多层次的汽车主动安全防护系统，实现环境感知-数据分析-实时预警-人机交互的闭环控制，降低碰撞风险。

三、作品实物图：

四、项目代码

1. import RPi.GPIO as GPIO
   
2. import time
   
3. 
   
4. # 硬件引脚定义
   
5. TRIG_PIN = 23    # 超声波Trig引脚（GPIO23/物理引脚16）
   
6. ECHO_PIN = 24    # 超声波Echo引脚（GPIO24/物理引脚18）
   
7. BUZZER_PIN = 18  # 蜂鸣器控制引脚（GPIO18/物理引脚12）
   
8. LED_PIN = 25     # LED控制引脚（GPIO25/物理引脚22）
   
9. 
   
10. # 初始化设置
    
11. def setup():
    
12.     GPIO.setmode(GPIO.BCM)          # 使用BCM编号
    
13.     GPIO.setup(TRIG_PIN, GPIO.OUT)  # Trig引脚输出模式
    
14.     GPIO.setup(ECHO_PIN, GPIO.IN)   # Echo引脚输入模式
    
15.     GPIO.setup(BUZZER_PIN, GPIO.OUT)
    
16.     GPIO.setup(LED_PIN, GPIO.OUT)
    
17.    
    
18.     # 初始化关闭蜂鸣器和LED
    
19.     GPIO.output(BUZZER_PIN, False)
    
20.     GPIO.output(LED_PIN, False)
    
21. 
    
22. # 超声波测距函数
    
23. def get_distance():
    
24.     # 发送触发信号
    
25.     GPIO.output(TRIG_PIN, True)
    
26.     time.sleep(0.00001)  # 持续10微秒
    
27.     GPIO.output(TRIG_PIN, False)
    
28. 
    
29.     # 记录回波时间
    
30.     timeout = 0.1  # 100ms超时时间（约对应5.8米）
    
31.     t_start = time.time()
    
32.     while GPIO.input(ECHO_PIN) == 0:
    
33.         if (time.time() - t_start) > timeout:
    
34.             return -1  # 超时返回错误
    
35.         pulse_start = time.time()
    
36. 
    
37.     t_start = time.time()
    
38.     while GPIO.input(ECHO_PIN) == 1:
    
39.         if (time.time() - t_start) > timeout:
    
40.             return -1  # 超时返回错误
    
41.         pulse_end = time.time()
    
42. 
    
43.     # 计算距离（单位：厘米）
    
44.     pulse_duration = pulse_end - pulse_start
    
45.     distance = pulse_duration * 34300 / 2  # 声速343m/s=34300cm/s
    
46.     return round(distance, 1)
    
47. 
    
48. # 报警控制函数
    
49. def alert_control(distance):
    
50.     if distance < 50 and distance > 0:  # 有效报警范围
    
51.         # 蜂鸣器高频鸣叫（0.1秒间隔）
    
52.         GPIO.output(BUZZER_PIN, True)
    
53.         GPIO.output(LED_PIN, True)
    
54.         time.sleep(0.1)
    
55.         GPIO.output(BUZZER_PIN, False)
    
56.         GPIO.output(LED_PIN, False)
    
57.         time.sleep(0.1)
    
58.     else:
    
59.         GPIO.output(BUZZER_PIN, False)
    
60.         GPIO.output(LED_PIN, False)
    
61. 
    
62. # 主程序
    
63. def main():
    
64.     setup()
    
65.     try:
    
66.         while True:
    
67.             dist = get_distance()
    
68.             print(f"当前距离: {dist}cm")
    
69.             alert_control(dist)
    
70.             time.sleep(0.2)  # 每次测量间隔200ms
    
71.     except KeyboardInterrupt:
    
72.         GPIO.cleanup()
    
73. 
    
74. if __name__ == "__main__":
    
75.     main()

复制代码

1. import serial
   
2. import RPi.GPIO as GPIO
   
3. import time
   
4. from struct import unpack
   
5. 
   
6. # 硬件配置
   
7. BUZZER_PIN = 18
   
8. LED_PIN = 25
   
9. SERIAL_PORT = "/dev/ttyAMA0"  # 树莓派5 UART默认设备
   
10. BAUD_RATE = 256000
    
11. 
    
12. # LD2451协议常量
    
13. HEADER = bytes([0xF4, 0xF3, 0xF2, 0xF1])
    
14. ALERT_DISTANCE = 10.0  # 报警阈值（单位：米）
    
15. 
    
16. def setup():
    
17.     GPIO.setmode(GPIO.BCM)
    
18.     GPIO.setup(BUZZER_PIN, GPIO.OUT)
    
19.     GPIO.setup(LED_PIN, GPIO.OUT)
    
20.     GPIO.output(BUZZER_PIN, False)
    
21.     GPIO.output(LED_PIN, False)
    
22. 
    
23. def parse_binary_data(data):
    
24.     """
    
25.     解析二进制数据帧
    
26.     返回：目标列表，每个目标为字典格式
    
27.     """
    
28.     targets = []
    
29.     try:
    
30.         # 校验帧头
    
31.         if data[0:4] != HEADER:
    
32.             return []
    
33.         
    
34.         # 获取数据长度（小端序）
    
35.         data_len = unpack('<H', data[4:6])[0]
    
36.         
    
37.         # 校验数据完整性
    
38.         if len(data) < 6 + data_len + 1:  # Header+Len+Data+Checksum
    
39.             return []
    
40.         
    
41.         # 计算校验和
    
42.         checksum = sum(data[0:6+data_len]) & 0xFF
    
43.         if checksum != data[6+data_len]:
    
44.             print(f"校验错误: 计算值{checksum} vs 接收值{data[6+data_len]}")
    
45.             return []
    
46.         
    
47.         # 解析目标数据（每24字节一个目标）
    
48.         target_count = data_len // 24
    
49.         for i in range(target_count):
    
50.             start = 6 + i*24
    
51.             end = start + 24
    
52.             target_bytes = data[start:end]
    
53.             
    
54.             # 解析结构体
    
55.             x, y, speed, _, distance, energy, status = unpack(
    
56.                 '<hhhHHHBB', target_bytes[:16]  # 仅解析前16字节关键数据
    
57.             )
    
58.             
    
59.             # 单位转换
    
60.             target = {
    
61.                 'x': x / 1000.0,         # mm → m
    
62.                 'y': y / 1000.0,
    
63.                 'speed': speed / 1000.0, # mm/s → m/s
    
64.                 'distance': distance / 1000.0,
    
65.                 'energy': energy,
    
66.                 'status': '运动' if (status & 0x01) == 0 else '静止'
    
67.             }
    
68.             targets.append(target)
    
69.         return targets
    
70.    
    
71.     except Exception as e:
    
72.         print(f"解析异常: {e}")
    
73.         return []
    
74. 
    
75. def alert_control(enable):
    
76.     GPIO.output(BUZZER_PIN, enable)
    
77.     GPIO.output(LED_PIN, enable)
    
78. 
    
79. def main():
    
80.     setup()
    
81.     try:
    
82.         with serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1) as ser:
    
83.             # 发送进入Binary模式指令（可选）
    
84.             ser.write(bytes([0xF4, 0xF3, 0xF2, 0xF1, 0x04, 0x00, 0x02, 0xAA, 0x55]))
    
85.             
    
86.             buffer = bytes()
    
87.             while True:
    
88.                 buffer += ser.read_all()
    
89.                
    
90.                 # 查找帧头
    
91.                 while len(buffer) >= 6:
    
92.                     header_pos = buffer.find(HEADER)
    
93.                     if header_pos == -1:
    
94.                         buffer = bytes()
    
95.                         break
    
96.                     
    
97.                     # 截取完整帧
    
98.                     if len(buffer) >= header_pos + 6:
    
99.                         data_len = unpack('<H', buffer[header_pos+4:header_pos+6])[0]
    
100.                         total_len = 4 + 2 + data_len + 1  # Header+Len+Data+Checksum
     
101.                         if len(buffer) >= header_pos + total_len:
     
102.                             frame = buffer[header_pos:header_pos+total_len]
     
103.                             buffer = buffer[header_pos+total_len:]
     
104.                             targets = parse_binary_data(frame)
     
105.                            
     
106.                             # 报警逻辑
     
107.                             min_dist = min((t['distance'] for t in targets) if targets else 999
     
108.                             alert_control(min_dist < ALERT_DISTANCE)
     
109.                             print(f"最近目标: {min_dist:.2f}m 报警状态: {min_dist < ALERT_DISTANCE}")
     
110.                            
     
111.                     else:
     
112.                         break
     
113.                
     
114.                 time.sleep(0.05)
     
115.                
     
116.     except KeyboardInterrupt:
     
117.         GPIO.cleanup()
     
118. 
     
119. if __name__ == "__main__":
     
120.     main()

复制代码

五、项目文档

ld2451_alert.py.txt (4.03 KB, 下载次数: 0)

2025-2-28 23:51 上传

点击文件名下载附件

SR04.py.txt (1.98 KB, 下载次数: 0)

2025-2-28 23:51 上传

点击文件名下载附件