编写程序实现智能书包重量检测，超重时提示“减轻书本”，保护脊椎。

智能书包重量检测与脊椎保护系统

一、实际应用场景描述

现代中小学生课业负担日益加重，书包重量往往超过儿童身体承受的安全范围。据医学研究表明，儿童书包重量不应超过体重的10%-15%，否则长期背负会导致脊柱侧弯、驼背、肌肉劳损等健康问题。

典型场景：

- 小学生小明（体重25kg）每天背着4-5公斤的书包上学，内含语文、数学、英语、科学等课本，加上作业本、文具盒、水壶等物品

- 初中生小红（体重40kg）面临中考压力，书包重量达到7-8公斤，包含各种教辅资料

- 高中生小华（体重50kg）书包重量超过8公斤，长期单肩背负导致肩膀高低不平

传统解决方案的局限：

- 家长凭经验判断，缺乏客观数据支撑

- 学校无检测设备，无法实时监控

- 学生自身无感知，直到出现疼痛才意识到问题

- 没有实时提醒机制，无法及时卸重

- 缺乏历史数据，无法追踪书包重量变化趋势

- 无个性化建议，不同体重学生使用统一标准

本系统功能：

- 实时检测书包重量（精度±10g）

- 根据学生体重计算安全负重阈值

- 超重时语音提示"减轻书本"

- 可视化显示重量状态和健康建议

- 记录每日书包重量历史

- 脊椎健康风险评估与个性化建议

二、引入痛点

1. 健康隐患严重：过重书包导致儿童脊柱发育畸形，据统计我国中小学生脊柱侧弯发病率已达5%-10%

2. 主观判断不准：家长和老师难以准确估算书包重量，容易低估实际负重

3. 缺乏实时监控：学生在校期间无人监督书包重量，长时间背负超限物品

4. 即时反馈缺失：没有实时提醒机制，学生往往在感到疲劳时才发现问题

5. 数据记录空白：缺乏历史数据追踪，无法评估书包重量变化趋势

6. 个性化缺失：不同年龄、体重的学生使用统一标准，不够科学合理

7. 预防意识薄弱：学生和家长对书包重量的健康影响认识不足

8. 家校联动困难：学校与家长缺乏有效的书包重量沟通渠道

三、核心逻辑讲解

重量安全标准

学生体重(kg) 安全负重(kg) 最大负重(kg) 健康风险

20-25 2.0-3.0 3.5-4.0 低风险

25-35 3.0-4.5 4.5-6.0 中低风险

35-45 4.5-6.0 6.0-7.5 中风险

45-55 6.0-7.5 7.5-9.0 中高风险

>55 7.5-9.0 9.0-12.0 高风险

压力传感器HX711特性

HX711是一款24位A/D转换器，专用于电子秤设计

- 输入电压范围：±20mV

- 输出数据速率：10Hz或80Hz

- 内置放大器和稳压器

- 差分输入，抗干扰能力强

- 典型连接方式：Load Cell → HX711 → MCU

核心算法流程

1. 重量采集：

- HX711读取24位原始数据

- 多次采样取平均值

- 温度补偿和线性校准

2. 用户配置：

- 输入学生体重

- 计算个性化安全阈值

- 设置提醒灵敏度

3. 实时分析：

- 重量与阈值比较

- 连续超重检测（防误报）

- 趋势分析和预测

4. 多级提醒：

- 绿色：安全范围

- 黄色：接近上限

- 红色：超重报警

- 语音提示"减轻书本"

5. 数据记录：

- 时间戳记录

- 重量历史存储

- 健康报告生成

关键技术难点及解决方案

难点 解决方案

传感器零点漂移 上电自动归零，定期校准

温度影响精度 温度补偿算法，NTC热敏电阻

机械振动干扰 数字滤波，软件去抖

不同书包差异 用户自定义校准系数

误报问题 连续3次超重确认机制

功耗优化 休眠唤醒机制，动态采样

四、代码模块化（含安全设计）

项目结构

smart_backpack/

├── main.py # 主程序入口

