From dc9ce57da3c9d34c34fc40306498265c5d762b0e Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 18 Dec 2025 15:55:50 +0800 Subject: [PATCH 01/33] 1 --- src/Smart_car/dianliangyuxianshi.py | 95 +++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 src/Smart_car/dianliangyuxianshi.py diff --git a/src/Smart_car/dianliangyuxianshi.py b/src/Smart_car/dianliangyuxianshi.py new file mode 100644 index 0000000000..6475107b10 --- /dev/null +++ b/src/Smart_car/dianliangyuxianshi.py @@ -0,0 +1,95 @@ +import time +import random # 仅用于模拟硬件数据，实际场景删除 + + +class UnmannedVehicleBattery: + """无人车电池电量管理类""" + + def __init__(self): + # 电池参数配置（根据实际电池规格调整） + self.max_voltage = 12.6 # 满电电压（12V锂电池为例） + self.min_voltage = 10.0 # 欠压保护电压 + self.current_voltage = 0.0 # 当前电压 + self.battery_percent = 0.0 # 剩余电量百分比 + + def read_battery_voltage(self): + """ + 读取电池电压（模拟硬件采集） + 实际场景：替换为ADC读取/串口接收BMS数据/I2C通信等 + """ + # 模拟电压波动（范围：10.0~12.6V） + self.current_voltage = round(random.uniform(10.0, 12.6), 2) + # 实际硬件示例（以树莓派ADC为例）： + # import adafruit_ads1x15.ads1115 as ADS + # from adafruit_ads1x15.analog_in import AnalogIn + # i2c = board.I2C() + # ads = ADS.ADS1115(i2c) + # chan = AnalogIn(ads, ADS.P0) + # self.current_voltage = chan.voltage * voltage_divider_ratio # 电压分压比 + + def calculate_battery_percent(self): + """计算剩余电量百分比""" + if self.current_voltage >= self.max_voltage: + self.battery_percent = 100.0 + elif self.current_voltage <= self.min_voltage: + self.battery_percent = 0.0 + else: + # 线性计算（实际可根据电池放电曲线优化） + self.battery_percent = round( + (self.current_voltage - self.min_voltage) / + (self.max_voltage - self.min_voltage) * 100, + 1 + ) + + def get_battery_status(self): + """判断电量状态""" + if self.battery_percent >= 95: + return "满电", "🟢" + elif 20 <= self.battery_percent < 95: + return "正常", "🟢" + elif 5 <= self.battery_percent < 20: + return "低电量", "🟡" + else: + return "紧急（请充电）", "🔴" + + def display_battery_info(self): + """可视化显示电量信息""" + # 清空控制台（可选） + # os.system('cls' if os.name == 'nt' else 'clear') + + # 电量条可视化 + bar_length = 20 + filled_length = int(bar_length * self.battery_percent // 100) + battery_bar = "█" * filled_length + "-" * (bar_length - filled_length) + + # 获取状态 + status, color = self.get_battery_status() + + # 打印信息 + print(f"\n=== 无人车电池状态 ===") + print(f"当前电压: {self.current_voltage}V") + print(f"剩余电量: |{battery_bar}| {self.battery_percent}%") + print(f"状态: {color} {status}") + + # 低电量告警 + if self.battery_percent < 5: + print("⚠️ 电量过低，立即停止作业并充电！") + + +def main(): + """主循环""" + battery = UnmannedVehicleBattery() + print("无人车电量监控系统启动...") + + try: + while True: + battery.read_battery_voltage() # 读取电压 + battery.calculate_battery_percent() # 计算电量 + battery.display_battery_info() # 显示信息 + time.sleep(1) # 1秒刷新一次 + except KeyboardInterrupt: + print("\n监控系统已退出") + + +if __name__ == "__main__": + main() \ No newline at end of file From dc3521a3d5958b0ce4b19be565ce899dd6de4365 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 18 Dec 2025 15:56:17 +0800 Subject: [PATCH 02/33] 1 --- src/Smart_car/dianliangyuxianshi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/dianliangyuxianshi.py b/src/Smart_car/dianliangyuxianshi.py index 6475107b10..40b6b6f8f5 100644 --- a/src/Smart_car/dianliangyuxianshi.py +++ b/src/Smart_car/dianliangyuxianshi.py @@ -73,7 +73,7 @@ def display_battery_info(self): # 低电量告警 if self.battery_percent < 5: - print("⚠️ 电量过低，立即停止作业并充电！") + print("⚠️ 电量过低，立即停止作业并充电") def main(): From 28b2a2eee835d868c8119c6b82eeaedf92d2c0c4 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 18 Dec 2025 19:46:33 +0800 Subject: [PATCH 03/33] 1 --- ...ngyuxianshi.py => autonomous vehicle battery level display.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/Smart_car/{dianliangyuxianshi.py => autonomous vehicle battery level display.py} (100%) diff --git a/src/Smart_car/dianliangyuxianshi.py b/src/Smart_car/autonomous vehicle battery level display.py similarity index 100% rename from src/Smart_car/dianliangyuxianshi.py rename to src/Smart_car/autonomous vehicle battery level display.py From 880ca4738b73e5facc54d21b7934701e5c724008 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 18 Dec 2025 20:25:49 +0800 Subject: [PATCH 04/33] 1 --- ...vel display.py => autonomous_vehicle_battery_level_display.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/Smart_car/{autonomous vehicle battery level display.py => autonomous_vehicle_battery_level_display.py} (100%) diff --git a/src/Smart_car/autonomous vehicle battery level display.py b/src/Smart_car/autonomous_vehicle_battery_level_display.py similarity index 100% rename from src/Smart_car/autonomous vehicle battery level display.py rename to src/Smart_car/autonomous_vehicle_battery_level_display.py From 1636dad0a68b8f4302340b584db8e75f9f8d8096 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 18 Dec 2025 21:29:20 +0800 Subject: [PATCH 05/33] 1 --- src/Smart_car/Speed_warning.py | 102 +++++++++++++++++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 src/Smart_car/Speed_warning.py diff --git a/src/Smart_car/Speed_warning.py b/src/Smart_car/Speed_warning.py new file mode 100644 index 0000000000..bb69dd8071 --- /dev/null +++ b/src/Smart_car/Speed_warning.py @@ -0,0 +1,102 @@ +import time +import serial # 需安装：pip install pyserial +import random # 仿真速度数据（真实场景替换为传感器读取） + +# ------------------- 配置参数 ------------------- +# 限速阈值（km/h） +SPEED_LIMIT = 20 +# 预警等级配置 +WARNING_LEVELS = { + "low": (SPEED_LIMIT, SPEED_LIMIT + 5), # 轻度超速：20-25km/h + "medium": (SPEED_LIMIT + 5, SPEED_LIMIT + 10), # 中度超速：25-30km/h + "high": (SPEED_LIMIT + 10, float('inf')) # 重度超速：>30km/h +} +# 串口配置（对接车载显示屏/报警器，真实场景启用） +SERIAL_PORT = "COM3" # Windows: COM3 / Linux: /dev/ttyUSB0 +BAUD_RATE = 9600 +ser = None + + +# ------------------- 初始化函数 ------------------- +def init_serial(): + """初始化串口（用于向硬件发送预警指令）""" + global ser + try: + ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1) + print(f"Serial port {SERIAL_PORT} initialized successfully") + except Exception as e: + print(f"Serial port init failed: {e}") + ser = None + + +# ------------------- 速度读取函数 ------------------- +def read_vehicle_speed(): + """ + 读取车辆速度（真实场景替换为传感器/总线数据） + 返回：当前速度（km/h） + """ + # 仿真：随机生成10-35km/h的速度（真实场景删除此段） + simulated_speed = random.uniform(10, 35) + return round(simulated_speed, 1) + + # 真实场景示例：从串口读取速度传感器数据 + # if ser and ser.in_waiting > 0: + # speed_data = ser.readline().decode('utf-8').strip() + # return float(speed_data) if speed_data else 0.0 + # return 0.0 + + +# ------------------- 超速预警核心函数 ------------------- +def speed_warning(current_speed): + """ + 超速预警判断与输出 + :param current_speed: 当前速度（km/h） + :return: 预警等级（None/low/medium/high）、预警信息（英文） + """ + if current_speed < SPEED_LIMIT: + return None, f"Current speed: {current_speed} km/h - Normal" + + # 判断预警等级 + warning_level = None + warning_msg = "" + if WARNING_LEVELS["low"][0] <= current_speed < WARNING_LEVELS["low"][1]: + warning_level = "low" + warning_msg = f"Speed Warning: {current_speed} km/h (Over limit by {current_speed - SPEED_LIMIT} km/h) - Slow down!" + elif WARNING_LEVELS["medium"][0] <= current_speed < WARNING_LEVELS["medium"][1]: + warning_level = "medium" + warning_msg = f"Over Speed Warning: {current_speed} km/h - Reduce speed immediately!" + elif current_speed >= WARNING_LEVELS["high"][0]: + warning_level = "high" + warning_msg = f"CRITICAL Over Speed Warning: {current_speed} km/h - STOP VEHICLE!" + + # 输出预警（控制台 + 串口/硬件） + print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {warning_msg}") + if ser: + ser.write(f"{warning_level}:{warning_msg}\n".encode('utf-8')) + + return warning_level, warning_msg + + +# ------------------- 主循环 ------------------- +def main(): + # 初始化串口（可选） + # init_serial() + + print(f"Autonomous Vehicle Speed Warning System Started | Speed Limit: {SPEED_LIMIT} km/h") + try: + while True: + # 读取当前速度 + current_speed = read_vehicle_speed() + # 触发超速预警 + speed_warning(current_speed) + # 1秒刷新一次（可根据传感器频率调整） + time.sleep(1) + except KeyboardInterrupt: + print("\nSystem stopped by user") + finally: + if ser: + ser.close() + + +if __name__ == "__main__": + main() \ No newline at end of file From 202a616c4fbff92dd333044fa05879960c0eec40 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 09:28:06 +0800 Subject: [PATCH 06/33] 1 --- src/Smart_car/obstacle_avoidance.py | 193 ++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 src/Smart_car/obstacle_avoidance.py diff --git a/src/Smart_car/obstacle_avoidance.py b/src/Smart_car/obstacle_avoidance.py new file mode 100644 index 0000000000..1787cd840f --- /dev/null +++ b/src/Smart_car/obstacle_avoidance.py @@ -0,0 +1,193 @@ +import time +import random +import matplotlib.pyplot as plt +import matplotlib.animation as animation +from matplotlib.patches import Rectangle, Circle + +# 无人车状态常量 +SAFE_DISTANCE = 50 # 安全距离（厘米） +WARNING_DISTANCE = 30 # 警告距离（厘米） +DANGER_DISTANCE = 15 # 危险距离（厘米） +NORMAL_SPEED = 20 # 正常速度（km/h） +LOW_SPEED = 5 # 低速（km/h） +STOP_SPEED = 0 # 停车速度 + +# 可视化全局变量 +fig, (ax_scene, ax_plot) = plt.subplots(1, 2, figsize=(12, 5)) +distance_history = [] # 前方距离历史 +speed_history = [] # 车速历史 +time_history = [] # 时间轴 +car_pos = [5, 2.5] # 无人车初始位置（x,y） +obstacle_pos = [0, 0] # 障碍物位置 +car_direction = "forward" + + +class UnmannedCar: + def __init__(self): + self.speed = 0 + self.direction = "forward" + + def simulate_sensor(self, direction): + """模拟传感器测距（加入轻微固定偏移，让障碍物位置可预测）""" + if direction == "front": + # 模拟障碍物距离缓慢变化（更贴近实际） + base_dist = random.randint(10, 60) if len(distance_history) < 5 else distance_history[-1] + random.randint( + -5, 5) + distance = max(0, min(100, base_dist)) # 限制0-100cm + else: + distance = random.randint(20, 80) # 左右侧距离 + + # 更新障碍物位置（用于可视化） + global obstacle_pos + obstacle_pos = [car_pos[0] + distance / 10, car_pos[1]] # 缩放适配画布 + print(f"[{direction}] 传感器检测距离：{distance} cm") + return distance + + def adjust_speed(self, new_speed): + self.speed = new_speed + print(f"车速调整为：{self.speed} km/h") + + def adjust_direction(self, new_dir): + global car_direction + self.direction = new_dir + car_direction = new_dir + print(f"行驶方向调整为：{self.direction}") + + def collision_avoidance(self): + """核心避撞逻辑""" + front_dist = self.simulate_sensor("front") + + # 记录数据用于绘图 + distance_history.append(front_dist) + speed_history.append(self.speed) + time_history.append(len(time_history)) + + if front_dist > SAFE_DISTANCE: + self.adjust_speed(NORMAL_SPEED) + self.adjust_direction("forward") + + elif WARNING_DISTANCE < front_dist <= SAFE_DISTANCE: + print("⚠️ 前方接近障碍物，减速！") + self.adjust_speed(LOW_SPEED) + self.adjust_direction("forward") + + elif front_dist <= DANGER_DISTANCE: + print("🚨 前方紧急危险！立即停车！") + self.adjust_speed(STOP_SPEED) + self.adjust_direction("stop") + + left_dist = self.simulate_sensor("left") + right_dist = self.simulate_sensor("right") + + if left_dist > SAFE_DISTANCE: + print("🔄 左侧有空间，转向左侧避障") + self.adjust_direction("left") + self.adjust_speed(LOW_SPEED) + elif right_dist > SAFE_DISTANCE: + print("🔄 右侧有空间，转向右侧避障") + self.adjust_direction("right") + self.adjust_speed(LOW_SPEED) + else: + print("❌ 左右侧均有障碍物，无法避障，保持停车！") + + +# 初始化可视化场景 +def init_visualization(): + # 左侧：场景图（无人车+障碍物） + ax_scene.set_xlim(0, 15) + ax_scene.set_ylim(0, 5) + ax_scene.set_title("无人车避障场景模拟") + ax_scene.set_xlabel("位置 (cm/10)") + ax_scene.set_ylabel("位置 (cm/10)") + ax_scene.grid(True) + + # 右侧：数据曲线图 + ax_plot.set_xlim(0, 20) + ax_plot.set_ylim(0, max(NORMAL_SPEED + 5, SAFE_DISTANCE + 5)) + ax_plot.set_title("实时数据监控") + ax_plot.set_xlabel("检测次数") + ax_plot.set_ylabel("数值") + ax_plot.grid(True) + ax_plot.legend(["前方距离 (cm)", "车速 (km/h)"], loc="upper right") + return ax_scene, ax_plot + + +# 实时更新可视化 +def update_visualization(frame): + # 清空场景图 + ax_scene.clear() + ax_scene.set_xlim(0, 15) + ax_scene.set_ylim(0, 5) + ax_scene.set_title("无人车避障场景模拟") + ax_scene.set_xlabel("位置 (cm/10)") + ax_scene.set_ylabel("位置 (cm/10)") + ax_scene.grid(True) + + # 绘制无人车（矩形） + car_color = "green" if car_direction == "forward" else "yellow" if car_direction in ["left", "right"] else "red" + car = Rectangle((car_pos[0], car_pos[1] - 0.5), 1, 1, color=car_color, label="无人车") + ax_scene.add_patch(car) + + # 绘制障碍物（圆形） + obstacle = Circle(obstacle_pos, 0.3, color="black", label="障碍物") + ax_scene.add_patch(obstacle) + + # 绘制方向标识 + if car_direction == "left": + ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], -0.3, 0, head_width=0.2, color="blue") + elif car_direction == "right": + ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], 0.3, 0, head_width=0.2, color="blue") + elif car_direction == "forward": + ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], 0.3, 0, head_width=0.2, color="blue") + + # 更新曲线图 + ax_plot.clear() + ax_plot.plot(time_history, distance_history, 'b-', label="前方距离 (cm)") + ax_plot.plot(time_history, speed_history, 'r-', label="车速 (km/h)") + # 绘制安全阈值线 + ax_plot.axhline(y=SAFE_DISTANCE, color='g', linestyle='--', label="安全距离") + ax_plot.axhline(y=WARNING_DISTANCE, color='y', linestyle='--', label="警告距离") + ax_plot.axhline(y=DANGER_DISTANCE, color='r', linestyle='--', label="危险距离") + ax_plot.set_xlim(max(0, len(time_history) - 20), len(time_history)) + ax_plot.set_ylim(0, max(NORMAL_SPEED + 5, SAFE_DISTANCE + 5)) + ax_plot.set_title("实时数据监控") + ax_plot.set_xlabel("检测次数") + ax_plot.set_ylabel("数值") + ax_plot.grid(True) + ax_plot.legend(loc="upper right") + + return ax_scene, ax_plot + + +# 主运行逻辑 +if __name__ == "__main__": + car = UnmannedCar() + init_visualization() + + # 启动动画更新（每1秒刷新一次，和传感器检测频率同步） + ani = animation.FuncAnimation(fig, update_visualization, interval=1000, blit=False) + + + # 启动无人车避障逻辑（后台运行） + def run_car(): + print("=== 无人车启动 ===") + try: + while True: + car.collision_avoidance() + time.sleep(1) + except KeyboardInterrupt: + print("\n=== 无人车停止 ===") + car.adjust_speed(STOP_SPEED) + car.adjust_direction("stop") + + + # 多线程运行（避免阻塞可视化） + import threading + + car_thread = threading.Thread(target=run_car) + car_thread.daemon = True + car_thread.start() + + # 显示可视化窗口 + plt.tight_layout() + plt.show() \ No newline at end of file From b951f8c8dcc406b4fa337752b877c6f3d616977d Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 13:19:52 +0800 Subject: [PATCH 07/33] 1 --- src/Smart_car/obstacle_avoidance.py | 376 ++++++++++++++-------------- 1 file changed, 187 insertions(+), 189 deletions(-) diff --git a/src/Smart_car/obstacle_avoidance.py b/src/Smart_car/obstacle_avoidance.py index 1787cd840f..9fb55b685a 100644 --- a/src/Smart_car/obstacle_avoidance.py +++ b/src/Smart_car/obstacle_avoidance.py @@ -1,193 +1,191 @@ import time -import random -import matplotlib.pyplot as plt -import matplotlib.animation as animation -from matplotlib.patches import Rectangle, Circle - -# 无人车状态常量 -SAFE_DISTANCE = 50 # 安全距离（厘米） -WARNING_DISTANCE = 30 # 警告距离（厘米） -DANGER_DISTANCE = 15 # 危险距离（厘米） -NORMAL_SPEED = 20 # 正常速度（km/h） -LOW_SPEED = 5 # 低速（km/h） -STOP_SPEED = 0 # 停车速度 - -# 可视化全局变量 -fig, (ax_scene, ax_plot) = plt.subplots(1, 2, figsize=(12, 5)) -distance_history = [] # 前方距离历史 -speed_history = [] # 车速历史 -time_history = [] # 时间轴 -car_pos = [5, 2.5] # 无人车初始位置（x,y） -obstacle_pos = [0, 0] # 障碍物位置 -car_direction = "forward" - - -class UnmannedCar: +import math +from enum import Enum + +# ======================== 常量定义 ======================== +# 安全参数（可根据车型调整） +SAFE_DISTANCE = 5.0 # 安全距离（米），低于此值触发预警 +EMERGENCY_DISTANCE = 2.0 # 紧急制动距离（米） +MAX_DECELERATION = 8.0 # 最大减速度（m/s²），符合道路安全标准 +TTC_THRESHOLD_LOW = 3.0 # 低风险TTC阈值（秒） +TTC_THRESHOLD_HIGH = 1.5 # 高风险TTC阈值（秒） +VEHICLE_MAX_SPEED = 30.0 # 车辆最大速度（m/s）≈108km/h + +# ======================== 枚举定义 ======================== +class CollisionRiskLevel(Enum): + """碰撞风险等级""" + NONE = 0 # 无风险 + LOW = 1 # 低风险（预警） + MEDIUM = 2 # 中风险（减速） + HIGH = 3 # 高风险（紧急制动） + +class ControlCommand(Enum): + """车辆控制指令""" + NORMAL = 0 # 正常行驶 + WARNING = 1 # 预警（声光提示） + DECELERATE = 2 # 减速 + EMERGENCY_STOP = 3 # 紧急制动 + +# ======================== 核心类实现 ======================== +class Obstacle: + """障碍物类：模拟感知到的障碍物信息""" + def __init__(self, distance: float, relative_speed: float, obstacle_type: str): + """ + :param distance: 障碍物距离（米），正值表示前方 + :param relative_speed: 相对速度（m/s），正值表示靠近 + :param obstacle_type: 障碍物类型（行人/车辆/障碍物） + """ + self.distance = max(0.0, distance) # 距离非负 + self.relative_speed = relative_speed + self.obstacle_type = obstacle_type + self.update_time = time.time() # 感知数据更新时间 + + def update(self, distance: float, relative_speed: float): + """更新障碍物感知数据""" + self.distance = max(0.0, distance) + self.relative_speed = relative_speed + self.update_time = time.time() + +class CollisionPreventionSystem: + """碰撞预防系统核心类""" def __init__(self): - self.speed = 0 - self.direction = "forward" - - def simulate_sensor(self, direction): - """模拟传感器测距（加入轻微固定偏移，让障碍物位置可预测）""" - if direction == "front": - # 模拟障碍物距离缓慢变化（更贴近实际） - base_dist = random.randint(10, 60) if len(distance_history) < 5 else distance_history[-1] + random.randint( - -5, 5) - distance = max(0, min(100, base_dist)) # 限制0-100cm + self.current_speed = 0.0 # 车辆当前速度（m/s） + self.obstacle = None # 感知到的前方障碍物 + self.risk_level = CollisionRiskLevel.NONE + self.control_command = ControlCommand.NORMAL + + def perception_update(self, obstacle_distance: float, obstacle_relative_speed: float, obstacle_type: str): + """ + 更新感知模块数据 + :param obstacle_distance: 障碍物距离（米） + :param obstacle_relative_speed: 相对速度（m/s） + :param obstacle_type: 障碍物类型 + """ + if self.obstacle is None: + self.obstacle = Obstacle(obstacle_distance, obstacle_relative_speed, obstacle_type) else: - distance = random.randint(20, 80) # 左右侧距离 - - # 更新障碍物位置（用于可视化） - global obstacle_pos - obstacle_pos = [car_pos[0] + distance / 10, car_pos[1]] # 缩放适配画布 - print(f"[{direction}] 传感器检测距离：{distance} cm") - return distance - - def adjust_speed(self, new_speed): - self.speed = new_speed - print(f"车速调整为：{self.speed} km/h") - - def adjust_direction(self, new_dir): - global car_direction - self.direction = new_dir - car_direction = new_dir - print(f"行驶方向调整为：{self.direction}") - - def collision_avoidance(self): - """核心避撞逻辑""" - front_dist = self.simulate_sensor("front") - - # 记录数据用于绘图 - distance_history.append(front_dist) - speed_history.append(self.speed) - time_history.append(len(time_history)) - - if front_dist > SAFE_DISTANCE: - self.adjust_speed(NORMAL_SPEED) - self.adjust_direction("forward") - - elif WARNING_DISTANCE < front_dist <= SAFE_DISTANCE: - print("⚠️ 前方接近障碍物，减速！") - self.adjust_speed(LOW_SPEED) - self.adjust_direction("forward") - - elif front_dist <= DANGER_DISTANCE: - print("🚨 前方紧急危险！立即停车！") - self.adjust_speed(STOP_SPEED) - self.adjust_direction("stop") - - left_dist = self.simulate_sensor("left") - right_dist = self.simulate_sensor("right") - - if left_dist > SAFE_DISTANCE: - print("🔄 左侧有空间，转向左侧避障") - self.adjust_direction("left") - self.adjust_speed(LOW_SPEED) - elif right_dist > SAFE_DISTANCE: - print("🔄 右侧有空间，转向右侧避障") - self.adjust_direction("right") - self.adjust_speed(LOW_SPEED) - else: - print("❌ 左右侧均有障碍物，无法避障，保持停车！") - - -# 初始化可视化场景 -def init_visualization(): - # 左侧：场景图（无人车+障碍物） - ax_scene.set_xlim(0, 15) - ax_scene.set_ylim(0, 5) - ax_scene.set_title("无人车避障场景模拟") - ax_scene.set_xlabel("位置 (cm/10)") - ax_scene.set_ylabel("位置 (cm/10)") - ax_scene.grid(True) - - # 右侧：数据曲线图 - ax_plot.set_xlim(0, 20) - ax_plot.set_ylim(0, max(NORMAL_SPEED + 5, SAFE_DISTANCE + 5)) - ax_plot.set_title("实时数据监控") - ax_plot.set_xlabel("检测次数") - ax_plot.set_ylabel("数值") - ax_plot.grid(True) - ax_plot.legend(["前方距离 (cm)", "车速 (km/h)"], loc="upper right") - return ax_scene, ax_plot - - -# 实时更新可视化 -def update_visualization(frame): - # 清空场景图 - ax_scene.clear() - ax_scene.set_xlim(0, 15) - ax_scene.set_ylim(0, 5) - ax_scene.set_title("无人车避障场景模拟") - ax_scene.set_xlabel("位置 (cm/10)") - ax_scene.set_ylabel("位置 (cm/10)") - ax_scene.grid(True) - - # 绘制无人车（矩形） - car_color = "green" if car_direction == "forward" else "yellow" if car_direction in ["left", "right"] else "red" - car = Rectangle((car_pos[0], car_pos[1] - 0.5), 1, 1, color=car_color, label="无人车") - ax_scene.add_patch(car) - - # 绘制障碍物（圆形） - obstacle = Circle(obstacle_pos, 0.3, color="black", label="障碍物") - ax_scene.add_patch(obstacle) - - # 绘制方向标识 - if car_direction == "left": - ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], -0.3, 0, head_width=0.2, color="blue") - elif car_direction == "right": - ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], 0.3, 0, head_width=0.2, color="blue") - elif car_direction == "forward": - ax_scene.arrow(car_pos[0] + 0.5, car_pos[1], 0.3, 0, head_width=0.2, color="blue") - - # 更新曲线图 - ax_plot.clear() - ax_plot.plot(time_history, distance_history, 'b-', label="前方距离 (cm)") - ax_plot.plot(time_history, speed_history, 'r-', label="车速 (km/h)") - # 绘制安全阈值线 - ax_plot.axhline(y=SAFE_DISTANCE, color='g', linestyle='--', label="安全距离") - ax_plot.axhline(y=WARNING_DISTANCE, color='y', linestyle='--', label="警告距离") - ax_plot.axhline(y=DANGER_DISTANCE, color='r', linestyle='--', label="危险距离") - ax_plot.set_xlim(max(0, len(time_history) - 20), len(time_history)) - ax_plot.set_ylim(0, max(NORMAL_SPEED + 5, SAFE_DISTANCE + 5)) - ax_plot.set_title("实时数据监控") - ax_plot.set_xlabel("检测次数") - ax_plot.set_ylabel("数值") - ax_plot.grid(True) - ax_plot.legend(loc="upper right") - - return ax_scene, ax_plot - - -# 主运行逻辑 + self.obstacle.update(obstacle_distance, obstacle_relative_speed) + + def calculate_ttc(self) -> float: + """ + 计算碰撞时间（Time To Collision, TTC） + :return: TTC值（秒），无穷大表示无碰撞风险 + """ + if self.obstacle is None or self.obstacle.relative_speed <= 0: + return float('inf') # 相对速度≤0，无碰撞风险 + return self.obstacle.distance / self.obstacle.relative_speed + + def evaluate_risk(self): + """评估碰撞风险等级""" + ttc = self.calculate_ttc() + distance = self.obstacle.distance if self.obstacle else float('inf') + + # 风险等级判定逻辑 + if ttc >= TTC_THRESHOLD_LOW or distance >= SAFE_DISTANCE: + self.risk_level = CollisionRiskLevel.NONE + elif TTC_THRESHOLD_HIGH <= ttc < TTC_THRESHOLD_LOW or EMERGENCY_DISTANCE <= distance < SAFE_DISTANCE: + self.risk_level = CollisionRiskLevel.LOW if ttc >= TTC_THRESHOLD_HIGH else CollisionRiskLevel.MEDIUM + else: + self.risk_level = CollisionRiskLevel.HIGH + + def generate_control_command(self) -> ControlCommand: + """根据风险等级生成控制指令""" + if self.risk_level == CollisionRiskLevel.NONE: + self.control_command = ControlCommand.NORMAL + elif self.risk_level == CollisionRiskLevel.LOW: + self.control_command = ControlCommand.WARNING + elif self.risk_level == CollisionRiskLevel.MEDIUM: + self.control_command = ControlCommand.DECELERATE + else: + self.control_command = ControlCommand.EMERGENCY_STOP + return self.control_command + + def execute_control(self, command: ControlCommand) -> float: + """ + 执行车辆控制指令，返回控制后的车速 + :param command: 控制指令 + :return: 调整后的车速（m/s） + """ + delta_time = 0.1 # 控制周期（秒），模拟实时控制 + + if command == ControlCommand.NORMAL: + # 正常行驶，维持当前速度（可扩展加速逻辑） + pass + elif command == ControlCommand.WARNING: + # 仅预警，不调整车速（声光提示驾驶员） + print("[预警] 检测到前方障碍物，请注意！") + elif command == ControlCommand.DECELERATE: + # 减速：中等减速度（最大减速度的50%） + deceleration = MAX_DECELERATION * 0.5 + self.current_speed = max(0.0, self.current_speed - deceleration * delta_time) + print(f"[减速] 当前车速：{self.current_speed:.2f} m/s（原速度：{self.current_speed + deceleration * delta_time:.2f} m/s）") + elif command == ControlCommand.EMERGENCY_STOP: + # 紧急制动：最大减速度 + deceleration = MAX_DECELERATION + self.current_speed = max(0.0, self.current_speed - deceleration * delta_time) + print(f"[紧急制动] 当前车速：{self.current_speed:.2f} m/s（紧急制动中）") + + # 限制车速不超过最大值 + self.current_speed = min(self.current_speed, VEHICLE_MAX_SPEED) + return self.current_speed + + def run_cycle(self, obstacle_distance: float, obstacle_relative_speed: float, obstacle_type: str, current_speed: float): + """ + 碰撞预防系统单次运行周期 + :param obstacle_distance: 障碍物距离（米） + :param obstacle_relative_speed: 相对速度（m/s） + :param obstacle_type: 障碍物类型 + :param current_speed: 车辆当前速度（m/s） + """ + # 1. 更新车辆当前速度 + self.current_speed = current_speed + + # 2. 更新感知数据 + self.perception_update(obstacle_distance, obstacle_relative_speed, obstacle_type) + + # 3. 风险评估 + self.evaluate_risk() + + # 4. 生成控制指令 + command = self.generate_control_command() + + # 5. 执行控制 + new_speed = self.execute_control(command) + + # 6. 输出状态信息 + print(f"\n=== 系统状态 ===") + print(f"障碍物类型：{obstacle_type}") + print(f"障碍物距离：{self.obstacle.distance:.2f} 米") + print(f"相对速度：{self.obstacle.relative_speed:.2f} m/s") + print(f"碰撞时间（TTC）：{self.calculate_ttc():.2f} 秒") + print(f"风险等级：{self.risk_level.name}") + print(f"控制指令：{command.name}") + print(f"当前车速：{new_speed:.2f} m/s") + +# ======================== 测试用例 ======================== if __name__ == "__main__": - car = UnmannedCar() - init_visualization() - - # 启动动画更新（每1秒刷新一次，和传感器检测频率同步） - ani = animation.FuncAnimation(fig, update_visualization, interval=1000, blit=False) - - - # 启动无人车避障逻辑（后台运行） - def run_car(): - print("=== 无人车启动 ===") - try: - while True: - car.collision_avoidance() - time.sleep(1) - except KeyboardInterrupt: - print("\n=== 无人车停止 ===") - car.adjust_speed(STOP_SPEED) - car.adjust_direction("stop") - - - # 多线程运行（避免阻塞可视化） - import threading - - car_thread = threading.Thread(target=run_car) - car_thread.daemon = True - car_thread.start() - - # 显示可视化窗口 - plt.tight_layout() - plt.show() \ No newline at end of file + # 初始化碰撞预防系统 + cps = CollisionPreventionSystem() + + # 模拟不同场景的运行周期 + test_scenarios = [ + # 场景1：无风险（远距离、低相对速度） + {"distance": 10.0, "relative_speed": 1.0, "type": "车辆", "speed": 15.0}, + # 场景2：低风险（预警） + {"distance": 6.0, "relative_speed": 3.0, "type": "行人", "speed": 10.0}, + # 场景3：中风险（减速） + {"distance": 3.0, "relative_speed": 4.0, "type": "障碍物", "speed": 8.0}, + # 场景4：高风险（紧急制动） + {"distance": 1.5, "relative_speed": 5.0, "type": "车辆", "speed": 6.0}, + ] + + # 运行测试场景 + for i, scenario in enumerate(test_scenarios): + print(f"\n==================== 测试场景 {i+1} ====================") + cps.run_cycle( + obstacle_distance=scenario["distance"], + obstacle_relative_speed=scenario["relative_speed"], + obstacle_type=scenario["type"], + current_speed=scenario["speed"] + ) + time.sleep(0.5) # 模拟时间间隔 \ No newline at end of file From 3b4d225ea4d8c231b92b5ee53cc9bc2c452d6d7e Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 15:21:08 +0800 Subject: [PATCH 08/33] 1 --- src/Smart_car/temperature.py | 149 +++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 src/Smart_car/temperature.py diff --git a/src/Smart_car/temperature.py b/src/Smart_car/temperature.py new file mode 100644 index 0000000000..98248ab38e --- /dev/null +++ b/src/Smart_car/temperature.py @@ -0,0 +1,149 @@ +import time +import random +from enum import Enum + +# 定义温度调节模式枚举 +class TempMode(Enum): + AUTO = "自动模式" # 自动根据目标温度调节 + COOL = "制冷模式" # 仅制冷 + HEAT = "制热模式" # 仅制热 + FAN = "仅吹风模式" # 仅通风，不控温 + OFF = "关闭模式" # 系统关闭 + +# 定义温度调节系统类 +class AutoCarTempSystem: + def __init__(self): + # 系统基础配置 + self.target_temp = 25.0 # 目标温度(℃)，默认25℃ + self.current_temp = 25.0 # 当前温度(℃)，初始默认值 + self.mode = TempMode.AUTO # 初始模式：自动 + self.fan_speed = 2 # 风扇转速(1-5档)，默认2档 + self.is_running = True # 系统运行状态 + self.temp_tolerance = 0.5 # 温度容差(℃)，避免频繁启停 + self.max_temp = 45.0 # 最高安全温度 + self.min_temp = 5.0 # 最低安全温度 + + def simulate_temp_sensor(self): + """模拟温度传感器读取当前温度（含微小波动）""" + # 模拟真实环境温度波动 ±0.3℃ + fluctuation = random.uniform(-0.3, 0.3) + self.current_temp += fluctuation + # 限制温度在安全范围内 + self.current_temp = max(self.min_temp, min(self.max_temp, self.current_temp)) + return round(self.current_temp, 1) + + def set_target_temp(self, temp): + """设置目标温度（含合法性校验）""" + if self.min_temp <= temp <= self.max_temp: + self.target_temp = temp + print(f"✅ 目标温度已设置为：{temp}℃") + else: + print(f"❌ 温度设置失败！请设置{self.min_temp}~{self.max_temp}℃范围内的温度") + + def set_mode(self, new_mode): + """切换温度调节模式""" + if isinstance(new_mode, TempMode): + self.mode = new_mode + print(f"🔄 模式已切换为：{new_mode.value}") + # 切换到关闭模式时停止风扇 + if new_mode == TempMode.OFF: + self.fan_speed = 0 + self.is_running = False + print("🔴 温度调节系统已关闭") + else: + self.is_running = True + if self.fan_speed == 0: + self.fan_speed = 2 # 切换回运行模式时默认2档风速 + else: + print("❌ 模式设置失败！请传入合法的TempMode枚举值") + + def set_fan_speed(self, speed): + """设置风扇转速（1-5档）""" + if 1 <= speed <= 5: + self.fan_speed = speed + print(f"🌬️ 风扇转速已设置为：{speed}档") + else: + print("❌ 风速设置失败！请设置1~5档范围内的转速") + + def adjust_temp(self): + """核心温度调节逻辑""" + if not self.is_running: + return + + current_temp = self.simulate_temp_sensor() + target_temp = self.target_temp + temp_diff = current_temp - target_temp + + # 根据模式执行调节逻辑 + if self.mode == TempMode.AUTO: + # 自动模式：温差超过容差时触发制冷/制热 + if temp_diff > self.temp_tolerance: + self._cooling() + elif temp_diff < -self.temp_tolerance: + self._heating() + else: + self._fan_only() # 温度达标仅吹风 + + elif self.mode == TempMode.COOL: + self._cooling() if temp_diff > self.temp_tolerance else self._fan_only() + + elif self.mode == TempMode.HEAT: + self._heating() if temp_diff < -self.temp_tolerance else self._fan_only() + + elif self.mode == TempMode.FAN: + self._fan_only() + + # 打印当前状态 + self._print_status() + + def _cooling(self): + """制冷逻辑：降低当前温度""" + # 制冷效率与风扇转速正相关 + cool_rate = 0.2 * self.fan_speed + self.current_temp -= cool_rate + self.current_temp = max(self.min_temp, self.current_temp) # 不低于最低温 + + def _heating(self): + """制热逻辑：升高当前温度""" + heat_rate = 0.15 * self.fan_speed + self.current_temp += heat_rate + self.current_temp = min(self.max_temp, self.current_temp) # 不高于最高温 + + def _fan_only(self): + """仅吹风：温度不变，维持通风""" + pass + + def _print_status(self): + """打印当前系统状态""" + print(f"\n📊 当前系统状态：") + print(f" 当前温度：{round(self.current_temp, 1)}℃ | 目标温度：{self.target_temp}℃") + print(f" 运行模式：{self.mode.value} | 风扇转速：{self.fan_speed}档") + print("-" * 40) + + def run(self, duration=10): + """运行系统（模拟duration秒的调节过程）""" + print("🚗 无人车温度调节系统启动...") + start_time = time.time() + while time.time() - start_time < duration: + self.adjust_temp() + time.sleep(1) # 每秒调节一次 + print("⏹️ 系统模拟运行结束") + + +# 测试示例 +if __name__ == "__main__": + # 初始化温度调节系统 + temp_system = AutoCarTempSystem() + + # 模拟场景1：初始温度25℃，设置目标22℃，自动模式运行5秒 + temp_system.set_target_temp(22.0) + temp_system.run(duration=5) + + # 模拟场景2：切换到制热模式，设置目标28℃，风速4档，运行5秒 + temp_system.set_mode(TempMode.HEAT) + temp_system.set_target_temp(28.0) + temp_system.set_fan_speed(4) + temp_system.run(duration=5) + + # 模拟场景3：切换到关闭模式 + temp_system.set_mode(TempMode.OFF) \ No newline at end of file From cd465f08011622a705c1a70019e2599a0a2e1e49 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 16:14:29 +0800 Subject: [PATCH 09/33] 1 --- src/Smart_car/temperature.py | 300 ++++++++++++++++++++--------------- 1 file changed, 173 insertions(+), 127 deletions(-) diff --git a/src/Smart_car/temperature.py b/src/Smart_car/temperature.py index 98248ab38e..42e27b886e 100644 --- a/src/Smart_car/temperature.py +++ b/src/Smart_car/temperature.py @@ -2,148 +2,194 @@ import random from enum import Enum -# 定义温度调节模式枚举 -class TempMode(Enum): - AUTO = "自动模式" # 自动根据目标温度调节 - COOL = "制冷模式" # 仅制冷 - HEAT = "制热模式" # 仅制热 - FAN = "仅吹风模式" # 仅通风，不控温 - OFF = "关闭模式" # 系统关闭 - -# 定义温度调节系统类 -class AutoCarTempSystem: +# 定义系统常量 +DEFAULT_TARGET_TEMP = 24 # 默认目标温度(℃) +TEMP_TOLERANCE = 1 # 温度容差(℃) +MAX_FAN_SPEED = 5 # 最大风速档 +MIN_FAN_SPEED = 1 # 最小风速档 + + +# 空调模式枚举 +class AC_Mode(Enum): + COOL = "制冷" + HEAT = "制热" + VENT = "通风" + OFF = "关闭" + + +# 运行模式枚举 +class Run_Mode(Enum): + AUTO = "自动" + MANUAL = "手动" + + +class TemperatureSensor: + """温度传感器类 - 模拟采集车内/车外温度""" + def __init__(self): - # 系统基础配置 - self.target_temp = 25.0 # 目标温度(℃)，默认25℃ - self.current_temp = 25.0 # 当前温度(℃)，初始默认值 - self.mode = TempMode.AUTO # 初始模式：自动 - self.fan_speed = 2 # 风扇转速(1-5档)，默认2档 - self.is_running = True # 系统运行状态 - self.temp_tolerance = 0.5 # 温度容差(℃)，避免频繁启停 - self.max_temp = 45.0 # 最高安全温度 - self.min_temp = 5.0 # 最低安全温度 - - def simulate_temp_sensor(self): - """模拟温度传感器读取当前温度（含微小波动）""" - # 模拟真实环境温度波动 ±0.3℃ - fluctuation = random.uniform(-0.3, 0.3) - self.current_temp += fluctuation - # 限制温度在安全范围内 - self.current_temp = max(self.min_temp, min(self.max_temp, self.current_temp)) - return round(self.current_temp, 1) + self.interior_temp = 25 # 初始车内温度 + self.exterior_temp = 30 # 初始车外温度 - def set_target_temp(self, temp): - """设置目标温度（含合法性校验）""" - if self.min_temp <= temp <= self.max_temp: - self.target_temp = temp - print(f"✅ 目标温度已设置为：{temp}℃") - else: - print(f"❌ 温度设置失败！请设置{self.min_temp}~{self.max_temp}℃范围内的温度") - - def set_mode(self, new_mode): - """切换温度调节模式""" - if isinstance(new_mode, TempMode): - self.mode = new_mode - print(f"🔄 模式已切换为：{new_mode.value}") - # 切换到关闭模式时停止风扇 - if new_mode == TempMode.OFF: - self.fan_speed = 0 - self.is_running = False - print("🔴 温度调节系统已关闭") - else: - self.is_running = True - if self.fan_speed == 0: - self.fan_speed = 2 # 切换回运行模式时默认2档风速 - else: - print("❌ 模式设置失败！请传入合法的TempMode枚举值") + def read_temperatures(self): + """模拟读取温度（加入微小随机波动）""" + self.interior_temp += random.uniform(-0.5, 0.5) + self.exterior_temp += random.uniform(-0.8, 0.8) + # 温度边界限制 + self.interior_temp = max(10, min(45, self.interior_temp)) + self.exterior_temp = max(-20, min(50, self.exterior_temp)) + return round(self.interior_temp, 1), round(self.exterior_temp, 1) + + +class SunlightSensor: + """阳光强度传感器 - 影响车内温度变化""" + + def read_intensity(self): + """返回0-10的阳光强度值""" + return round(random.uniform(0, 10), 1) - def set_fan_speed(self, speed): - """设置风扇转速（1-5档）""" - if 1 <= speed <= 5: - self.fan_speed = speed - print(f"🌬️ 风扇转速已设置为：{speed}档") - else: - print("❌ 风速设置失败！请设置1~5档范围内的转速") - - def adjust_temp(self): - """核心温度调节逻辑""" - if not self.is_running: - return - - current_temp = self.simulate_temp_sensor() - target_temp = self.target_temp - temp_diff = current_temp - target_temp - - # 根据模式执行调节逻辑 - if self.mode == TempMode.AUTO: - # 自动模式：温差超过容差时触发制冷/制热 - if temp_diff > self.temp_tolerance: - self._cooling() - elif temp_diff < -self.temp_tolerance: - self._heating() - else: - self._fan_only() # 温度达标仅吹风 - elif self.mode == TempMode.COOL: - self._cooling() if temp_diff > self.temp_tolerance else self._fan_only() +class PassengerDetector: + """乘客检测 - 模拟检测车内乘客数量""" - elif self.mode == TempMode.HEAT: - self._heating() if temp_diff < -self.temp_tolerance else self._fan_only() + def get_passenger_count(self): + """返回0-5的乘客数""" + return random.randint(0, 5) - elif self.mode == TempMode.FAN: - self._fan_only() - # 打印当前状态 - self._print_status() +class AirConditioner: + """空调执行器类 - 控制空调运行""" - def _cooling(self): - """制冷逻辑：降低当前温度""" - # 制冷效率与风扇转速正相关 - cool_rate = 0.2 * self.fan_speed - self.current_temp -= cool_rate - self.current_temp = max(self.min_temp, self.current_temp) # 不低于最低温 + def __init__(self): + self.ac_mode = AC_Mode.OFF + self.fan_speed = MIN_FAN_SPEED + self.target_temp = DEFAULT_TARGET_TEMP + self.run_mode = Run_Mode.AUTO + + def set_mode(self, mode): + """设置空调模式""" + if isinstance(mode, AC_Mode): + self.ac_mode = mode + print(f"空调模式已切换为: {self.ac_mode.value}") + + def set_fan_speed(self, speed): + """设置风速（1-5档）""" + if MIN_FAN_SPEED <= speed <= MAX_FAN_SPEED: + self.fan_speed = speed + print(f"风速已设置为: {self.fan_speed}档") + + def set_target_temp(self, temp): + """设置目标温度（16-30℃）""" + if 16 <= temp <= 30: + self.target_temp = temp + print(f"目标温度已设置为: {self.target_temp}℃") - def _heating(self): - """制热逻辑：升高当前温度""" - heat_rate = 0.15 * self.fan_speed - self.current_temp += heat_rate - self.current_temp = min(self.max_temp, self.current_temp) # 不高于最高温 + def set_run_mode(self, mode): + """设置运行模式（自动/手动）""" + if isinstance(mode, Run_Mode): + self.run_mode = mode + print(f"运行模式已切换为: {self.run_mode.value}") - def _fan_only(self): - """仅吹风：温度不变，维持通风""" - pass - def _print_status(self): - """打印当前系统状态""" - print(f"\n📊 当前系统状态：") - print(f" 当前温度：{round(self.current_temp, 1)}℃ | 目标温度：{self.target_temp}℃") - print(f" 运行模式：{self.mode.value} | 风扇转速：{self.fan_speed}档") - print("-" * 40) +class TemperatureControlSystem: + """无人车温度调节核心系统""" + + def __init__(self): + # 初始化传感器和执行器 + self.temp_sensor = TemperatureSensor() + self.sun_sensor = SunlightSensor() + self.passenger_detector = PassengerDetector() + self.aircon = AirConditioner() + + def calculate_adjustment(self): + """核心算法：根据环境参数计算空调调节策略""" + interior_temp, exterior_temp = self.temp_sensor.read_temperatures() + sunlight_intensity = self.sun_sensor.read_intensity() + passenger_count = self.passenger_detector.get_passenger_count() + + # 打印当前环境参数 + print(f"\n=== 环境参数 ===") + print(f"车内温度: {interior_temp}℃") + print(f"车外温度: {exterior_temp}℃") + print(f"阳光强度: {sunlight_intensity}") + print(f"乘客数量: {passenger_count}") + + # 目标温度动态调整（乘客越多/阳光越强，目标温度略低） + base_target = DEFAULT_TARGET_TEMP + dynamic_target = base_target - (passenger_count * 0.5) - (sunlight_intensity * 0.2) + dynamic_target = max(18, min(26, dynamic_target)) # 限制在18-26℃ + + # 自动模式下的调节逻辑 + if self.aircon.run_mode == Run_Mode.AUTO: + # 温度偏差计算 + temp_diff = interior_temp - dynamic_target + + # 制冷逻辑 + if temp_diff > TEMP_TOLERANCE: + self.aircon.set_mode(AC_Mode.COOL) + # 温差越大，风速越高 + fan_speed = MIN_FAN_SPEED + min(int(temp_diff), MAX_FAN_SPEED - MIN_FAN_SPEED) + self.aircon.set_fan_speed(fan_speed) + self.aircon.set_target_temp(dynamic_target) + + # 制热逻辑 + elif temp_diff < -TEMP_TOLERANCE: + self.aircon.set_mode(AC_Mode.HEAT) + fan_speed = MIN_FAN_SPEED + min(int(abs(temp_diff)), MAX_FAN_SPEED - MIN_FAN_SPEED) + self.aircon.set_fan_speed(fan_speed) + self.aircon.set_target_temp(dynamic_target) + + # 温度适宜 - 通风模式 + else: + self.aircon.set_mode(AC_Mode.VENT) + self.aircon.set_fan_speed(MIN_FAN_SPEED) + + # 打印当前空调状态 + print(f"\n=== 空调状态 ===") + print(f"运行模式: {self.aircon.run_mode.value}") + print(f"空调模式: {self.aircon.ac_mode.value}") + print(f"目标温度: {self.aircon.target_temp}℃") + print(f"当前风速: {self.aircon.fan_speed}档") + + def manual_control(self, mode, target_temp=None, fan_speed=None): + """手动控制接口""" + if self.aircon.run_mode != Run_Mode.MANUAL: + self.aircon.set_run_mode(Run_Mode.MANUAL) + + self.aircon.set_mode(mode) + if target_temp: + self.aircon.set_target_temp(target_temp) + if fan_speed: + self.aircon.set_fan_speed(fan_speed) def run(self, duration=10): - """运行系统（模拟duration秒的调节过程）""" - print("🚗 无人车温度调节系统启动...") + """系统主运行函数""" + print("无人车温度调节系统启动...") + print(f"系统将运行 {duration} 秒，自动调节温度") + start_time = time.time() while time.time() - start_time < duration: - self.adjust_temp() - time.sleep(1) # 每秒调节一次 - print("⏹️ 系统模拟运行结束") + self.calculate_adjustment() + time.sleep(2) # 每2秒调节一次 + print("\n系统运行结束") -# 测试示例 -if __name__ == "__main__": - # 初始化温度调节系统 - temp_system = AutoCarTempSystem() - - # 模拟场景1：初始温度25℃，设置目标22℃，自动模式运行5秒 - temp_system.set_target_temp(22.0) - temp_system.run(duration=5) - # 模拟场景2：切换到制热模式，设置目标28℃，风速4档，运行5秒 - temp_system.set_mode(TempMode.HEAT) - temp_system.set_target_temp(28.0) - temp_system.set_fan_speed(4) - temp_system.run(duration=5) - - # 模拟场景3：切换到关闭模式 - temp_system.set_mode(TempMode.OFF) \ No newline at end of file +# 测试代码 +if __name__ == "__main__": + # 初始化系统 + temp_system = TemperatureControlSystem() + + # 示例1：自动模式运行10秒 + temp_system.run(duration=10) + + # 示例2：切换到手动模式，设置制冷22℃，3档风速 + print("\n--- 切换到手动模式 ---") + temp_system.manual_control( + mode=AC_Mode.COOL, + target_temp=22, + fan_speed=3 + ) + + # 手动模式下继续运行5秒 + time.sleep(5) + temp_system.calculate_adjustment() \ No newline at end of file From d39e44677353485d2092d5f6e812c8243d4d8011 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 17:05:22 +0800 Subject: [PATCH 10/33] 1 --- src/Smart_car/temperature.py | 284 ++++++++++++----------------------- 1 file changed, 94 insertions(+), 190 deletions(-) diff --git a/src/Smart_car/temperature.py b/src/Smart_car/temperature.py index 42e27b886e..9a2784d2bb 100644 --- a/src/Smart_car/temperature.py +++ b/src/Smart_car/temperature.py @@ -1,195 +1,99 @@ -import time +import tkinter as tk +from tkinter import ttk import random -from enum import Enum - -# 定义系统常量 -DEFAULT_TARGET_TEMP = 24 # 默认目标温度(℃) -TEMP_TOLERANCE = 1 # 温度容差(℃) -MAX_FAN_SPEED = 5 # 最大风速档 -MIN_FAN_SPEED = 1 # 最小风速档 - - -# 空调模式枚举 -class AC_Mode(Enum): - COOL = "制冷" - HEAT = "制热" - VENT = "通风" - OFF = "关闭" - - -# 运行模式枚举 -class Run_Mode(Enum): - AUTO = "自动" - MANUAL = "手动" - +import time -class TemperatureSensor: - """温度传感器类 - 模拟采集车内/车外温度""" - - def __init__(self): - self.interior_temp = 25 # 初始车内温度 - self.exterior_temp = 30 # 初始车外温度 - - def read_temperatures(self): - """模拟读取温度（加入微小随机波动）""" - self.interior_temp += random.uniform(-0.5, 0.5) - self.exterior_temp += random.uniform(-0.8, 0.8) - # 温度边界限制 - self.interior_temp = max(10, min(45, self.interior_temp)) - self.exterior_temp = max(-20, min(50, self.exterior_temp)) - return round(self.interior_temp, 1), round(self.exterior_temp, 1) - - -class SunlightSensor: - """阳光强度传感器 - 影响车内温度变化""" - - def read_intensity(self): - """返回0-10的阳光强度值""" - return round(random.uniform(0, 10), 1) - - -class PassengerDetector: - """乘客检测 - 模拟检测车内乘客数量""" - - def get_passenger_count(self): - """返回0-5的乘客数""" - return random.randint(0, 5) - - -class AirConditioner: - """空调执行器类 - 控制空调运行""" - - def __init__(self): - self.ac_mode = AC_Mode.OFF - self.fan_speed = MIN_FAN_SPEED - self.target_temp = DEFAULT_TARGET_TEMP - self.run_mode = Run_Mode.AUTO - - def set_mode(self, mode): - """设置空调模式""" - if isinstance(mode, AC_Mode): - self.ac_mode = mode - print(f"空调模式已切换为: {self.ac_mode.value}") - - def set_fan_speed(self, speed): - """设置风速（1-5档）""" - if MIN_FAN_SPEED <= speed <= MAX_FAN_SPEED: - self.fan_speed = speed - print(f"风速已设置为: {self.fan_speed}档") - - def set_target_temp(self, temp): - """设置目标温度（16-30℃）""" - if 16 <= temp <= 30: - self.target_temp = temp - print(f"目标温度已设置为: {self.target_temp}℃") - - def set_run_mode(self, mode): - """设置运行模式（自动/手动）""" - if isinstance(mode, Run_Mode): - self.run_mode = mode - print(f"运行模式已切换为: {self.run_mode.value}") - - -class TemperatureControlSystem: - """无人车温度调节核心系统""" - - def __init__(self): - # 初始化传感器和执行器 - self.temp_sensor = TemperatureSensor() - self.sun_sensor = SunlightSensor() - self.passenger_detector = PassengerDetector() - self.aircon = AirConditioner() - - def calculate_adjustment(self): - """核心算法：根据环境参数计算空调调节策略""" - interior_temp, exterior_temp = self.temp_sensor.read_temperatures() - sunlight_intensity = self.sun_sensor.read_intensity() - passenger_count = self.passenger_detector.get_passenger_count() - - # 打印当前环境参数 - print(f"\n=== 环境参数 ===") - print(f"车内温度: {interior_temp}℃") - print(f"车外温度: {exterior_temp}℃") - print(f"阳光强度: {sunlight_intensity}") - print(f"乘客数量: {passenger_count}") - - # 目标温度动态调整（乘客越多/阳光越强，目标温度略低） - base_target = DEFAULT_TARGET_TEMP - dynamic_target = base_target - (passenger_count * 0.5) - (sunlight_intensity * 0.2) - dynamic_target = max(18, min(26, dynamic_target)) # 限制在18-26℃ - - # 自动模式下的调节逻辑 - if self.aircon.run_mode == Run_Mode.AUTO: - # 温度偏差计算 - temp_diff = interior_temp - dynamic_target - - # 制冷逻辑 - if temp_diff > TEMP_TOLERANCE: - self.aircon.set_mode(AC_Mode.COOL) - # 温差越大，风速越高 - fan_speed = MIN_FAN_SPEED + min(int(temp_diff), MAX_FAN_SPEED - MIN_FAN_SPEED) - self.aircon.set_fan_speed(fan_speed) - self.aircon.set_target_temp(dynamic_target) - - # 制热逻辑 - elif temp_diff < -TEMP_TOLERANCE: - self.aircon.set_mode(AC_Mode.HEAT) - fan_speed = MIN_FAN_SPEED + min(int(abs(temp_diff)), MAX_FAN_SPEED - MIN_FAN_SPEED) - self.aircon.set_fan_speed(fan_speed) - self.aircon.set_target_temp(dynamic_target) - - # 温度适宜 - 通风模式 +class UAVTemperatureSystem: + def __init__(self, root): + self.root = root + self.root.title("无人车温度调节系统仿真") + self.root.geometry("500x400") + + # 温度参数初始化 + self.current_temp = 25.0 # 初始温度 + self.target_temp = 25.0 # 目标温度 + self.max_temp = 35.0 # 温度上限 + self.min_temp = 15.0 # 温度下限 + + # 创建UI组件 + self.create_widgets() + + # 启动温度监测循环 + self.update_temp() + + def create_widgets(self): + # 标题标签 + ttk.Label(self.root, text="无人车温度调节系统", font=("Arial", 16, "bold")).pack(pady=10) + + # 当前温度显示 + self.temp_label = ttk.Label(self.root, text=f"当前温度: {self.current_temp:.1f} °C", font=("Arial", 14)) + self.temp_label.pack(pady=5) + + # 目标温度设置 + ttk.Label(self.root, text="设置目标温度:").pack(pady=2) + self.target_entry = ttk.Entry(self.root, width=10) + self.target_entry.insert(0, "25") + self.target_entry.pack(pady=2) + ttk.Button(self.root, text="确认设置", command=self.set_target_temp).pack(pady=5) + + # 系统状态显示 + self.status_label = ttk.Label(self.root, text="系统状态: 待机", font=("Arial", 12), foreground="blue") + self.status_label.pack(pady=10) + + # 温度曲线画布（简易模拟） + self.canvas = tk.Canvas(self.root, width=400, height=150, bg="white") + self.canvas.pack(pady=10) + self.canvas.create_line(10, 75, 390, 75, fill="black") # 基准线 + self.canvas.create_text(200, 10, text="温度变化趋势", font=("Arial", 10)) + + self.x_pos = 10 # 曲线绘制横坐标 + + def set_target_temp(self): + try: + self.target_temp = float(self.target_entry.get()) + self.status_label.config(text=f"目标温度已设为: {self.target_temp:.1f} °C", foreground="green") + except ValueError: + self.status_label.config(text="输入无效！请输入数字", foreground="red") + + def update_temp(self): + # 模拟温度波动（无人车运行时的温度变化） + self.current_temp += random.uniform(-0.5, 0.8) + self.current_temp = round(self.current_temp, 1) + + # 更新温度显示 + self.temp_label.config(text=f"当前温度: {self.current_temp:.1f} °C") + + # 判断温度状态并执行调节逻辑 + if self.current_temp > self.max_temp: + self.status_label.config(text="状态: 温度过高 → 启动制冷系统", foreground="red") + self.current_temp -= 1.2 # 制冷降温 + elif self.current_temp < self.min_temp: + self.status_label.config(text="状态: 温度过低 → 启动加热系统", foreground="orange") + self.current_temp += 1.2 # 加热升温 + elif abs(self.current_temp - self.target_temp) > 1.0: + if self.current_temp > self.target_temp: + self.status_label.config(text="状态: 高于目标 → 轻度制冷", foreground="blue") + self.current_temp -= 0.5 else: - self.aircon.set_mode(AC_Mode.VENT) - self.aircon.set_fan_speed(MIN_FAN_SPEED) - - # 打印当前空调状态 - print(f"\n=== 空调状态 ===") - print(f"运行模式: {self.aircon.run_mode.value}") - print(f"空调模式: {self.aircon.ac_mode.value}") - print(f"目标温度: {self.aircon.target_temp}℃") - print(f"当前风速: {self.aircon.fan_speed}档") - - def manual_control(self, mode, target_temp=None, fan_speed=None): - """手动控制接口""" - if self.aircon.run_mode != Run_Mode.MANUAL: - self.aircon.set_run_mode(Run_Mode.MANUAL) - - self.aircon.set_mode(mode) - if target_temp: - self.aircon.set_target_temp(target_temp) - if fan_speed: - self.aircon.set_fan_speed(fan_speed) - - def run(self, duration=10): - """系统主运行函数""" - print("无人车温度调节系统启动...") - print(f"系统将运行 {duration} 秒，自动调节温度") - - start_time = time.time() - while time.time() - start_time < duration: - self.calculate_adjustment() - time.sleep(2) # 每2秒调节一次 - - print("\n系统运行结束") - + self.status_label.config(text="状态: 低于目标 → 轻度加热", foreground="blue") + else: + self.status_label.config(text="状态: 温度正常 → 系统待机", foreground="green") + + # 绘制温度变化曲线 + y_pos = 75 - (self.current_temp - 25) * 5 # 映射温度到画布坐标 + if self.x_pos < 390: + self.canvas.create_line(self.x_pos, 75, self.x_pos + 1, y_pos, fill="red", width=2) + self.x_pos += 1 + else: + # 曲线满屏后重置 + self.canvas.delete("all") + self.canvas.create_line(10, 75, 390, 75, fill="black") + self.x_pos = 10 + + # 每隔1秒更新一次 + self.root.after(1000, self.update_temp) -# 测试代码 if __name__ == "__main__": - # 初始化系统 - temp_system = TemperatureControlSystem() - - # 示例1：自动模式运行10秒 - temp_system.run(duration=10) - - # 示例2：切换到手动模式，设置制冷22℃，3档风速 - print("\n--- 切换到手动模式 ---") - temp_system.manual_control( - mode=AC_Mode.COOL, - target_temp=22, - fan_speed=3 - ) - - # 手动模式下继续运行5秒 - time.sleep(5) - temp_system.calculate_adjustment() \ No newline at end of file + root = tk.Tk() + app = UAVTemperatureSystem(root) + root.mainloop() \ No newline at end of file From 3d6656916b86ba496e4ae2d6a871882a889b98ab Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 21:18:24 +0800 Subject: [PATCH 11/33] 1 --- src/Smart_car/{temperature.py => overweight.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/Smart_car/{temperature.py => overweight.py} (100%) diff --git a/src/Smart_car/temperature.py b/src/Smart_car/overweight.py similarity index 100% rename from src/Smart_car/temperature.py rename to src/Smart_car/overweight.py From 179dbe9e4a5672ee7afd5c2a9f31264e5992bccc Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Fri, 19 Dec 2025 22:36:38 +0800 Subject: [PATCH 12/33] 1 --- src/Smart_car/overload.py | 72 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 src/Smart_car/overload.py diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py new file mode 100644 index 0000000000..add2d37219 --- /dev/null +++ b/src/Smart_car/overload.py @@ -0,0 +1,72 @@ +import time +import random + +class UnmannedVehicleOverloadWarningSystem: + """无人车超载预警系统""" + def __init__(self, max_load=1000): + # 初始化系统参数 + self.max_load = max_load # 车辆最大载重（单位：kg，可自定义） + self.current_load = 0 # 当前载重 + self.warning_level = 0 # 预警等级：0-正常，1-轻度过载，2-中度过载，3-严重超载 + + def simulate_weight_collection(self): + """模拟无人车重量采集（模拟传感器数据，可替换为真实硬件接口）""" + # 模拟载重变化：每次在当前基础上小幅波动（模拟乘客/货物上下车） + weight_change = random.randint(-50, 100) + self.current_load = max(0, self.current_load + weight_change) # 载重不能为负数 + return self.current_load + + def judge_overload(self): + """超载判断逻辑，划分预警等级""" + load_ratio = self.current_load / self.max_load # 载重占比 + + if load_ratio <= 0.8: + self.warning_level = 0 # 正常：载重≤80%最大载重 + return "正常", "绿色", "当前载重未超出安全范围，无需处理" + elif 0.8 < load_ratio <= 0.95: + self.warning_level = 1 # 轻度过载：80%<载重≤95% + return "轻度过载预警", "黄色", "当前载重接近上限，建议停止加载" + elif 0.95 < load_ratio <= 1.1: + self.warning_level = 2 # 中度过载：95%<载重≤110% + return "中度过载警告", "橙色", "当前载重已超出安全上限，立即停止运行并卸载部分货物" + else: + self.warning_level = 3 # 严重超载：载重>110% + return "严重超载警报", "红色", "极度危险！立即紧急制动，联系工作人员处理" + + def display_warning(self, status, color, desc): + """可视化输出预警信息（模拟车载终端显示）""" + print("=" * 50) + print(f"【无人车超载预警系统 - 实时监测】") + print(f"当前时间：{time.strftime('%Y-%m-%d %H:%M:%S')}") + print(f"最大载重：{self.max_load} kg") + print(f"当前载重：{self.current_load:.2f} kg") + print(f"载重占比：{self.current_load/self.max_load*100:.2f}%") + print(f"预警状态：【{status}】（{color}）") + print(f"处理建议：{desc}") + print("=" * 50) + print() + + def run(self, monitor_times=10): + """运行系统，持续监测载重并输出预警""" + print("无人车超载预警系统已启动...") + print(f"开始持续监测（共监测{monitor_times}次，每次间隔2秒）\n") + + for i in range(monitor_times): + # 1. 采集当前载重（模拟） + self.simulate_weight_collection() + # 2. 判断超载等级 + status, color, desc = self.judge_overload() + # 3. 显示预警信息 + self.display_warning(status, color, desc) + # 4. 严重超载时紧急停止 + if self.warning_level == 3: + print("❗❗❗ 检测到严重超载，系统紧急停止运行！ ❗❗❗") + break + # 5. 间隔2秒进行下一次监测 + time.sleep(2) + +if __name__ == "__main__": + # 初始化系统：设置无人车最大载重为1000kg（可根据需求修改） + overload_system = UnmannedVehicleOverloadWarningSystem(max_load=1000) + # 运行系统，持续监测10次（可修改监测次数） + overload_system.run(monitor_times=10) \ No newline at end of file From 88f2251357c1c1c7cf818b3c6222d6ab005f4959 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sat, 20 Dec 2025 13:53:07 +0800 Subject: [PATCH 13/33] 1 --- src/Smart_car/obstacle_avoidance.py | 123 +++++++++++++++------------- 1 file changed, 67 insertions(+), 56 deletions(-) diff --git a/src/Smart_car/obstacle_avoidance.py b/src/Smart_car/obstacle_avoidance.py index 9fb55b685a..bdcb85ac89 100644 --- a/src/Smart_car/obstacle_avoidance.py +++ b/src/Smart_car/obstacle_avoidance.py @@ -13,53 +13,58 @@ # ======================== 枚举定义 ======================== class CollisionRiskLevel(Enum): - """碰撞风险等级""" - NONE = 0 # 无风险 - LOW = 1 # 低风险（预警） - MEDIUM = 2 # 中风险（减速） - HIGH = 3 # 高风险（紧急制动） + """碰撞风险等级枚举：用于标识当前与前方障碍物的碰撞危险程度""" + NONE = 0 # 无风险：障碍物距离较远或相对速度低，无需任何干预 + LOW = 1 # 低风险（预警）：存在潜在碰撞隐患，需提醒驾驶员注意 + MEDIUM = 2 # 中风险（减速）：碰撞概率上升，需车辆自动减速降低风险 + HIGH = 3 # 高风险（紧急制动）：碰撞即将发生，需全力制动避免事故 class ControlCommand(Enum): - """车辆控制指令""" - NORMAL = 0 # 正常行驶 - WARNING = 1 # 预警（声光提示） - DECELERATE = 2 # 减速 - EMERGENCY_STOP = 3 # 紧急制动 + """车辆控制指令枚举：根据碰撞风险等级对应生成的车辆执行指令""" + NORMAL = 0 # 正常行驶：车辆保持当前行驶状态，无需主动调整 + WARNING = 1 # 预警（声光提示）：仅触发报警装置，提醒驾驶员接管关注 + DECELERATE = 2 # 减速：车辆自动执行中等强度制动，降低行驶速度 + EMERGENCY_STOP = 3 # 紧急制动：车辆以最大减速度制动，尽可能避免碰撞 # ======================== 核心类实现 ======================== class Obstacle: - """障碍物类：模拟感知到的障碍物信息""" + """障碍物类：用于封装感知模块检测到的前方障碍物相关信息""" def __init__(self, distance: float, relative_speed: float, obstacle_type: str): """ - :param distance: 障碍物距离（米），正值表示前方 - :param relative_speed: 相对速度（m/s），正值表示靠近 - :param obstacle_type: 障碍物类型（行人/车辆/障碍物） + 障碍物对象初始化 + :param distance: 障碍物距离（米），正值表示在本车前方 + :param relative_speed: 相对速度（m/s），正值表示本车与障碍物正在相互靠近 + :param obstacle_type: 障碍物类型（行人/车辆/固定障碍物等） """ - self.distance = max(0.0, distance) # 距离非负 + self.distance = max(0.0, distance) # 距离非负：避免感知数据异常导致的无效负数距离 self.relative_speed = relative_speed self.obstacle_type = obstacle_type - self.update_time = time.time() # 感知数据更新时间 + self.update_time = time.time() # 感知数据更新时间戳：用于判断数据是否失效 def update(self, distance: float, relative_speed: float): - """更新障碍物感知数据""" + """ + 更新障碍物感知数据：感知模块周期性刷新数据时调用 + :param distance: 最新检测到的障碍物距离（米） + :param relative_speed: 最新检测到的本车与障碍物相对速度（m/s） + """ self.distance = max(0.0, distance) self.relative_speed = relative_speed self.update_time = time.time() class CollisionPreventionSystem: - """碰撞预防系统核心类""" + """碰撞预防系统核心类：整合感知、风险评估、指令生成与控制执行的全流程""" def __init__(self): - self.current_speed = 0.0 # 车辆当前速度（m/s） - self.obstacle = None # 感知到的前方障碍物 - self.risk_level = CollisionRiskLevel.NONE - self.control_command = ControlCommand.NORMAL + self.current_speed = 0.0 # 车辆当前行驶速度（m/s） + self.obstacle = None # 感知到的前方障碍物对象，初始为None表示未检测到障碍物 + self.risk_level = CollisionRiskLevel.NONE # 当前碰撞风险等级，初始为无风险 + self.control_command = ControlCommand.NORMAL # 当前车辆控制指令，初始为正常行驶 def perception_update(self, obstacle_distance: float, obstacle_relative_speed: float, obstacle_type: str): """ - 更新感知模块数据 + 更新感知模块数据：同步最新检测到的障碍物信息到系统中 :param obstacle_distance: 障碍物距离（米） :param obstacle_relative_speed: 相对速度（m/s） - :param obstacle_type: 障碍物类型 + :param obstacle_type: 障碍物类型（行人/车辆/固定障碍物等） """ if self.obstacle is None: self.obstacle = Obstacle(obstacle_distance, obstacle_relative_speed, obstacle_type) @@ -68,15 +73,18 @@ def perception_update(self, obstacle_distance: float, obstacle_relative_speed: f def calculate_ttc(self) -> float: """ - 计算碰撞时间（Time To Collision, TTC） - :return: TTC值（秒），无穷大表示无碰撞风险 + 计算碰撞时间（Time To Collision, TTC）：预测本车与障碍物发生碰撞的剩余时间 + :return: TTC值（秒），无穷大（float('inf')）表示无碰撞风险（无障碍物或障碍物远离） """ if self.obstacle is None or self.obstacle.relative_speed <= 0: - return float('inf') # 相对速度≤0，无碰撞风险 - return self.obstacle.distance / self.obstacle.relative_speed + return float('inf') # 相对速度≤0：障碍物与本车相互远离或静止，无碰撞风险 + return self.obstacle.distance / self.obstacle.relative_speed # TTC核心计算公式 def evaluate_risk(self): - """评估碰撞风险等级""" + """ + 评估碰撞风险等级：基于TTC值和障碍物距离双指标，综合判定碰撞危险程度 + 判定逻辑兼顾时间维度（TTC）和空间维度（距离），提升风险判断准确性 + """ ttc = self.calculate_ttc() distance = self.obstacle.distance if self.obstacle else float('inf') @@ -89,7 +97,10 @@ def evaluate_risk(self): self.risk_level = CollisionRiskLevel.HIGH def generate_control_command(self) -> ControlCommand: - """根据风险等级生成控制指令""" + """ + 根据风险等级生成控制指令：建立风险等级与车辆控制动作的一一对应关系 + :return: 对应的车辆控制指令（ControlCommand枚举类型） + """ if self.risk_level == CollisionRiskLevel.NONE: self.control_command = ControlCommand.NORMAL elif self.risk_level == CollisionRiskLevel.LOW: @@ -102,57 +113,57 @@ def generate_control_command(self) -> ControlCommand: def execute_control(self, command: ControlCommand) -> float: """ - 执行车辆控制指令，返回控制后的车速 - :param command: 控制指令 - :return: 调整后的车速（m/s） + 执行车辆控制指令，根据指令调整车辆车速，并返回控制后的最新车速 + :param command: 待执行的车辆控制指令（ControlCommand枚举类型） + :return: 调整后的车辆当前车速（m/s） """ - delta_time = 0.1 # 控制周期（秒），模拟实时控制 + delta_time = 0.1 # 控制周期（秒），模拟车载系统实时控制的100ms刷新间隔 if command == ControlCommand.NORMAL: - # 正常行驶，维持当前速度（可扩展加速逻辑） + # 正常行驶，维持当前速度（可扩展后续加速逻辑） pass elif command == ControlCommand.WARNING: - # 仅预警，不调整车速（声光提示驾驶员） + # 仅预警，不调整车速（通过声光设备提示驾驶员注意前方障碍物） print("[预警] 检测到前方障碍物，请注意！") elif command == ControlCommand.DECELERATE: - # 减速：中等减速度（最大减速度的50%） + # 减速：采用中等减速度（最大减速度的50%），避免急刹影响驾乘体验 deceleration = MAX_DECELERATION * 0.5 self.current_speed = max(0.0, self.current_speed - deceleration * delta_time) print(f"[减速] 当前车速：{self.current_speed:.2f} m/s（原速度：{self.current_speed + deceleration * delta_time:.2f} m/s）") elif command == ControlCommand.EMERGENCY_STOP: - # 紧急制动：最大减速度 + # 紧急制动：采用最大减速度，尽可能在碰撞前将车辆停稳 deceleration = MAX_DECELERATION self.current_speed = max(0.0, self.current_speed - deceleration * delta_time) print(f"[紧急制动] 当前车速：{self.current_speed:.2f} m/s（紧急制动中）") - # 限制车速不超过最大值 + # 限制车速不超过最大值，确保行驶安全合规 self.current_speed = min(self.current_speed, VEHICLE_MAX_SPEED) return self.current_speed def run_cycle(self, obstacle_distance: float, obstacle_relative_speed: float, obstacle_type: str, current_speed: float): """ - 碰撞预防系统单次运行周期 + 碰撞预防系统单次运行周期：完整执行“感知更新-风险评估-指令生成-控制执行”流程 :param obstacle_distance: 障碍物距离（米） :param obstacle_relative_speed: 相对速度（m/s） - :param obstacle_type: 障碍物类型 - :param current_speed: 车辆当前速度（m/s） + :param obstacle_type: 障碍物类型（行人/车辆/固定障碍物等） + :param current_speed: 车辆当前行驶速度（m/s） """ - # 1. 更新车辆当前速度 + # 1. 更新车辆当前速度：同步本车最新行驶状态 self.current_speed = current_speed - # 2. 更新感知数据 + # 2. 更新感知数据：同步前方障碍物的最新检测信息 self.perception_update(obstacle_distance, obstacle_relative_speed, obstacle_type) - # 3. 风险评估 + # 3. 风险评估：基于最新感知数据判定碰撞风险等级 self.evaluate_risk() - # 4. 生成控制指令 + # 4. 生成控制指令：根据风险等级匹配对应的车辆控制动作 command = self.generate_control_command() - # 5. 执行控制 + # 5. 执行控制：执行控制指令并调整车辆车速 new_speed = self.execute_control(command) - # 6. 输出状态信息 + # 6. 输出状态信息：打印系统当前各项关键参数，便于调试和监控 print(f"\n=== 系统状态 ===") print(f"障碍物类型：{obstacle_type}") print(f"障碍物距离：{self.obstacle.distance:.2f} 米") @@ -164,22 +175,22 @@ def run_cycle(self, obstacle_distance: float, obstacle_relative_speed: float, ob # ======================== 测试用例 ======================== if __name__ == "__main__": - # 初始化碰撞预防系统 + # 初始化碰撞预防系统实例：创建系统核心对象 cps = CollisionPreventionSystem() - # 模拟不同场景的运行周期 + # 模拟不同场景的运行周期：覆盖无风险、低风险、中风险、高风险四种典型行驶场景 test_scenarios = [ - # 场景1：无风险（远距离、低相对速度） + # 场景1：无风险（远距离、低相对速度，无需任何干预） {"distance": 10.0, "relative_speed": 1.0, "type": "车辆", "speed": 15.0}, - # 场景2：低风险（预警） + # 场景2：低风险（预警）（距离接近安全阈值、相对速度适中，需提醒驾驶员） {"distance": 6.0, "relative_speed": 3.0, "type": "行人", "speed": 10.0}, - # 场景3：中风险（减速） + # 场景3：中风险（减速）（距离接近紧急阈值、相对速度较高，需自动减速） {"distance": 3.0, "relative_speed": 4.0, "type": "障碍物", "speed": 8.0}, - # 场景4：高风险（紧急制动） + # 场景4：高风险（紧急制动）（距离低于紧急阈值、相对速度快，需全力制动） {"distance": 1.5, "relative_speed": 5.0, "type": "车辆", "speed": 6.0}, ] - # 运行测试场景 + # 运行测试场景：依次执行每个测试用例，模拟实际行驶中的系统循环运行 for i, scenario in enumerate(test_scenarios): print(f"\n==================== 测试场景 {i+1} ====================") cps.run_cycle( @@ -188,4 +199,4 @@ def run_cycle(self, obstacle_distance: float, obstacle_relative_speed: float, ob obstacle_type=scenario["type"], current_speed=scenario["speed"] ) - time.sleep(0.5) # 模拟时间间隔 \ No newline at end of file + time.sleep(0.5) # 模拟时间间隔：模拟不同场景之间的时间流逝，更贴近实际运行场景 \ No newline at end of file From 41945ad97abfdc6fbfb8378d1388d6959e04b2fa Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sat, 20 Dec 2025 20:57:09 +0800 Subject: [PATCH 14/33] 1 --- src/Smart_car/overload.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py index add2d37219..1018554ae2 100644 --- a/src/Smart_car/overload.py +++ b/src/Smart_car/overload.py @@ -60,7 +60,7 @@ def run(self, monitor_times=10): self.display_warning(status, color, desc) # 4. 严重超载时紧急停止 if self.warning_level == 3: - print("❗❗❗ 检测到严重超载，系统紧急停止运行！ ❗❗❗") + print("❗❗❗ 检测到严重超载，系统紧急停止运行！ ❗❗") break # 5. 间隔2秒进行下一次监测 time.sleep(2) From f7e911aa7419a736c138c4159278646e9f9b426d Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sun, 21 Dec 2025 10:38:10 +0800 Subject: [PATCH 15/33] 1 --- src/Smart_car/path.py | 157 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 src/Smart_car/path.py diff --git a/src/Smart_car/path.py b/src/Smart_car/path.py new file mode 100644 index 0000000000..55d607d711 --- /dev/null +++ b/src/Smart_car/path.py @@ -0,0 +1,157 @@ +import pygame +import sys +import math + +# 初始化pygame +pygame.init() + +# 窗口配置 +WINDOW_WIDTH = 800 +WINDOW_HEIGHT = 600 +screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT)) +pygame.display.set_caption("无人车键盘控制") + +# 颜色定义 +WHITE = (255, 255, 255) +BLACK = (0, 0, 0) +RED = (255, 0, 0) +GREEN = (0, 255, 0) +BLUE = (0, 0, 255) +GRAY = (200, 200, 200) + +# 无人车参数 +CAR_WIDTH = 40 +CAR_HEIGHT = 60 +car_x = WINDOW_WIDTH // 2 # 初始x坐标（窗口中心） +car_y = WINDOW_HEIGHT // 2 # 初始y坐标（窗口中心） +car_angle = 0 # 初始角度（0度为向上） +car_speed = 5 # 移动速度 +car_color = RED # 车辆颜色 + +# 字体初始化（显示控制提示和车辆状态） +font = pygame.font.SysFont("SimHei", 20) # 支持中文显示 +font_large = pygame.font.SysFont("SimHei", 24) + + +def draw_car(x, y, angle): + """绘制带方向的无人车（三角形+矩形，直观显示朝向）""" + # 保存当前坐标系 + pygame.draw.rect(screen, GRAY, (0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)) + # 绘制道路网格（增强场景感） + for i in range(0, WINDOW_WIDTH, 50): + pygame.draw.line(screen, WHITE, (i, 0), (i, WINDOW_HEIGHT), 1) + for j in range(0, WINDOW_HEIGHT, 50): + pygame.draw.line(screen, WHITE, (0, j), (WINDOW_WIDTH, j), 1) + + # 平移+旋转坐标系，实现车辆朝向控制 + rotated_car = pygame.Surface((CAR_WIDTH, CAR_HEIGHT), pygame.SRCALPHA) + # 绘制车辆主体（矩形） + pygame.draw.rect(rotated_car, car_color, (0, 0, CAR_WIDTH, CAR_HEIGHT)) + # 绘制车辆头部（三角形，标识前进方向） + pygame.draw.polygon(rotated_car, BLACK, [ + (CAR_WIDTH // 2, 0), + (0, CAR_HEIGHT // 2), + (CAR_WIDTH, CAR_HEIGHT // 2) + ]) + # 旋转车辆 + rotated_car = pygame.transform.rotate(rotated_car, -angle) + # 获取旋转后的矩形区域（用于居中绘制） + car_rect = rotated_car.get_rect(center=(x, y)) + # 绘制车辆到窗口 + screen.blit(rotated_car, car_rect) + + +def display_info(direction): + """显示控制提示和车辆当前状态""" + # 控制提示文本 + tip_text1 = "键盘控制说明：" + tip_text2 = "W-前进 S-后退 A-左转 D-右转" + tip_text3 = "空格-停止 Q-退出程序" + # 车辆状态文本 + status_text = f"当前状态：{direction} | 位置：({int(car_x)}, {int(car_y)}) | 朝向角度：{int(car_angle)}°" + + # 绘制文本（抗锯齿） + text1 = font.render(tip_text1, True, BLACK) + text2 = font.render(tip_text2, True, BLACK) + text3 = font.render(tip_text3, True, BLACK) + status_text_surf = font_large.render(status_text, True, BLUE) + + # 显示文本位置 + screen.blit(text1, (10, 10)) + screen.blit(text2, (10, 40)) + screen.blit(text3, (10, 70)) + screen.blit(status_text_surf, (10, 100)) + + +def update_car_position(key_pressed): + """根据键盘输入更新车辆位置和角度""" + global car_x, car_y, car_angle + direction = "停止" + + # 角度控制（左转/右转，每次调整5度） + if key_pressed[pygame.K_a]: # A键左转 + car_angle += 5 + direction = "左转" + if key_pressed[pygame.K_d]: # D键右转 + car_angle -= 5 + direction = "右转" + + # 位置控制（前进/后退，基于当前角度计算位移） + radian = math.radians(car_angle) # 角度转弧度 + if key_pressed[pygame.K_w]: # W键前进 + car_x += car_speed * math.sin(radian) + car_y -= car_speed * math.cos(radian) + direction = "前进" + if key_pressed[pygame.K_s]: # S键后退 + car_x -= car_speed * math.sin(radian) + car_y += car_speed * math.cos(radian) + direction = "后退" + + # 边界检测（防止车辆驶出窗口） + car_x = max(CAR_WIDTH // 2, min(WINDOW_WIDTH - CAR_WIDTH // 2, car_x)) + car_y = max(CAR_HEIGHT // 2, min(WINDOW_HEIGHT - CAR_HEIGHT // 2, car_y)) + + return direction + + +def main(): + """主函数：运行仿真系统""" + clock = pygame.time.Clock() # 控制帧率 + running = True + + while running: + # 帧率控制（60帧/秒） + clock.tick(60) + + # 事件监听 + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: # Q键退出 + running = False + if event.key == pygame.K_SPACE: # 空格停止（重置角度无变化，位置不变） + pass + + # 获取键盘按键状态 + key_pressed = pygame.key.get_pressed() + + # 更新车辆位置和方向 + current_direction = update_car_position(key_pressed) + + # 绘制场景和车辆 + draw_car(car_x, car_y, car_angle) + + # 显示信息 + display_info(current_direction) + + # 更新窗口显示 + pygame.display.flip() + + # 退出程序 + pygame.quit() + sys.exit() + + +if __name__ == "__main__": + main() \ No newline at end of file From 77a3c3f07aaa358acf533514e6f8ddc1846a94bf Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sun, 21 Dec 2025 11:52:17 +0800 Subject: [PATCH 16/33] 1 --- src/Smart_car/path.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/path.py b/src/Smart_car/path.py index 55d607d711..14de9a79d4 100644 --- a/src/Smart_car/path.py +++ b/src/Smart_car/path.py @@ -9,7 +9,7 @@ WINDOW_WIDTH = 800 WINDOW_HEIGHT = 600 screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT)) -pygame.display.set_caption("无人车键盘控制") +pygame.display.set_caption("无人车键盘控制.") # 颜色定义 WHITE = (255, 255, 255) From 5320b97c7335bfd44639a9f39f25f3a890837da8 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sun, 21 Dec 2025 15:09:16 +0800 Subject: [PATCH 17/33] 1 --- src/Smart_car/traffic.py | 156 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 156 insertions(+) create mode 100644 src/Smart_car/traffic.py diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py new file mode 100644 index 0000000000..493048d0e8 --- /dev/null +++ b/src/Smart_car/traffic.py @@ -0,0 +1,156 @@ +import cv2 +import numpy as np +import os +import time + + +def traffic_light_real_time_detection(): + """ + 摄像头实时交通信号灯三色识别函数 + """ + # 1. 初始化摄像头（0为默认内置摄像头，1为外接摄像头，可根据实际调整） + cap = cv2.VideoCapture(0) + if not cap.isOpened(): + print("错误：无法打开摄像头，请检查摄像头是否正常连接或被其他程序占用") + return "摄像头初始化失败" + + # 设置摄像头分辨率（提升识别效率，可根据摄像头性能调整） + cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) + cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) + + # 创建保存目录（用于保存抓拍结果） + save_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "real_time_detection_results") + if not os.path.exists(save_dir): + os.makedirs(save_dir) + + # 2. 定义红、黄、绿三种颜色的HSV阈值范围（优化后更适配实时场景） + # 红色（两个区间，覆盖HSV红色色域） + red_lower1 = np.array([0, 100, 80]) + red_upper1 = np.array([10, 255, 255]) + red_lower2 = np.array([160, 100, 80]) + red_upper2 = np.array([180, 255, 255]) + + # 黄色 + yellow_lower = np.array([15, 120, 80]) + yellow_upper = np.array([35, 255, 255]) + + # 绿色 + green_lower = np.array([40, 80, 80]) + green_upper = np.array([80, 255, 255]) + + # 形态学操作核 + kernel = np.ones((3, 3), np.uint8) + # 轮廓检测参数 + contour_params = (cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + # 自适应最小面积（基于摄像头分辨率） + min_area = (640 * 480) / 1000 + + print("摄像头已启动，实时交通信号灯检测中...") + print("操作提示：") + print(" 1. 按下 's' 键保存当前检测结果图像") + print(" 2. 按下 'ESC' 键退出程序") + + def filter_valid_contours(contours, min_area_val): + """筛选有效轮廓（面积+圆度，适配信号灯圆形特征）""" + valid = [] + for cnt in contours: + area = cv2.contourArea(cnt) + if area < min_area_val: + continue + perimeter = cv2.arcLength(cnt, True) + if perimeter == 0: + continue + circularity = (4 * np.pi * area) / (perimeter ** 2) + if circularity > 0.6: # 圆度筛选，排除非圆形噪声 + valid.append(cnt) + return valid + + while True: + # 3. 读取摄像头帧 + ret, frame = cap.read() + if not ret: + print("警告：无法读取摄像头帧，可能是摄像头断开连接") + break + + # 复制帧用于绘制结果 + frame_result = frame.copy() + # 转换为HSV色彩空间（抗光照干扰） + hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) + + # 4. 颜色掩码生成 + red_mask = cv2.inRange(hsv, red_lower1, red_upper1) | cv2.inRange(hsv, red_lower2, red_upper2) + yellow_mask = cv2.inRange(hsv, yellow_lower, yellow_upper) + green_mask = cv2.inRange(hsv, green_lower, green_upper) + + # 5. 形态学操作优化掩码 + red_mask = cv2.morphologyEx(red_mask, cv2.MORPH_OPEN, kernel, iterations=1) + red_mask = cv2.morphologyEx(red_mask, cv2.MORPH_CLOSE, kernel, iterations=2) + yellow_mask = cv2.morphologyEx(yellow_mask, cv2.MORPH_OPEN, kernel, iterations=1) + yellow_mask = cv2.morphologyEx(yellow_mask, cv2.MORPH_CLOSE, kernel, iterations=2) + green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_OPEN, kernel, iterations=1) + green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_CLOSE, kernel, iterations=2) + + # 6. 轮廓检测与筛选 + red_contours, _ = cv2.findContours(red_mask, *contour_params) + yellow_contours, _ = cv2.findContours(yellow_mask, *contour_params) + green_contours, _ = cv2.findContours(green_mask, *contour_params) + + red_valid = filter_valid_contours(red_contours, min_area) + yellow_valid = filter_valid_contours(yellow_contours, min_area) + green_valid = filter_valid_contours(green_contours, min_area) + + # 7. 信号灯判断与可视化绘制 + light_color = "未检测到信号灯" + color_configs = [ + (red_valid, "红色信号灯", "Red", (0, 0, 255)), + (yellow_valid, "黄色信号灯", "Yellow", (0, 255, 255)), + (green_valid, "绿色信号灯", "Green", (0, 255, 0)) + ] + + for valid_contours, color_name, label, bgr_color in color_configs: + if len(valid_contours) > 0: + light_color = color_name + # 绘制轮廓和最小外接圆 + cv2.drawContours(frame_result, valid_contours, -1, bgr_color, 2) + for cnt in valid_contours: + (x, y), radius = cv2.minEnclosingCircle(cnt) + center = (int(x), int(y)) + radius = int(radius) + cv2.circle(frame_result, center, radius, bgr_color, 2) + # 绘制文字标签（避免超出图像边界） + text_y = int(y - radius - 10) if (y - radius - 10) > 10 else int(y + radius + 20) + cv2.putText(frame_result, label, (int(x) - 20, text_y), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, bgr_color, 2) + break # 通常仅一种信号灯点亮，找到后退出循环 + + # 8. 在帧上添加信息提示 + cv2.putText(frame_result, f"Status: {light_color}", (10, 30), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2) + cv2.putText(frame_result, "Press 's' to save, 'ESC' to exit", (10, 60), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + + # 9. 显示实时结果 + cv2.namedWindow("Real-Time Traffic Light Detection", cv2.WINDOW_NORMAL) + cv2.resizeWindow("Real-Time Traffic Light Detection", 640, 480) + cv2.imshow("Real-Time Traffic Light Detection", frame_result) + + # 10. 按键事件处理 + key = cv2.waitKey(1) & 0xFF + if key == 27: # ESC键退出 + print("程序已退出") + break + elif key == ord('s'): # 's'键保存结果 + timestamp = time.strftime("%Y%m%d_%H%M%S", time.localtime()) + save_path = os.path.join(save_dir, f"real_time_result_{timestamp}.jpg") + cv2.imwrite(save_path, frame_result) + print(f"当前检测结果已保存：{save_path}") + + # 释放资源 + cap.release() + cv2.destroyAllWindows() + return "实时检测结束" + + +# 主函数调用 +if __name__ == "__main__": + traffic_light_real_time_detection() \ No newline at end of file From 2744d954a0d373ea8536199a8d94f064ce959552 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sun, 21 Dec 2025 20:45:13 +0800 Subject: [PATCH 18/33] 1 --- src/Smart_car/traffic.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index 493048d0e8..f4aaada99a 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -22,9 +22,6 @@ def traffic_light_real_time_detection(): save_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "real_time_detection_results") if not os.path.exists(save_dir): os.makedirs(save_dir) - - # 2. 定义红、黄、绿三种颜色的HSV阈值范围（优化后更适配实时场景） - # 红色（两个区间，覆盖HSV红色色域） red_lower1 = np.array([0, 100, 80]) red_upper1 = np.array([10, 255, 255]) red_lower2 = np.array([160, 100, 80]) From d2f27aab9505ccd4d34d1dd089ad2b7b7b1f628c Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Sun, 21 Dec 2025 20:48:39 +0800 Subject: [PATCH 19/33] 1 --- src/Smart_car/traffic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index f4aaada99a..2ec352cb61 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -11,7 +11,7 @@ def traffic_light_real_time_detection(): # 1. 初始化摄像头（0为默认内置摄像头，1为外接摄像头，可根据实际调整） cap = cv2.VideoCapture(0) if not cap.isOpened(): - print("错误：无法打开摄像头，请检查摄像头是否正常连接或被其他程序占用") + print("错误：无法打开摄像头，请检查摄像头是否正常连接或被其他程序占用.") return "摄像头初始化失败" # 设置摄像头分辨率（提升识别效率，可根据摄像头性能调整） From 97b55726377c8818ca82f58d93d0a3d5e40f1366 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Mon, 22 Dec 2025 09:09:09 +0800 Subject: [PATCH 20/33] 1 --- src/Smart_car/traffic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index 2ec352cb61..49ab35aa92 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -12,7 +12,7 @@ def traffic_light_real_time_detection(): cap = cv2.VideoCapture(0) if not cap.isOpened(): print("错误：无法打开摄像头，请检查摄像头是否正常连接或被其他程序占用.") - return "摄像头初始化失败" + return "摄像头初始化失败." # 设置摄像头分辨率（提升识别效率，可根据摄像头性能调整） cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) From 7479387aaad45a20de36952dc4f210c113a55fdd Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Mon, 22 Dec 2025 10:51:16 +0800 Subject: [PATCH 21/33] 1 --- src/Smart_car/overload.py | 67 ++++++++++++++++++++++++++------------- 1 file changed, 45 insertions(+), 22 deletions(-) diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py index 1018554ae2..74076f98a4 100644 --- a/src/Smart_car/overload.py +++ b/src/Smart_car/overload.py @@ -2,39 +2,57 @@ import random class UnmannedVehicleOverloadWarningSystem: - """无人车超载预警系统""" + """无人车超载预警系统 + 功能：实时监测无人车载重状态，根据载重占比划分预警等级，输出可视化预警信息，严重超载时紧急停止系统 + """ def __init__(self, max_load=1000): - # 初始化系统参数 - self.max_load = max_load # 车辆最大载重（单位：kg，可自定义） - self.current_load = 0 # 当前载重 + # 初始化系统核心参数 + self.max_load = max_load # 车辆最大载重（单位：kg，可根据实际车型自定义配置） + self.current_load = 0 # 当前实时载重，初始值为0 self.warning_level = 0 # 预警等级：0-正常，1-轻度过载，2-中度过载，3-严重超载 def simulate_weight_collection(self): - """模拟无人车重量采集（模拟传感器数据，可替换为真实硬件接口）""" - # 模拟载重变化：每次在当前基础上小幅波动（模拟乘客/货物上下车） + """模拟无人车重量采集（模拟传感器数据，可替换为真实硬件接口） + 逻辑：在当前载重基础上随机小幅波动，模拟乘客上下车或货物装卸的载重变化 + 返回：更新后的当前载重值 + """ + # 模拟载重变化：每次波动范围为-50kg（卸载）到100kg（加载） weight_change = random.randint(-50, 100) - self.current_load = max(0, self.current_load + weight_change) # 载重不能为负数 + # 更新当前载重，确保载重不会为负数（最低为0） + self.current_load = max(0, self.current_load + weight_change) return self.current_load def judge_overload(self): - """超载判断逻辑，划分预警等级""" - load_ratio = self.current_load / self.max_load # 载重占比 + """超载判断逻辑，根据载重占比划分预警等级 + 计算规则：载重占比 = 当前载重 / 最大载重 + 返回值：(预警状态名称, 预警颜色标识, 处理建议描述) + """ + load_ratio = self.current_load / self.max_load # 计算载重占比，用于等级判定 + # 正常状态：载重≤80%最大载重，无需干预 if load_ratio <= 0.8: - self.warning_level = 0 # 正常：载重≤80%最大载重 + self.warning_level = 0 return "正常", "绿色", "当前载重未超出安全范围，无需处理" + # 轻度过载预警：80%<载重≤95%，接近上限需停止加载 elif 0.8 < load_ratio <= 0.95: - self.warning_level = 1 # 轻度过载：80%<载重≤95% + self.warning_level = 1 return "轻度过载预警", "黄色", "当前载重接近上限，建议停止加载" + # 中度过载警告：95%<载重≤110%，超出上限需卸载并停止运行 elif 0.95 < load_ratio <= 1.1: - self.warning_level = 2 # 中度过载：95%<载重≤110% + self.warning_level = 2 return "中度过载警告", "橙色", "当前载重已超出安全上限，立即停止运行并卸载部分货物" + # 严重超载警报：载重>110%，极度危险需紧急制动并联系工作人员 else: - self.warning_level = 3 # 严重超载：载重>110% + self.warning_level = 3 return "严重超载警报", "红色", "极度危险！立即紧急制动，联系工作人员处理" def display_warning(self, status, color, desc): - """可视化输出预警信息（模拟车载终端显示）""" + """可视化输出预警信息（模拟车载终端显示界面） + 参数： + status: 预警状态名称（如"正常"、"严重超载警报"） + color: 预警颜色标识（如"绿色"、"红色"） + desc: 具体处理建议描述 + """ print("=" * 50) print(f"【无人车超载预警系统 - 实时监测】") print(f"当前时间：{time.strftime('%Y-%m-%d %H:%M:%S')}") @@ -47,26 +65,31 @@ def display_warning(self, status, color, desc): print() def run(self, monitor_times=10): - """运行系统，持续监测载重并输出预警""" + """运行系统，持续循环监测载重并输出预警信息 + 参数： + monitor_times: 预设监测次数，默认10次，可根据需求修改 + 流程：采集载重→判断等级→显示预警→异常停止（严重超载）→间隔等待 + """ print("无人车超载预警系统已启动...") print(f"开始持续监测（共监测{monitor_times}次，每次间隔2秒）\n") + # 循环执行监测流程，达到预设次数或检测到严重超载时终止 for i in range(monitor_times): - # 1. 采集当前载重（模拟） + # 1. 采集当前载重（模拟传感器数据更新） self.simulate_weight_collection() - # 2. 判断超载等级 + # 2. 判断超载等级，获取预警相关信息 status, color, desc = self.judge_overload() - # 3. 显示预警信息 + # 3. 可视化输出预警详情（模拟车载终端展示） self.display_warning(status, color, desc) - # 4. 严重超载时紧急停止 + # 4. 严重超载（等级3）时，紧急停止系统运行 if self.warning_level == 3: print("❗❗❗ 检测到严重超载，系统紧急停止运行！ ❗❗") break - # 5. 间隔2秒进行下一次监测 + # 5. 间隔2秒进行下一次监测，模拟实时周期性检测 time.sleep(2) if __name__ == "__main__": - # 初始化系统：设置无人车最大载重为1000kg（可根据需求修改） + # 初始化系统：设置无人车最大载重为1000kg（可根据车型/场景需求修改该参数） overload_system = UnmannedVehicleOverloadWarningSystem(max_load=1000) - # 运行系统，持续监测10次（可修改监测次数） + # 运行系统，持续监测10次（可修改monitor_times参数调整监测次数） overload_system.run(monitor_times=10) \ No newline at end of file From d533151f0f69982c6ef2a2ee65e145b557b52c0a Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Mon, 22 Dec 2025 17:10:51 +0800 Subject: [PATCH 22/33] 1 --- src/Smart_car/overload.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py index 74076f98a4..de69aad9c0 100644 --- a/src/Smart_car/overload.py +++ b/src/Smart_car/overload.py @@ -72,7 +72,6 @@ def run(self, monitor_times=10): """ print("无人车超载预警系统已启动...") print(f"开始持续监测（共监测{monitor_times}次，每次间隔2秒）\n") - # 循环执行监测流程，达到预设次数或检测到严重超载时终止 for i in range(monitor_times): # 1. 采集当前载重（模拟传感器数据更新） From 3f5bc11138c0cf3113d236550d1f8e9c0e831b8b Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Mon, 22 Dec 2025 17:12:15 +0800 Subject: [PATCH 23/33] 1 --- src/Smart_car/overload.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py index de69aad9c0..f53fdf0dc0 100644 --- a/src/Smart_car/overload.py +++ b/src/Smart_car/overload.py @@ -82,7 +82,7 @@ def run(self, monitor_times=10): self.display_warning(status, color, desc) # 4. 严重超载（等级3）时，紧急停止系统运行 if self.warning_level == 3: - print("❗❗❗ 检测到严重超载，系统紧急停止运行！ ❗❗") + print("❗❗❗ 检测到严重超载，系统紧急停止运行！❗") break # 5. 间隔2秒进行下一次监测，模拟实时周期性检测 time.sleep(2) From a58199517fa344c659c1b2bb5c78585d15e630be Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Mon, 22 Dec 2025 21:08:05 +0800 Subject: [PATCH 24/33] 1 --- ...utonomous_vehicle_battery_level_display.py | 106 ++++++++++++------ 1 file changed, 70 insertions(+), 36 deletions(-) diff --git a/src/Smart_car/autonomous_vehicle_battery_level_display.py b/src/Smart_car/autonomous_vehicle_battery_level_display.py index 40b6b6f8f5..9cb9dba2a2 100644 --- a/src/Smart_car/autonomous_vehicle_battery_level_display.py +++ b/src/Smart_car/autonomous_vehicle_battery_level_display.py @@ -1,40 +1,58 @@ import time -import random # 仅用于模拟硬件数据，实际场景删除 +import random # 仅用于模拟硬件采集的电池电压数据，实际项目部署时请删除该模块及相关模拟代码 class UnmannedVehicleBattery: - """无人车电池电量管理类""" + """无人车电池电量管理核心类 + 负责电池电压读取、剩余电量计算、状态判断及可视化展示， + 支持对接实际硬件采集模块，可根据电池规格灵活配置参数。 + """ def __init__(self): - # 电池参数配置（根据实际电池规格调整） - self.max_voltage = 12.6 # 满电电压（12V锂电池为例） - self.min_voltage = 10.0 # 欠压保护电压 - self.current_voltage = 0.0 # 当前电压 - self.battery_percent = 0.0 # 剩余电量百分比 + # 电池核心参数配置（可根据实际使用的电池型号/规格调整对应数值） + self.max_voltage = 12.6 # 电池满电电压（以12V三元锂电池为例） + self.min_voltage = 10.0 # 电池欠压保护电压，低于此值需立即停止使用并充电 + self.current_voltage = 0.0 # 电池实时电压（初始值为0，通过硬件采集或模拟更新） + self.battery_percent = 0.0 # 电池剩余电量百分比（保留1位小数） def read_battery_voltage(self): + """读取电池实时电压（模拟硬件采集逻辑） + 实际应用场景中，需替换为对应硬件的数据采集方式： + 1. 树莓派/单片机：通过ADC模块（如ADS1115）采集电压信号 + 2. 带BMS的电池：通过串口/RS485/I2C通信获取BMS上报的电压数据 + 3. 其他硬件：根据对应通信协议调整数据读取逻辑 """ - 读取电池电压（模拟硬件采集） - 实际场景：替换为ADC读取/串口接收BMS数据/I2C通信等 - """ - # 模拟电压波动（范围：10.0~12.6V） + # 模拟电压小幅波动（范围：欠压保护电压~满电电压，保留2位小数） self.current_voltage = round(random.uniform(10.0, 12.6), 2) - # 实际硬件示例（以树莓派ADC为例）： + + # 实际硬件采集示例（以树莓派+ADS1115 ADC模块为例，需安装对应依赖库） + # 依赖库安装：pip install adafruit-circuitpython-ads1x15 + # import board # import adafruit_ads1x15.ads1115 as ADS # from adafruit_ads1x15.analog_in import AnalogIn - # i2c = board.I2C() + # + # # 初始化I2C总线和ADS1115模块 + # i2c = board.I2C() # 默认使用SDA/SCL引脚 # ads = ADS.ADS1115(i2c) - # chan = AnalogIn(ads, ADS.P0) - # self.current_voltage = chan.voltage * voltage_divider_ratio # 电压分压比 + # chan = AnalogIn(ads, ADS.P0) # 选择A0通道作为电压采集通道 + # + # # 计算实际电池电压（需根据分压电路配置对应的电压分压比） + # voltage_divider_ratio = 2.0 # 分压比示例，需根据实际电路调整 + # self.current_voltage = chan.voltage * voltage_divider_ratio def calculate_battery_percent(self): - """计算剩余电量百分比""" + """根据实时电压计算电池剩余电量百分比 + 采用线性计算模型（适用于电压与电量近似线性的电池类型）， + 实际场景中可根据电池放电曲线优化为非线性计算模型，提升精度。 + """ if self.current_voltage >= self.max_voltage: + # 电压达到满电电压，判定为100%电量 self.battery_percent = 100.0 elif self.current_voltage <= self.min_voltage: + # 电压低于欠压保护值，判定为0%电量（需立即充电） self.battery_percent = 0.0 else: - # 线性计算（实际可根据电池放电曲线优化） + # 线性插值计算剩余电量，保留1位小数，保证显示精度 self.battery_percent = round( (self.current_voltage - self.min_voltage) / (self.max_voltage - self.min_voltage) * 100, @@ -42,7 +60,11 @@ def calculate_battery_percent(self): ) def get_battery_status(self): - """判断电量状态""" + """根据剩余电量判断电池当前状态 + 返回值说明： + - 第一个返回值：文字状态描述（满电/正常/低电量/紧急） + - 第二个返回值：状态标识符号（对应不同告警级别） + """ if self.battery_percent >= 95: return "满电", "🟢" elif 20 <= self.battery_percent < 95: @@ -53,43 +75,55 @@ def get_battery_status(self): return "紧急（请充电）", "🔴" def display_battery_info(self): - """可视化显示电量信息""" - # 清空控制台（可选） + """可视化展示电池完整信息 + 包括实时电压、剩余电量进度条、当前状态， + 低电量时触发额外告警提示，提升使用安全性。 + """ + # 清空控制台屏幕（可选功能，根据实际使用场景选择是否启用） + # 兼容Windows和Linux/macOS系统 + # import os # os.system('cls' if os.name == 'nt' else 'clear') - # 电量条可视化 - bar_length = 20 - filled_length = int(bar_length * self.battery_percent // 100) - battery_bar = "█" * filled_length + "-" * (bar_length - filled_length) + # 电量进度条可视化配置 + bar_length = 20 # 进度条总长度（字符数） + filled_length = int(bar_length * self.battery_percent // 100) # 已填充进度长度 + battery_bar = "█" * filled_length + "-" * (bar_length - filled_length) # 拼接进度条 - # 获取状态 + # 获取当前电池状态描述和状态标识 status, color = self.get_battery_status() - # 打印信息 - print(f"\n=== 无人车电池状态 ===") + # 打印格式化后的电池信息 + print(f"\n=== 无人车电池状态监控 ===") print(f"当前电压: {self.current_voltage}V") print(f"剩余电量: |{battery_bar}| {self.battery_percent}%") print(f"状态: {color} {status}") - # 低电量告警 + # 紧急告警：电量低于5%时，提示立即停止作业并充电 if self.battery_percent < 5: - print("⚠️ 电量过低，立即停止作业并充电") + print("⚠️ 【紧急告警】电量过低，立即停止所有作业并接入充电器！") def main(): - """主循环""" + """程序主入口，实现电池状态循环监控 + 初始化电池管理对象，持续执行「电压读取→电量计算→信息展示」流程， + 支持通过Ctrl+C快捷键正常退出监控程序。 + """ + # 初始化无人车电池管理实例 battery = UnmannedVehicleBattery() - print("无人车电量监控系统启动...") + print("无人车电量监控系统已启动...（按Ctrl+C可退出监控）") try: + # 无限循环执行监控流程，每秒刷新一次数据 while True: - battery.read_battery_voltage() # 读取电压 - battery.calculate_battery_percent() # 计算电量 - battery.display_battery_info() # 显示信息 - time.sleep(1) # 1秒刷新一次 + battery.read_battery_voltage() # 步骤1：读取电池实时电压 + battery.calculate_battery_percent() # 步骤2：计算剩余电量百分比 + battery.display_battery_info() # 步骤3：可视化展示电池状态 + time.sleep(1) # 设置刷新间隔为1秒，可根据需求调整 except KeyboardInterrupt: - print("\n监控系统已退出") + # 捕获Ctrl+C中断信号，友好退出程序 + print("\n监控系统已正常退出") if __name__ == "__main__": + # 程序启动时，直接执行主函数 main() \ No newline at end of file From 4e4d975edc92a0f11fdf0987012b16ddffd823b5 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 11:29:11 +0800 Subject: [PATCH 25/33] 1 --- src/Smart_car/path.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/Smart_car/path.py b/src/Smart_car/path.py index 14de9a79d4..60d6893d98 100644 --- a/src/Smart_car/path.py +++ b/src/Smart_car/path.py @@ -1,10 +1,3 @@ -import pygame -import sys -import math - -# 初始化pygame -pygame.init() - # 窗口配置 WINDOW_WIDTH = 800 WINDOW_HEIGHT = 600 From c1b0510e4af40cce49bebfe177009cb666406838 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 11:29:26 +0800 Subject: [PATCH 26/33] 1 --- src/Smart_car/traffic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index 49ab35aa92..f1c7f28c39 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -42,7 +42,7 @@ def traffic_light_real_time_detection(): # 自适应最小面积（基于摄像头分辨率） min_area = (640 * 480) / 1000 - print("摄像头已启动，实时交通信号灯检测中...") + print("摄像头已启动，实时交通信号灯检测中..") print("操作提示：") print(" 1. 按下 's' 键保存当前检测结果图像") print(" 2. 按下 'ESC' 键退出程序") From e38fdeb2991bca4a3e69024d78dad16013ebaf02 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 15:00:29 +0800 Subject: [PATCH 27/33] 1 --- src/Smart_car/traffic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index f1c7f28c39..49ab35aa92 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -42,7 +42,7 @@ def traffic_light_real_time_detection(): # 自适应最小面积（基于摄像头分辨率） min_area = (640 * 480) / 1000 - print("摄像头已启动，实时交通信号灯检测中..") + print("摄像头已启动，实时交通信号灯检测中...") print("操作提示：") print(" 1. 按下 's' 键保存当前检测结果图像") print(" 2. 按下 'ESC' 键退出程序") From aa7e2263447918c98a276e770ef14147f7a2df81 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 15:07:18 +0800 Subject: [PATCH 28/33] 1 --- src/Smart_car/traffic.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/traffic.py b/src/Smart_car/traffic.py index 49ab35aa92..157ee7a3a5 100644 --- a/src/Smart_car/traffic.py +++ b/src/Smart_car/traffic.py @@ -66,7 +66,7 @@ def filter_valid_contours(contours, min_area_val): # 3. 读取摄像头帧 ret, frame = cap.read() if not ret: - print("警告：无法读取摄像头帧，可能是摄像头断开连接") + print("警告：无法读取摄像头帧，可能是摄像头断开连接.") break # 复制帧用于绘制结果 From 5c261566b9d8e07df798842dfd0c7931a5b893ef Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 17:40:00 +0800 Subject: [PATCH 29/33] 1 --- src/Smart_car/README.md | 229 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 229 insertions(+) diff --git a/src/Smart_car/README.md b/src/Smart_car/README.md index e69de29bb2..16dcce9f37 100644 --- a/src/Smart_car/README.md +++ b/src/Smart_car/README.md @@ -0,0 +1,229 @@ +--- +AIGC: + ContentProducer: Minimax Agent AI + ContentPropagator: Minimax Agent AI + Label: AIGC + ProduceID: e052170842fbffc7d21baedf4eb60a91 + PropagateID: e052170842fbffc7d21baedf4eb60a91 + ReservedCode1: 30450220634cdb7d01a90f09d27c8175ddbead6c2e00eb6885f4bf068b71a5e68462deca022100bae83365aff19667c6a3d81e38e6b421807893b6f6908a22e839588a0946a346 + ReservedCode2: 3046022100a7bfdf8c0b714f1dba19461db6b74519f502d4673a07347747fb0cf56e840d95022100854fe1d24afa96ab2ea3fae7b6bc2b8d75f2021846f4dce4f4743a9680d68e0d +--- + +# 智能无人车导航系统 + +![无人车导航系统](imgs/chinese_nav_0.png) + +> 基于ROS的智能无人车自主导航系统，支持路径规划、障碍物避让、实时定位等功能 + +## 项目简介 + +本项目是一个基于ROS (Robot Operating System) 框架开发的智能无人车导航系统，集成了先进的SLAM算法、路径规划、动态避障等功能模块，实现了完全自主的室内外导航能力。 + +### 核心特性 + +- 实时建图 (SLAM)**: 基于激光雷达的实时环境建图 +- 智能路径规划**: 支持全局路径规划和局部路径优化 +- 动态避障**: 实时检测障碍物并调整路径 +- 精确定位**: 多传感器融合定位系统 +- 多种控制模式**: 支持手动控制、自动导航、目标点导航 +- 实时监控**: 可视化界面实时显示系统状态 + +## 快速开始 + +### 系统要求 + +- **操作系统**: Ubuntu 18.04/20.04 LTS +- **ROS版本**: Melodic/Noetic +- **Python**: 2.7/3.x +- **硬件要求**: + - 激光雷达 (16线/32线) + - 深度相机 + - IMU传感器 + - 编码器 + +### 安装步骤 + +```bash +# 1. 创建工作空间 +mkdir -p ~/catkin_ws/src +cd ~/catkin_ws/src + +# 2. 克隆项目 +git clone https://github.com/your-repo/autonomous-vehicle.git + +# 3. 安装依赖 +cd autonomous-vehicle +rosdep install --from-paths src --ignore-src -r -y + +# 4. 编译项目 +cd ~/catkin_ws +catkin_make + +# 5. 加载环境变量 +source devel/setup.bash +``` + +### 运行演示 + +```bash +# 启动仿真环境 +roslaunch autonomous_vehicle simulation.launch + +# 启动真实机器人 +roslaunch autonomous_vehicle robot.launch + +# 启动导航系统 +roslaunch autonomous_vehicle navigation.launch +``` + +## 运行效果图 + +### 1. ROS导航仿真界面 + +(imgs/ros_navigation_4.png) +*图1: ROS RViz环境下的导航仿真界面，实时显示地图、路径规划和机器人位置* + +### 2. 路径规划可视化 + +![路径规划](imgs/path_planning_6.png) +*图2: 智能路径规划系统，绿色线条显示全局规划路径，红色线条显示局部优化路径* + +### 3. 障碍物避让演示 + +![障碍物避让](imgs/obstacle_avoidance_8.jpg) +*图3: 实时障碍物检测与避让，黄色区域为检测到的障碍物，蓝色区域为安全路径* + +### 4. 中文导航界面 + +![中文导航](imgs/chinese_nav_8.png) +*图4: 中文导航系统界面，支持目标点设定、路径显示和状态监控* + +### 5. 实时地图构建 + +![地图构建](imgs/chinese_nav_7.png) +*图5: 实时SLAM地图构建过程，显示环境特征点和机器人轨迹* + +## 系统架构 + +``` +autonomous_vehicle/ +├── src/ +│ ├── perception/ # 感知模块 +│ │ ├── obstacle_detection/ +│ │ ├── lane_detection/ +│ │ └── traffic_light_detection/ +│ ├── localization/ # 定位模块 +│ │ ├── slam/ +│ │ └── ekf_localization/ +│ ├── planning/ # 规划模块 +│ │ ├── global_planner/ +│ │ └── local_planner/ +│ ├── control/ # 控制模块 +│ │ ├── pid_controller/ +│ │ └── pure_pursuit/ +│ └── utils/ # 工具模块 +├── launch/ # 启动文件 +├── config/ # 配置文件 +├── urdf/ # 机器人模型 +├── rviz/ # 可视化配置 +└── scripts/ # 脚本文件 +``` + +## 性能指标 + +| 指标项 | 性能参数 | +|--------|----------| +| 最大速度 | 2.0 m/s | +| 最小转弯半径 | 0.5 m | +| 定位精度 | ±5 cm | +| 避障距离 | 1.0 m | +| 地图分辨率 | 5 cm/pixel | +| 路径规划频率 | 10 Hz | + + 使用场景 + +- 室内服务机器人**: 办公楼、医院、酒店等场所的自主导航 +- 工业AGV**: 工厂内的物料搬运和自动化运输 +- 室外巡检机器人**: 园区巡检、安防监控等应用 +- 教育研究**: 机器人学习和算法验证平台 + +## API文档 + +### 主要话题 + +| 话题名称 | 消息类型 | 功能描述 | +|----------|----------|----------| +| `/cmd_vel` | `geometry_msgs/Twist` | 机器人运动控制命令 | +| `/scan` | `sensor_msgs/LaserScan` | 激光雷达数据 | +| `/amcl_pose` | `geometry_msgs/PoseWithCovarianceStamped` | 机器人位姿信息 | +| `/move_base/goal` | `geometry_msgs/PoseStamped` | 导航目标点 | + +### 主要服务 + +| 服务名称 | 服务类型 | 功能描述 | +|----------|----------|----------| +| `/slam_gmapping/map` | `nav_msgs/GetMap` | 获取地图数据 | +| `/static_map` | `nav_msgs/GetMap` | 获取静态地图 | + +## 配置说明 + +### 导航参数配置 + +```yaml +# costmap_common_params.yaml +obstacle_radius: 0.2 +inflation_radius: 0.5 +max_vel_x: 0.5 +min_vel_x: -0.5 +max_vel_theta: 1.0 +``` + +### 激光雷达配置 + +```yaml +# lidar_params.yaml +min_range: 0.2 +max_range: 30.0 +scan_frequency: 5.0 +angular_resolution: 0.25 +``` + +## 故障排除 + +### 常见问题 + +1. **激光雷达数据丢失** + - 检查激光雷达连接 + - 确认串口权限设置 + +2. **定位不准确** + - 校准IMU传感器 + - 检查编码器数据 + +3. **路径规划失败** + - 检查地图数据完整性 + - 确认目标点可达性 + +### 日志查看 + +```bash +# 查看系统日志 +roslaunch autonomous_vehicle log.launch + +# 实时监控话题数据 +rostopic echo /cmd_vel +``` + +## 贡献指南 + +我们欢迎社区贡献！请阅读 [CONTRIBUTING.md](CONTRIBUTING.md) 了解详细信息。 + +### 开发环境搭建 + +```bash +# 安装开发工具 +sudo apt install python3-catkin-tools python3-osrf-pycommon + +# 克隆开发分支 +git checkout -b feature/your-feature +``` \ No newline at end of file From 288aae10941f1557cf787b12802a5a5ecdacbac5 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Tue, 23 Dec 2025 17:48:48 +0800 Subject: [PATCH 30/33] 1 --- src/Smart_car/README.md | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/src/Smart_car/README.md b/src/Smart_car/README.md index 16dcce9f37..9f882079af 100644 --- a/src/Smart_car/README.md +++ b/src/Smart_car/README.md @@ -21,12 +21,12 @@ AIGC: ### 核心特性 -- 实时建图 (SLAM)**: 基于激光雷达的实时环境建图 -- 智能路径规划**: 支持全局路径规划和局部路径优化 -- 动态避障**: 实时检测障碍物并调整路径 -- 精确定位**: 多传感器融合定位系统 -- 多种控制模式**: 支持手动控制、自动导航、目标点导航 -- 实时监控**: 可视化界面实时显示系统状态 +- 实时建图 (SLAM): 基于激光雷达的实时环境建图 +- 智能路径规划: 支持全局路径规划和局部路径优化 +- 动态避障: 实时检测障碍物并调整路径 +- 精确定位: 多传感器融合定位系统 +- 多种控制模式: 支持手动控制、自动导航、目标点导航 +- 实时监控: 可视化界面实时显示系统状态 ## 快速开始 @@ -142,7 +142,7 @@ autonomous_vehicle/ 使用场景 -- 室内服务机器人**: 办公楼、医院、酒店等场所的自主导航 +- 室内服务机器人: 办公楼、医院、酒店等场所的自主导航 - 工业AGV**: 工厂内的物料搬运和自动化运输 - 室外巡检机器人**: 园区巡检、安防监控等应用 - 教育研究**: 机器人学习和算法验证平台 @@ -213,11 +213,6 @@ roslaunch autonomous_vehicle log.launch # 实时监控话题数据 rostopic echo /cmd_vel ``` - -## 贡献指南 - -我们欢迎社区贡献！请阅读 [CONTRIBUTING.md](CONTRIBUTING.md) 了解详细信息。 - ### 开发环境搭建 ```bash From 4313ec2eba46dcb75a2c5a9c30b1a2c98ee143f8 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Wed, 24 Dec 2025 21:17:09 +0800 Subject: [PATCH 31/33] 1 --- src/Smart_car/overload.py | 100 ++++++++++++++++++++++++++------------ 1 file changed, 69 insertions(+), 31 deletions(-) diff --git a/src/Smart_car/overload.py b/src/Smart_car/overload.py index f53fdf0dc0..6f069dbb2f 100644 --- a/src/Smart_car/overload.py +++ b/src/Smart_car/overload.py @@ -3,37 +3,63 @@ class UnmannedVehicleOverloadWarningSystem: """无人车超载预警系统 - 功能：实时监测无人车载重状态，根据载重占比划分预警等级，输出可视化预警信息，严重超载时紧急停止系统 + + 核心功能： + 1. 实时监测无人车载重状态数据 + 2. 根据载重占比自动划分预警等级 + 3. 可视化输出预警信息及处理建议 + 4. 检测到严重超载时触发系统紧急停止机制 """ def __init__(self, max_load=1000): - # 初始化系统核心参数 - self.max_load = max_load # 车辆最大载重（单位：kg，可根据实际车型自定义配置） - self.current_load = 0 # 当前实时载重，初始值为0 + """系统初始化方法，配置核心参数 + + 参数: + max_load (int/float): 车辆最大载重限额，单位为千克(kg)，可根据实际车型自定义配置，默认值1000 + 实例属性: + self.max_load: 存储车辆最大载重 + self.current_load: 当前实时载重，初始值设为0 + self.warning_level: 预警等级标识，0-正常，1-轻度过载，2-中度过载，3-严重超载 + """ + self.max_load = max_load # 车辆最大载重（kg） + self.current_load = 0 # 当前实时载重，初始化为0 self.warning_level = 0 # 预警等级：0-正常，1-轻度过载，2-中度过载，3-严重超载 def simulate_weight_collection(self): - """模拟无人车重量采集（模拟传感器数据，可替换为真实硬件接口） - 逻辑：在当前载重基础上随机小幅波动，模拟乘客上下车或货物装卸的载重变化 - 返回：更新后的当前载重值 + """模拟无人车重量数据采集（传感器数据模拟接口） + + 逻辑说明： + 在当前载重基础上进行随机小幅波动，模拟乘客上下车或货物装卸带来的载重变化 + 避免载重出现负数，最低载重限制为0 + + 返回: + float: 更新后的当前载重数值 """ - # 模拟载重变化：每次波动范围为-50kg（卸载）到100kg（加载） + # 模拟载重变化范围：卸载最多50kg，加载最多100kg weight_change = random.randint(-50, 100) - # 更新当前载重，确保载重不会为负数（最低为0） + # 更新当前载重，确保载重不低于0（最低载重为0） self.current_load = max(0, self.current_load + weight_change) return self.current_load def judge_overload(self): - """超载判断逻辑，根据载重占比划分预警等级 - 计算规则：载重占比 = 当前载重 / 最大载重 - 返回值：(预警状态名称, 预警颜色标识, 处理建议描述) + """超载等级判断核心方法，基于载重占比划分预警等级 + + 计算规则： + 载重占比 = 当前载重 / 最大载重 + + 返回值: + tuple: 包含三个元素的元组，依次为： + 1. 预警状态名称（字符串） + 2. 预警颜色标识（字符串） + 3. 处理建议描述（字符串） """ - load_ratio = self.current_load / self.max_load # 计算载重占比，用于等级判定 + # 计算载重占比，作为预警等级判定的核心依据 + load_ratio = self.current_load / self.max_load - # 正常状态：载重≤80%最大载重，无需干预 + # 正常状态：载重≤80%最大载重，无需任何干预措施 if load_ratio <= 0.8: self.warning_level = 0 return "正常", "绿色", "当前载重未超出安全范围，无需处理" - # 轻度过载预警：80%<载重≤95%，接近上限需停止加载 + # 轻度过载预警：80%<载重≤95%，接近上限需停止继续加载 elif 0.8 < load_ratio <= 0.95: self.warning_level = 1 return "轻度过载预警", "黄色", "当前载重接近上限，建议停止加载" @@ -48,10 +74,11 @@ def judge_overload(self): def display_warning(self, status, color, desc): """可视化输出预警信息（模拟车载终端显示界面） - 参数： - status: 预警状态名称（如"正常"、"严重超载警报"） - color: 预警颜色标识（如"绿色"、"红色"） - desc: 具体处理建议描述 + + 参数: + status (str): 预警状态名称（如"正常"、"严重超载警报"等） + color (str): 预警颜色标识（如"绿色"、"红色"等，对应车载终端显示颜色） + desc (str): 针对当前状态的具体处理建议描述 """ print("=" * 50) print(f"【无人车超载预警系统 - 实时监测】") @@ -65,30 +92,41 @@ def display_warning(self, status, color, desc): print() def run(self, monitor_times=10): - """运行系统，持续循环监测载重并输出预警信息 - 参数： - monitor_times: 预设监测次数，默认10次，可根据需求修改 - 流程：采集载重→判断等级→显示预警→异常停止（严重超载）→间隔等待 + """系统主运行方法，执行持续循环监测流程 + + 参数: + monitor_times (int): 预设监测总次数，默认值10次，可根据实际需求修改 + + 运行流程: + 1. 采集当前载重数据（模拟传感器更新） + 2. 判断超载预警等级，获取预警相关信息 + 3. 可视化输出预警详情（模拟车载终端展示） + 4. 检测到严重超载时，触发紧急停止机制 + 5. 间隔指定时间，进行下一次循环监测 """ print("无人车超载预警系统已启动...") print(f"开始持续监测（共监测{monitor_times}次，每次间隔2秒）\n") - # 循环执行监测流程，达到预设次数或检测到严重超载时终止 + # 循环执行监测流程，满足以下任一条件即终止： + # 1. 完成预设的监测次数 + # 2. 检测到严重超载（预警等级3） for i in range(monitor_times): - # 1. 采集当前载重（模拟传感器数据更新） + # 步骤1：采集当前载重（模拟传感器数据实时更新） self.simulate_weight_collection() - # 2. 判断超载等级，获取预警相关信息 + # 步骤2：判断超载等级，获取预警状态、颜色及处理建议 status, color, desc = self.judge_overload() - # 3. 可视化输出预警详情（模拟车载终端展示） + # 步骤3：可视化输出预警详情（模拟车载终端显示效果） self.display_warning(status, color, desc) - # 4. 严重超载（等级3）时，紧急停止系统运行 + # 步骤4：严重超载（等级3）时，立即紧急停止系统运行 if self.warning_level == 3: print("❗❗❗ 检测到严重超载，系统紧急停止运行！❗") break - # 5. 间隔2秒进行下一次监测，模拟实时周期性检测 + # 步骤5：间隔2秒进行下一次监测，模拟实时周期性数据检测 time.sleep(2) if __name__ == "__main__": - # 初始化系统：设置无人车最大载重为1000kg（可根据车型/场景需求修改该参数） + # 初始化系统：设置无人车最大载重为1000kg + # 备注：可根据不同车型、应用场景修改max_load参数值 overload_system = UnmannedVehicleOverloadWarningSystem(max_load=1000) - # 运行系统，持续监测10次（可修改monitor_times参数调整监测次数） + # 运行系统：持续监测10次 + # 备注：可修改monitor_times参数调整监测总次数 overload_system.run(monitor_times=10) \ No newline at end of file From 960839f563a9b59d12ccd592824d4c03ad24fb94 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 25 Dec 2025 10:00:20 +0800 Subject: [PATCH 32/33] 1 --- src/Smart_car/autonomous_vehicle_battery_level_display.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Smart_car/autonomous_vehicle_battery_level_display.py b/src/Smart_car/autonomous_vehicle_battery_level_display.py index 9cb9dba2a2..e5738ae2e5 100644 --- a/src/Smart_car/autonomous_vehicle_battery_level_display.py +++ b/src/Smart_car/autonomous_vehicle_battery_level_display.py @@ -118,7 +118,7 @@ def main(): battery.read_battery_voltage() # 步骤1：读取电池实时电压 battery.calculate_battery_percent() # 步骤2：计算剩余电量百分比 battery.display_battery_info() # 步骤3：可视化展示电池状态 - time.sleep(1) # 设置刷新间隔为1秒，可根据需求调整 + time.sleep(1) except KeyboardInterrupt: # 捕获Ctrl+C中断信号，友好退出程序 print("\n监控系统已正常退出") From a4006b3a2fc16923dd6e9e1c4d9fd9e6b0515ff0 Mon Sep 17 00:00:00 2001 From: yuboyyy <2814479226@qq.com> Date: Thu, 25 Dec 2025 22:06:46 +0800 Subject: [PATCH 33/33] 1 --- ...utonomous_vehicle_battery_level_display.py | 120 +++++++++++------- 1 file changed, 76 insertions(+), 44 deletions(-) diff --git a/src/Smart_car/autonomous_vehicle_battery_level_display.py b/src/Smart_car/autonomous_vehicle_battery_level_display.py index e5738ae2e5..a61e21363c 100644 --- a/src/Smart_car/autonomous_vehicle_battery_level_display.py +++ b/src/Smart_car/autonomous_vehicle_battery_level_display.py @@ -4,55 +4,67 @@ class UnmannedVehicleBattery: """无人车电池电量管理核心类 - 负责电池电压读取、剩余电量计算、状态判断及可视化展示， - 支持对接实际硬件采集模块，可根据电池规格灵活配置参数。 + 核心职责： + 1. 电池实时电压数据读取（支持对接实际硬件或模拟采集） + 2. 基于电压值计算剩余电量百分比 + 3. 根据剩余电量判断电池工作状态 + 4. 格式化、可视化展示电池完整监控信息 + 特性： + - 可根据电池型号/规格灵活配置核心参数（满电电压、欠压保护电压等） + - 预留硬件采集对接接口，易于实际项目部署迁移 """ def __init__(self): # 电池核心参数配置（可根据实际使用的电池型号/规格调整对应数值） - self.max_voltage = 12.6 # 电池满电电压（以12V三元锂电池为例） + self.max_voltage = 12.6 # 电池满电电压（示例：12V三元锂电池满电电压） self.min_voltage = 10.0 # 电池欠压保护电压，低于此值需立即停止使用并充电 - self.current_voltage = 0.0 # 电池实时电压（初始值为0，通过硬件采集或模拟更新） - self.battery_percent = 0.0 # 电池剩余电量百分比（保留1位小数） + self.current_voltage = 0.0 # 电池实时电压（初始值为0，后续通过硬件采集或模拟逻辑更新） + self.battery_percent = 0.0 # 电池剩余电量百分比（计算后保留1位小数，保证显示精度） def read_battery_voltage(self): """读取电池实时电压（模拟硬件采集逻辑） - 实际应用场景中，需替换为对应硬件的数据采集方式： - 1. 树莓派/单片机：通过ADC模块（如ADS1115）采集电压信号 - 2. 带BMS的电池：通过串口/RS485/I2C通信获取BMS上报的电压数据 - 3. 其他硬件：根据对应通信协议调整数据读取逻辑 + 实际应用场景对接说明： + 1. 树莓派/单片机平台：通过ADC模块（如ADS1115）采集电压模拟信号 + 2. 带BMS管理系统的电池：通过串口/RS485/I2C通信协议获取BMS上报的电压数据 + 3. 其他硬件平台：根据对应硬件的通信协议调整数据读取逻辑 + 本方法中模拟逻辑仅用于测试演示，实际部署需替换为真实硬件采集代码 """ - # 模拟电压小幅波动（范围：欠压保护电压~满电电压，保留2位小数） + # 模拟电压小幅波动（范围：欠压保护电压~满电电压，保留2位小数，贴近真实电池电压变化） self.current_voltage = round(random.uniform(10.0, 12.6), 2) # 实际硬件采集示例（以树莓派+ADS1115 ADC模块为例，需安装对应依赖库） - # 依赖库安装：pip install adafruit-circuitpython-ads1x15 + # 依赖库安装命令：pip install adafruit-circuitpython-ads1x15 # import board # import adafruit_ads1x15.ads1115 as ADS # from adafruit_ads1x15.analog_in import AnalogIn # - # # 初始化I2C总线和ADS1115模块 - # i2c = board.I2C() # 默认使用SDA/SCL引脚 + # # 初始化I2C总线和ADS1115模块（使用硬件默认SDA/SCL引脚） + # i2c = board.I2C() # ads = ADS.ADS1115(i2c) - # chan = AnalogIn(ads, ADS.P0) # 选择A0通道作为电压采集通道 + # chan = AnalogIn(ads, ADS.P0) # 选择A0通道作为电池电压采集通道 # - # # 计算实际电池电压（需根据分压电路配置对应的电压分压比） - # voltage_divider_ratio = 2.0 # 分压比示例，需根据实际电路调整 + # # 计算实际电池电压（需根据硬件分压电路配置，调整对应的电压分压比） + # voltage_divider_ratio = 2.0 # 分压比示例，需根据实际电路参数修改 # self.current_voltage = chan.voltage * voltage_divider_ratio def calculate_battery_percent(self): """根据实时电压计算电池剩余电量百分比 - 采用线性计算模型（适用于电压与电量近似线性的电池类型）， - 实际场景中可根据电池放电曲线优化为非线性计算模型，提升精度。 + 计算模型说明： + - 采用线性计算模型，适用于电压与电量近似线性关系的电池类型（如三元锂电池） + - 实际场景优化建议：可根据电池具体放电曲线，优化为非线性计算模型，提升电量计算精度 + 计算逻辑： + 1. 电压≥满电电压：判定为100%满电量 + 2. 电压≤欠压保护电压：判定为0%电量（需立即停止使用） + 3. 电压在两者之间：通过线性插值公式计算剩余电量，保留1位小数 """ if self.current_voltage >= self.max_voltage: - # 电压达到满电电压，判定为100%电量 + # 电压达到满电阈值，判定为100%剩余电量 self.battery_percent = 100.0 elif self.current_voltage <= self.min_voltage: - # 电压低于欠压保护值，判定为0%电量（需立即充电） + # 电压低于欠压保护阈值，判定为0%剩余电量（需立即充电） self.battery_percent = 0.0 else: - # 线性插值计算剩余电量，保留1位小数，保证显示精度 + # 线性插值计算剩余电量，保留1位小数，保证显示一致性 self.battery_percent = round( (self.current_voltage - self.min_voltage) / (self.max_voltage - self.min_voltage) * 100, @@ -60,10 +72,15 @@ def calculate_battery_percent(self): ) def get_battery_status(self): - """根据剩余电量判断电池当前状态 + """根据剩余电量判断电池当前工作状态 返回值说明： - - 第一个返回值：文字状态描述（满电/正常/低电量/紧急） - - 第二个返回值：状态标识符号（对应不同告警级别） + - 第一个返回值：文字状态描述（用于直观展示电池状态） + - 第二个返回值：状态标识符号（通过颜色/emoji区分告警级别，提升可读性） + 状态分级标准： + 1. 满电：电量≥95%，正常工作状态 + 2. 正常：20%≤电量<95%，可正常执行作业 + 3. 低电量：5%≤电量<20%，需准备充电 + 4. 紧急：电量<5%，需立即停止作业并充电 """ if self.battery_percent >= 95: return "满电", "🟢" @@ -75,55 +92,70 @@ def get_battery_status(self): return "紧急（请充电）", "🔴" def display_battery_info(self): - """可视化展示电池完整信息 - 包括实时电压、剩余电量进度条、当前状态， - 低电量时触发额外告警提示，提升使用安全性。 + """可视化展示电池完整监控信息 + 展示内容： + 1. 电池实时电压 + 2. 剩余电量百分比及可视化进度条 + 3. 电池当前工作状态（含状态标识） + 4. 紧急告警提示（电量<5%时触发） + 优化特性： + - 进度条可视化提升信息可读性 + - 紧急告警强化使用安全性，提醒用户及时处理 + 可选配置： + - 可启用控制台清屏功能，实现监控信息实时刷新（已注释，按需启用） """ # 清空控制台屏幕（可选功能，根据实际使用场景选择是否启用） - # 兼容Windows和Linux/macOS系统 + # 兼容Windows（cls命令）和Linux/macOS（clear命令）系统 # import os # os.system('cls' if os.name == 'nt' else 'clear') # 电量进度条可视化配置 - bar_length = 20 # 进度条总长度（字符数） - filled_length = int(bar_length * self.battery_percent // 100) # 已填充进度长度 - battery_bar = "█" * filled_length + "-" * (bar_length - filled_length) # 拼接进度条 + bar_length = 20 # 进度条总长度（字符数），可根据显示需求调整 + filled_length = int(bar_length * self.battery_percent // 100) # 已填充进度的字符长度 + battery_bar = "█" * filled_length + "-" * (bar_length - filled_length) # 拼接进度条字符 - # 获取当前电池状态描述和状态标识 + # 获取当前电池状态描述和状态标识符号 status, color = self.get_battery_status() - # 打印格式化后的电池信息 + # 打印格式化后的电池监控信息，排版清晰便于查看 print(f"\n=== 无人车电池状态监控 ===") print(f"当前电压: {self.current_voltage}V") print(f"剩余电量: |{battery_bar}| {self.battery_percent}%") print(f"状态: {color} {status}") - # 紧急告警：电量低于5%时，提示立即停止作业并充电 + # 紧急告警：电量低于5%时，提示用户立即停止作业并接入充电器，避免电池过放损坏 if self.battery_percent < 5: print("⚠️ 【紧急告警】电量过低，立即停止所有作业并接入充电器！") def main(): """程序主入口，实现电池状态循环监控 - 初始化电池管理对象，持续执行「电压读取→电量计算→信息展示」流程， - 支持通过Ctrl+C快捷键正常退出监控程序。 + 核心流程： + 1. 初始化无人车电池管理实例 + 2. 循环执行「电压读取→电量计算→信息展示」流程 + 3. 每秒刷新一次监控数据，保证实时性 + 退出机制： + - 支持通过Ctrl+C快捷键捕获中断信号，实现程序友好退出，避免异常报错 + 运行提示： + - 启动后会输出系统启动提示，告知用户退出方式 """ - # 初始化无人车电池管理实例 + # 初始化无人车电池管理实例，加载电池核心配置参数 battery = UnmannedVehicleBattery() print("无人车电量监控系统已启动...（按Ctrl+C可退出监控）") try: - # 无限循环执行监控流程，每秒刷新一次数据 + # 无限循环执行监控流程，每秒刷新一次数据，实现持续监控 while True: - battery.read_battery_voltage() # 步骤1：读取电池实时电压 - battery.calculate_battery_percent() # 步骤2：计算剩余电量百分比 - battery.display_battery_info() # 步骤3：可视化展示电池状态 - time.sleep(1) + battery.read_battery_voltage() # 步骤1：读取电池实时电压（模拟/硬件采集） + battery.calculate_battery_percent() # 步骤2：根据电压计算剩余电量百分比 + battery.display_battery_info() # 步骤3：可视化展示电池完整监控信息 + time.sleep(1) # 暂停1秒，控制监控刷新频率 except KeyboardInterrupt: - # 捕获Ctrl+C中断信号，友好退出程序 + # 捕获Ctrl+C中断信号，打印退出提示，实现程序正常退出 print("\n监控系统已正常退出") if __name__ == "__main__": - # 程序启动时，直接执行主函数 + # 程序启动入口：当脚本直接运行时，自动执行主函数启动监控系统 + # 若作为模块导入时，不会自动执行，便于复用类和方法 main() \ No newline at end of file