├── sensors/ # 传感器模块

│ ├── __init__.py

│ ├── hx711_weight.py # HX711重量传感器驱动

│ └── calibration.py # 校准模块

├── core/ # 核心逻辑模块

│ ├── __init__.py

│ ├── weight_analyzer.py # 重量分析引擎

│ ├── health_assessor.py # 健康评估模块

│ └── alert_manager.py # 提醒管理器

├── actuators/ # 执行器模块

│ ├── __init__.py

│ ├── lcd_display.py # LCD显示屏控制

│ ├── voice_prompt.py # 语音提示模块

│ ├── led_indicator.py # LED指示灯控制

│ └── buzzer.py # 蜂鸣器控制

├── storage/ # 数据存储模块

│ ├── __init__.py

│ ├── data_logger.py # 数据记录器

│ └── report_generator.py # 报告生成器

├── config.py # 系统配置

├── requirements.txt # 依赖清单

├── README.md # 项目文档

└── utils/

├── __init__.py

├── logger.py # 日志工具

└── decorators.py # 装饰器工具

核心代码实现

1. config.py（系统配置）

"""

智能书包重量检测与脊椎保护系统配置文件

包含传感器、执行器、健康标准等所有配置参数

"""

from dataclasses import dataclass, field

from typing import List, Optional, Dict, Any, Tuple

from enum import Enum, auto

from pathlib import Path

import os

# 确保配置目录存在

Path("config").mkdir(parents=True, exist_ok=True)

class WeightStatus(Enum):

"""重量状态枚举"""

SAFE = auto() # 安全范围

WARNING = auto() # 警告（接近上限）

OVERWEIGHT = auto() # 超重

CRITICAL = auto() # 严重超重

class AlertLevel(Enum):

"""提醒级别枚举"""

NONE = auto() # 无提醒

MILD = auto() # 轻度提醒

MODERATE = auto() # 中度提醒

URGENT = auto() # 紧急提醒

@dataclass

class SensorConfig:

"""传感器配置"""

# HX711配置

hx711_dt_pin: int = 5 # 数据引脚

hx711_sck_pin: int = 6 # 时钟引脚

hx711_reference_unit: float = 1.0 # 参考单位（校准系数）

hx711_offset: int = 0 # 零点偏移

hx711_gain: int = 128 # 增益设置（128或64）

# 采样配置

sample_count: int = 10 # 采样次数

sample_interval: float = 0.1 # 采样间隔（秒）

filter_window: int = 5 # 滤波窗口大小

# 校准配置

calibration_weight: float = 1.0 # 校准砝码重量（kg）

calibration_samples: int = 20 # 校准采样次数

# 模拟模式（开发测试用）

simulation_mode: bool = True

@dataclass

class UserConfig:

"""用户配置"""

# 学生信息

student_name: str = "学生"

student_weight: float = 30.0 # 学生体重（kg）

student_age: int = 10 # 学生年龄

# 安全阈值配置

safe_load_ratio: float = 0.15 # 安全负重比例（体重的15%）

max_load_ratio: float = 0.20 # 最大负重比例（体重的20%）

warning_threshold: float = 0.85 # 警告阈值（安全上限的85%）

# 个性化设置

sensitivity: float = 1.0 # 敏感度（0.5-2.0）

reminder_interval: float = 30.0 # 提醒间隔（秒）

enable_voice: bool = True # 启用语音提醒

enable_display: bool = True # 启用显示

enable_led: bool = True # 启用LED指示

@dataclass

class HealthThresholds:

"""健康阈值配置"""

# 按年龄段的健康建议

age_groups: Dict[Tuple[int, int], Dict[str, Any]] = field(default_factory=lambda: {

(6, 8): {"safe_min": 1.5, "safe_max": 3.0, "warning_msg": "低年级学生书包不宜过重"},

(9, 11): {"safe_min": 2.0, "safe_max": 4.5, "warning_msg": "中年级学生注意减负"},

(12, 14): {"safe_min": 3.0, "safe_max": 6.0, "warning_msg": "高年级学业繁重，合理整理书包"},

(15, 18): {"safe_min": 4.0, "safe_max": 8.0, "warning_msg": "初高中生注意脊柱健康"}

})

# 脊椎健康风险评估

spine_risk_levels: Dict[str, Tuple[float, float]] = field(default_factory=lambda: {

"低风险": (0.0, 0.12),

"中低风险": (0.12, 0.15),

"中风险": (0.15, 0.18),

"中高风险": (0.18, 0.22),

"高风险": (0.22, 1.0)

})

@dataclass

class AlertConfig:

"""提醒配置"""

# LCD配置

lcd_enabled: bool = True

lcd_i2c_address: int = 0x27

lcd_columns: int = 16

lcd_rows: int = 2

# LED配置

led_enabled: bool = True

led_green_pin: int = 17

led_yellow_pin: int = 27

led_red_pin: int = 22

# 蜂鸣器配置

buzzer_enabled: bool = True

buzzer_pin: int = 23

buzzer_frequency_safe: int = 1000

buzzer_frequency_warning: int = 1500

buzzer_frequency_overweight: int = 2000

# 语音配置

voice_enabled: bool = True

voice_volume: int = 80 # 音量百分比

voice_language: str = "zh-CN"

# 提醒模式

vibration_enabled: bool = False # 震动提醒（可选配件）

vibration_pin: int = 24

@dataclass

class StorageConfig:

"""存储配置"""

# 数据记录

log_enabled: bool = True

log_directory: str = "data/logs"

log_filename: str = "weight_history.csv"

log_interval: float = 300.0 # 记录间隔（秒）

# 历史数据

max_history_days: int = 30

export_enabled: bool = True

export_format: str = "csv"

# 报告配置

weekly_report: bool = True

monthly_report: bool = True

@dataclass

class SystemConfig:

"""系统总配置"""

sensor: SensorConfig = field(default_factory=SensorConfig)

user: UserConfig = field(default_factory=UserConfig)

health: HealthThresholds = field(default_factory=HealthThresholds)

alert: AlertConfig = field(default_factory=AlertConfig)

storage: StorageConfig = field(default_factory=StorageConfig)

# 系统设置

debug_mode: bool = False

log_level: str = "INFO"

log_file: str = "smart_backpack.log"

# 安全限制

min_weight: float = 0.0

max_weight: float = 20.0 # 最大可测重量

min_student_weight: float = 15.0

max_student_weight: float = 100.0

def __post_init__(self):

# 确保目录存在

for directory in [self.storage.log_directory, "data", "reports"]:

Path(directory).mkdir(parents=True, exist_ok=True)

# 计算实际阈值

self._calculate_thresholds()

def _calculate_thresholds(self):

"""根据学生体重计算实际重量阈值"""

weight = self.user.student_weight

# 根据年龄组调整

for (age_min, age_max), params in self.health.age_groups.items():

if age_min <= self.user.student_age <= age_max:

self.user.safe_load_ratio = params["safe_max"] / weight if weight > 0 else 0.15

break

# 计算各级阈值

self.safe_threshold = weight * self.user.safe_load_ratio * self.user.sensitivity

self.warning_threshold = self.safe_threshold * self.user.warning_threshold

self.max_threshold = weight * self.user.max_load_ratio * self.user.sensitivity

logger.info(f"阈值计算完成: 安全={self.safe_threshold:.2f}kg, "

f"警告={self.warning_threshold:.2f}kg, "

f"最大={self.max_threshold:.2f}kg")

# 全局配置实例

config = SystemConfig()

# 重量状态颜色映射

STATUS_COLORS = {

WeightStatus.SAFE: (0, 255, 0), # 绿色

WeightStatus.WARNING: (255, 255, 0), # 黄色

WeightStatus.OVERWEIGHT: (255, 165, 0), # 橙色

WeightStatus.CRITICAL: (255, 0, 0) # 红色

}

# 提醒级别消息

ALERT_MESSAGES = {

AlertLevel.NONE: "",

AlertLevel.MILD: "书包略重，请注意",

AlertLevel.MODERATE: "书包较重，建议减负",

AlertLevel.URGENT: "书包超重！请减轻书本！"

}

# 脊椎健康建议

SPINE_HEALTH_ADVICE = {

"低风险": "书包重量适中，继续保持良好习惯",

"中低风险": "书包稍重，可适当减少不必要物品",

"中风险": "书包偏重，建议每日检查书包内容",

"中高风险": "书包过重，请及时减负保护脊椎",

"高风险": "书包严重超重！立即停止背负，咨询医生！"

}

# 年级对应建议

AGE_GROUP_ADVICE = {

(6, 8): "低年级同学：只带当天需要的课本，使用轻便文具盒",

(9, 11): "中年级同学：学会整理书包，定期清理不需要的物品",

(12, 14): "高年级同学：合理安排学习计划，避免携带过多参考资料",

(15, 18): "初高中同学：使用拉杆书包分担重量，注意双肩背负"

}

# 工厂函数

def create_config() -> SystemConfig:

"""创建配置实例"""

return config

def update_user_config(name: str = None, weight: float = None, age: int = None):

"""更新用户配置"""

global config

if name:

config.user.student_name = name

if weight:

config.user.student_weight = weight

config._calculate_thresholds()

if age:

config.user.student_age = age

config._calculate_thresholds()

logger = None # 将在main中初始化

2. sensors/hx711_weight.py（HX711重量传感器模块）

"""

HX711重量传感器模块

24位A/D转换器，专用于电子秤和压力检测

支持校准、滤波、温度补偿等功能

"""

import time

import logging

import random

from typing import Optional, List, Tuple, Deque

from dataclasses import dataclass, field

from enum import Enum, auto

from collections import deque

from config import config, SensorConfig

logger = logging.getLogger(__name__)

class SensorError(Exception):

"""传感器异常类"""

pass

class CalibrationError(SensorError):

"""校准异常类"""

pass

class GainChannel(Enum):

"""HX711增益通道"""

CHANNEL_A_GAIN_128 = 1 # 通道A，增益128（默认）

CHANNEL_A_GAIN_64 = 3 # 通道A，增益64

CHANNEL_B_GAIN_32 = 2 # 通道B，增益32

@dataclass

class WeightReading:

"""重量读数数据类"""

timestamp: float

raw_value: int

weight_kg: float

is_valid: bool = True

quality: float = 1.0 # 数据质量分数 0-1

temperature: Optional[float] = None # 温度补偿用

class HX711WeightSensor:

"""

HX711 24位重量传感器驱动

特性：

- 24位高精度A/D转换

- 内置可编程增益放大器

- 差分输入，抗干扰能力强

- 支持温度补偿

- 数字滤波和校准

- 模拟模式支持（开发测试用）

工作原理：

1. 称重传感器（应变片）将重量转换为微伏级电压

2. HX711内部PGA将信号放大

3. 24位Σ-Δ ADC将模拟信号转换为数字量

4. 通过参考单位和零点偏移计算实际重量

接线方式：

HX711 → Raspberry Pi

VCC → 3.3V/5V

GND → GND

DT(Data) → GPIO5

SCK(Clock)→ GPIO6

E+(红) → 传感器红线

E-(黑) → 传感器黑线

A+(绿) → 传感器绿线

A-(白) → 传感器白线

"""

# HX711命令码

CMD_READ_CH_A_128 = 0x01 # 读通道A，增益128

CMD_READ_CH_A_64 = 0x03 # 读通道A，增益64

CMD_READ_CH_B_32 = 0x02 # 读通道B，增益32

# 时序参数（微秒）

TIMING_CLOCK_HIGH = 1

TIMING_CLOCK_LOW = 1

TIMING_READ_DELAY = 1

def __init__(self, dt_pin: int = 5, sck_pin: int = 6, gain: int = 128):

"""

初始化HX711传感器

Args:

dt_pin: 数据引脚GPIO编号

sck_pin: 时钟引脚GPIO编号

gain: 增益设置（128或64）

"""

self.dt_pin = dt_pin

self.sck_pin = sck_pin

self.gain = gain

# 校准参数

self._reference_unit = config.sensor.hx711_reference_unit

self._offset = config.sensor.hx711_offset

# 滤波缓冲区

self._filter_buffer: Deque[float] = deque(

maxlen=config.sensor.filter_window

)

# 状态管理

self._is_initialized = False

self._is_ready = False

self._last_reading: Optional[WeightReading] = None

# 模拟模式

self._simulation_mode = config.sensor.simulation_mode

self._simulation_base_weight = 2.0 # 模拟基础重量

# 统计信息

self._readings_count = 0

self._error_count = 0

self._max_errors = 10

# 温度补偿参数

self._temperature_coefficient = -0.02 # 每度温度变化的影响（%/°C）

self._reference_temperature = 25.0 # 参考温度

logger.info(

f"HX711重量传感器初始化: DT引脚={dt_pin}, "

f"SCK引脚={sck_pin}, 增益={gain}"

)

def initialize(self) -> bool:

"""

初始化传感器硬件

Returns:

bool: 初始化是否成功

"""

try:

if self._simulation_mode:

logger.info("HX711传感器运行在模拟模式")

self._is_initialized = True

self._is_ready = True

return True

# 实际硬件初始化

# import RPi.GPIO as GPIO

# self.GPIO = GPIO

# self.GPIO.setmode(GPIO.BCM)

# self.GPIO.setup(self.dt_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# self.GPIO.setup(self.sck_pin, GPIO.OUT)

# self.GPIO.output(self.sck_pin, GPIO.LOW)

# 等待传感器稳定

time.sleep(0.5)

# 检查传感器是否就绪（DT引脚应为高电平）

# ready = self.GPIO.input(self.dt_pin)

# if ready:

# logger.warning("传感器未就绪，可能有重物压着")

self._is_initialized = True

self._is_ready = True

logger.info("HX711重量传感器初始化成功")

return True

except Exception as e:

logger.error(f"HX711传感器初始化失败: {e}")

return False

def _set_gain(self, gain: int):

"""设置增益"""

if gain == 128:

self._gain_channel = GainChannel.CHANNEL_A_GAIN_128

elif gain == 64:

self._gain_channel = GainChannel.CHANNEL_A_GAIN_64

elif gain == 32:

self._gain_channel = GainChannel.CHANNEL_B_GAIN_32

else:

raise ValueError(f"不支持的增益值: {gain}")

def _read_raw_value(self) -> Optional[int]:

"""

读取24位原始数据

HX711通信协议：

1. 等待DT引脚变低（数据准备好）

2. 发送24个时钟脉冲，在每个上升沿读取数据位

3. 发送额外的1-3个时钟脉冲选择下一次的增益通道

Returns:

Optional[int]: 24位原始数据（有符号）

"""

if not self._is_initialized:

logger.error("传感器未初始化")

return None

try:

if self._simulation_mode:

# 模拟数据：模拟不同重量和噪声

time.sleep(0.1)

# 模拟重量波动

weight_variation = random.uniform(-0.1, 0.1)

noise = random.uniform(-50, 50)

# 模拟一些日常场景

import math

time_factor = (time.time() % 60) / 60 # 0-1循环

# 模拟放书包（前5秒重量增加）

if time_factor < 0.08:

loading_progress = time_factor / 0.08

simulated_weight = self._simulation_base_weight * loading_progress

# 模拟稳定负重

elif time_factor < 0.85:

simulated_weight = self._simulation_base_weight + weight_variation

# 模拟减重（最后15秒）

else:

unloading_progress = (time_factor - 0.85) / 0.15

simulated_weight = self._simulation_base_weight * (1 - unloading_progress)

# 转换为原始ADC值

raw_value = int(simulated_weight * self._reference_unit * 1000) + noise

return raw_value

# 实际硬件读取

# import RPi.GPIO as GPIO

# 等待数据准备好（DT变低）

# timeout = 1000 # 超时计数

# while self.GPIO.input(self.dt_pin) and timeout > 0:

# time.sleep(0.001)

# timeout -= 1

#

# if timeout <= 0:

# logger.warning("等待数据就绪超时")

# return None

# 读取24位数据

# raw_data = 0

# for _ in range(24):

# self.GPIO.output(self.sck_pin, GPIO.HIGH)

# time.sleep(self.TIMING_CLOCK_HIGH / 1000000)

# raw_data = (raw_data << 1) | self.GPIO.input(self.dt_pin)

# self.GPIO.output(self.sck_pin, GPIO.LOW)

# time.sleep(self.TIMING_CLOCK_LOW / 1000000)

#

# # 选择下一个增益通道

# extra_clocks = self._gain_channel.value

# for _ in range(extra_clocks):

# self.GPIO.output(self.sck_pin, GPIO.HIGH)

# time.sleep(self.TIMING_CLOCK_HIGH / 1000000)

# self.GPIO.output(self.sck_pin, GPIO.LOW)

# time.sleep(self.TIMING_CLOCK_LOW / 1000000)

#

# # 转换补码（HX711输出是二进制补码）

# if raw_data & 0x800000:

# raw_data -= 0x1000000

#

# return raw_data

return int(random.uniform(1000, 50000))

except Exception as e:

logger.error(f"读取原始数据失败: {e}")

self._error_count += 1

if self._error_count >= self._max_errors:

logger.critical("传感器错误过多，进入保护模式")

self._is_initialized = False

return None

def read_weight(self, temperature: Optional[float] = None) -> Optional[WeightReading]:

"""

读取重量值

Args:

temperature: 环境温度（用于补偿）

Returns:

Optional[WeightReading]: 重量读数对象

"""

if not self._is_initialized:

logger.error("传感器未初始化")

return None

# 多次采样取平均

samples: List[float] = []

for _ in range(config.sensor.sample_count):

raw_value = self._read_raw_value()

if raw_value is None:

continue

# 减去零点偏移

adjusted_value = raw_value - self._offset

# 转换为重量

weight = adjusted_value / self._reference_unit / 1000.0 # 转换为kg

# 温度补偿

if temperature is not None:

weight = self._apply_temperature_compensation(weight, temperature)

# 限制范围

weight = max(config.min_weight, min(config.max_weight, weight))

samples.append(weight)

time.sleep(config.sensor.sample_interval)

if len(samples) < config.sensor.sample_count // 2:

logger.error("有效样本不足")

return None

# 计算平均重量

avg_weight = sum(samples) / len(samples)

# 应用数字滤波

filtered_weight = self._apply_filter(avg_weight)

# 计算数据质量

quality = self._calculate_data_quality(samples)

# 创建读数对象

reading = WeightReading(

timestamp=time.time(),

raw_value=int(sum(samples) / len(samples) * self._reference_unit * 1000),

weight_kg=round(filtered_weight, 3),

is_valid=quality > 0.5,

quality=quality,

temperature=temperature

)

self._last_reading = reading

self._readings_count += 1

logger.debug(

f"重量读数: 原始={reading.raw_value}, "

f"重量={filtered_weight:.3f}kg, 质量={quality:.2f}"

)

return reading

def _apply_temperature_compensation(self, weight: float, temperature: float) -> float:

"""

应用温度补偿

金属应变片受温度影响，需要补偿

Args:

weight: 原始重量

temperature: 当前温度

Returns:

float: 补偿后的重量

"""

if self._reference_temperature is None:

return weight

# 计算温度差

temp_diff = temperature - self._reference_temperature

# 温度补偿（系数需要根据实际传感器校准）

compensation_factor = 1.0 + (self._temperature_coefficient * temp_diff)

# 限制补偿范围

compensation_factor = max(0.95, min(1.05, compensation_factor))

compensated_weight = weight * compensation_factor

logger.debug(

f"温度补偿: 温度={temperature}°C, "

f"温差={temp_diff:.1f}°C, "

f"补偿系数={compensation_fa

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！