编写程序实现智能台灯定时关闭，设定一小时后，自动熄灭，防止熬夜忘关灯。
智能台灯定时关闭系统 - 健康作息守护者
一、实际应用场景描述
某智能家居品牌计划为年轻上班族和学生群体开发智能台灯产品，解决因专注工作或学习而忘记关灯导致的熬夜、电能浪费和健康问题。传统台灯仅具备手动开关功能，用户常常在深夜才发现灯光依然亮着，既影响睡眠质量，又造成不必要的电费支出。
本系统目标：在台灯内部集成环境光传感器、人体红外传感器和无线控制模块，允许用户设置定时关闭时间（默认1小时），当设定时间到达后自动熄灭台灯，并通过手机App推送和本地提示告知用户"该休息了"。系统还具备环境光自适应调光和人走灯灭功能，形成完整的健康照明解决方案。
二、引入痛点
痛点类型 具体表现 本方案解决方式
熬夜伤身 专注工作时忘记时间，熬夜到凌晨 定时自动关灯+休息提醒
电能浪费 人离开后灯一直亮着，或睡着后未关灯 人体感应+定时关闭双保险
操作繁琐 需要起身或找遥控器关灯 手机App远程控制+语音控制
光线不适 环境变亮时仍开强光，刺眼费眼 环境光自适应调光
缺乏规律 没有固定的休息时间提醒 可配置定时+渐进式提醒
三、核心逻辑讲解
graph TD
A[系统初始化] --> B[传感器校准与环境学习]
B --> C[用户设置定时时长]
C --> D[台灯开启，开始计时]
D --> E[持续监测环境状态]
E --> F{有人且环境较暗?}
F -- 是 --> G[保持台灯开启]
F -- 否 --> H[人走灯灭/环境光充足时关灯]
G --> I{定时时间到?}
I -- 否 --> E
I -- 是 --> J[启动渐暗关闭程序]
J --> K[10秒渐暗至熄灭]
K --> L[触发休息提醒]
L --> M[本地提示+App推送]
M --> N[记录使用情况]
N --> O[进入待机监测模式]
O --> P{检测到用户活动?}
P -- 是 --> Q[询问是否重新开启]
P -- 否 --> O
关键逻辑点：
1. 双传感器融合：人体红外(PIR)检测用户存在，环境光传感器判断是否需要照明
2. 定时器管理：使用多线程定时器，允许运行中动态调整定时时长
3. 渐进式关闭：10秒渐暗过程模拟日落效果，减少对眼睛的刺激
4. 多级提醒：本地LED闪烁+蜂鸣器+手机推送，确保用户注意到休息提醒
四、代码模块化实现
项目结构
smart_desk_lamp/
├── main.py # 主程序入口
├── config.py # 配置文件
├── sensors/ # 传感器模块
│ ├── __init__.py
│ ├── pir_sensor.py # 人体红外传感器
│ ├── light_sensor.py # 环境光传感器(BH1750)
│ └── button_sensor.py # 按键输入模块
├── lamp_control/ # 台灯控制模块
│ ├── __init__.py
│ ├── led_driver.py # LED调光驱动
│ └── pwm_controller.py # PWM调光控制器
├── timer/ # 定时器模块
│ ├── __init__.py
│ └── countdown_timer.py # 倒计时管理器
├── notifications/ # 通知模块
│ ├── __init__.py
│ ├── local_notifier.py # 本地提示系统
│ └── app_notifier.py # App推送服务
├── storage/ # 数据存储模块
│ ├── __init__.py
│ └── usage_logger.py # 使用日志记录
├── utils/ # 工具函数
│ ├── __init__.py
│ ├── brightness_curve.py # 亮度曲线算法
│ └── time_utils.py # 时间工具函数
└── tests/ # 单元测试
├── __init__.py
└── test_timer.py
1. 配置文件 (config.py)
"""
智能台灯定时关闭系统配置文件
包含传感器参数、定时设置、调光配置等
"""
# 系统基本信息
SYSTEM_NAME = "SmartDeskLamp"
SYSTEM_VERSION = "1.0.0"
DEVICE_ID = "DESK_LAMP_001"
# 传感器配置
PIR_SENSOR_PIN = 27 # 人体红外传感器信号引脚 (BCM编号)
PIR_DEBOUNCE_TIME = 0.5 # PIR传感器去抖动时间(秒)
LIGHT_SENSOR_ADDR = 0x23 # BH1750环境光传感器I2C地址
LIGHT_SENSOR_MODE = "CONTINUOUS_HIGH_RES_MODE" # 光照测量模式
BUTTON_PIN = 22 # 按键引脚（用于手动控制）
# 定时配置
DEFAULT_TIMER_MINUTES = 60 # 默认定时时长（分钟）- 1小时
MIN_TIMER_MINUTES = 5 # 最小定时时长
MAX_TIMER_MINUTES = 180 # 最大定时时长（3小时）
TIMER_WARNING_BEFORE = 300 # 定时结束前警告时间（秒）- 5分钟
GRADUAL_OFF_DURATION = 10 # 渐暗关闭持续时间（秒）
# 调光配置
DEFAULT_BRIGHTNESS = 80 # 默认亮度百分比 (0-100)
MIN_BRIGHTNESS = 10 # 最小亮度（夜间模式）
MAX_BRIGHTNESS = 100 # 最大亮度
AMBIENT_LIGHT_THRESHOLD = 50 # 环境光阈值（lux），低于此值开启灯光
DAYTIME_BRIGHTNESS_BOOST = 20 # 白天亮度加成
# PWM调光配置
PWM_FREQUENCY = 1000 # PWM频率（Hz）
PWM_CHANNEL = 0 # PWM通道
PWM_INVERT = False # PWM输出是否反转
# LED驱动配置
LED_RED_PIN = 12 # RGB LED红色通道
LED_GREEN_PIN = 13 # RGB LED绿色通道
LED_BLUE_PIN = 18 # RGB LED蓝色通道
LED_COUNT = 1 # LED数量
# 通知配置
ENABLE_LOCAL_NOTIFICATIONS = True # 启用本地提示
ENABLE_APP_NOTIFICATIONS = True # 启用App推送
LOCAL_ALERT_LED_PIN = 23 # 本地提示LED
LOCAL_ALERT_BUZZER_PIN = 24 # 本地提示蜂鸣器
APP_PUSH_SERVER = "https://api.push.example.com/v1/send"
USER_DEVICE_TOKEN = "user_device_token_here"
# 数据存储配置
USAGE_LOG_FILE = "lamp_usage.log"
SETTINGS_FILE = "lamp_settings.json"
MAX_LOG_ENTRIES = 10000
# 节能配置
AUTO_OFF_NO_MOTION_SECONDS = 300 # 无人时自动关闭时间（秒）- 5分钟
DO_NOT_DISTURB_START_HOUR = 22 # 免打扰开始时间（22:00）
DO_NOT_DISTURB_END_HOUR = 7 # 免打扰结束时间（07:00）
# 健康提醒配置
ENABLE_SLEEP_REMINDER = True # 启用睡眠提醒
SLEEP_REMINDER_HOUR = 23 # 睡眠提醒时间（23:00）
REMINDER_MESSAGE = "该休息了！为了保护视力，建议睡前1小时停止使用电子设备。"
# 调试配置
DEBUG_MODE = False # 调试模式
LOG_LEVEL = "INFO" # 日志级别
2. 人体红外传感器模块 (sensors/pir_sensor.py)
"""
人体红外(PIR)传感器模块
检测人体移动，用于判断用户是否在台灯前
"""
import RPi.GPIO as GPIO
import time
from threading import Lock
from config import PIR_SENSOR_PIN, PIR_DEBOUNCE_TIME
class PIRSensor:
def __init__(self):
"""初始化人体红外传感器"""
self.pin = PIR_SENSOR_PIN
self.last_motion_time = 0
self.motion_detected = False
self.lock = Lock()
self.callback = None
self.running = False
self._motion_count = 0
self._last_callback_time = 0
self._setup_gpio()
print(f"✅ 人体红外传感器初始化成功")
print(f" 引脚: GPIO{PIR_SENSOR_PIN}")
print(f" 去抖动时间: {PIR_DEBOUNCE_TIME}秒")
def _setup_gpio(self):
"""配置GPIO为输入模式"""
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.pin, GPIO.IN)
# 添加事件检测，上升沿触发（检测到运动）
GPIO.add_event_detect(
self.pin, GPIO.RISING,
callback=self._motion_callback,
bouncetime=int(PIR_DEBOUNCE_TIME * 1000)
)
def _motion_callback(self, channel):
"""运动检测回调函数"""
current_time = time.time()
with self.lock:
self.last_motion_time = current_time
self.motion_detected = True
self._motion_count += 1
# 触发用户注册的回调
if self.callback and (current_time - self._last_callback_time > 0.1):
self.callback(True)
self._last_callback_time = current_time
def set_callback(self, callback_func):
"""设置运动检测回调函数"""
self.callback = callback_func
def is_motion_detected(self) -> bool:
"""检查是否有运动检测到"""
with self.lock:
# 检查是否在有效时间内（PIR传感器会持续输出一段时间）
if self.motion_detected:
if time.time() - self.last_motion_time > 5: # 5秒后认为运动结束
self.motion_detected = False
return self.motion_detected
def get_last_motion_time(self) -> float:
"""获取最后一次检测到运动的时间戳"""
with self.lock:
return self.last_motion_time
def get_time_since_last_motion(self) -> float:
"""获取距离最后一次运动的秒数"""
return time.time() - self.last_motion_time
def wait_for_motion(self, timeout: float = None) -> bool:
"""
等待检测到运动
timeout: 超时时间（秒），None表示无限等待
返回: 检测到运动返回True，超时返回False
"""
start_time = time.time()
while True:
if self.is_motion_detected():
return True
if timeout and (time.time() - start_time > timeout):
return False
time.sleep(0.1)
def reset_motion_state(self):
"""重置运动状态"""
with self.lock:
self.motion_detected = False
self._motion_count = 0
def get_motion_count(self) -> int:
"""获取本次会话的运动计数"""
with self.lock:
return self._motion_count
def get_sensor_status(self) -> dict:
"""获取传感器状态信息"""
return {
"pin": self.pin,
"motion_detected": self.is_motion_detected(),
"last_motion_time": self.last_motion_time,
"time_since_motion": self.get_time_since_last_motion(),
"motion_count": self._motion_count
}
def cleanup(self):
"""清理传感器资源"""
GPIO.remove_event_detect(self.pin)
GPIO.cleanup(self.pin)
3. 环境光传感器模块 (sensors/light_sensor.py)
"""
BH1750环境光传感器模块
I2C接口，测量环境光照强度（单位：lux）
"""
import smbus2
import time
from config import LIGHT_SENSOR_ADDR, LIGHT_SENSOR_MODE
class LightSensor:
# BH1750指令集
CMD_POWER_ON = 0x01
CMD_POWER_DOWN = 0x00
CMD_RESET = 0x07
# 测量模式
MODE_CONTINUOUS_HIGH_RES = 0x10 # 连续高分辨率模式 (1 lux精度)
MODE_CONTINUOUS_HIGH_RES_2 = 0x11 # 连续高分辨率模式2 (0.5 lux精度)
MODE_CONTINUOUS_LOW_RES = 0x13 # 连续低分辨率模式 (4 lux精度)
MODE_ONE_TIME_HIGH_RES = 0x20 # 单次高分辨率模式
MODE_ONE_TIME_HIGH_RES_2 = 0x21 # 单次高分辨率模式2
MODE_ONE_TIME_LOW_RES = 0x23 # 单次低分辨率模式
def __init__(self):
"""初始化环境光传感器"""
self.bus = smbus2.SMBus(1) # I2C总线1
self.address = LIGHT_SENSOR_ADDR
self.mode = self.MODE_CONTINUOUS_HIGH_RES
self.last_reading = 0
self.last_read_time = 0
# 根据配置选择模式
self._select_mode()
# 启动传感器
self._power_on()
# 首次读取
time.sleep(0.2) # 等待传感器稳定
self._read_light()
print(f"✅ BH1750环境光传感器初始化成功")
print(f" 地址: 0x{LIGHT_SENSOR_ADDR:02X}")
print(f" 当前光照: {self.last_reading:.1f} lux")
def _select_mode(self):
"""根据配置选择测量模式"""
mode_map = {
"CONTINUOUS_HIGH_RES_MODE": self.MODE_CONTINUOUS_HIGH_RES,
"CONTINUOUS_HIGH_RES_MODE_2": self.MODE_CONTINUOUS_HIGH_RES_2,
"CONTINUOUS_LOW_RES_MODE": self.MODE_CONTINUOUS_LOW_RES,
"ONE_TIME_HIGH_RES_MODE": self.MODE_ONE_TIME_HIGH_RES,
}
self.mode = mode_map.get(LIGHT_SENSOR_MODE, self.MODE_CONTINUOUS_HIGH_RES)
def _power_on(self):
"""唤醒传感器"""
try:
self.bus.write_byte(self.address, self.CMD_POWER_ON)
time.sleep(0.01)
except IOError as e:
print(f"传感器唤醒失败: {e}")
def _power_down(self):
"""关闭传感器电源（节能）"""
try:
self.bus.write_byte(self.address, self.CMD_POWER_DOWN)
except IOError:
pass
def _reset(self):
"""重置传感器"""
try:
self.bus.write_byte(self.address, self.CMD_RESET)
time.sleep(0.01)
except IOError:
pass
def _read_light(self) -> float:
"""
读取光照强度值
返回: 光照强度（lux）
"""
try:
# 发送测量命令
self.bus.write_byte(self.address, self.mode)
# 等待测量完成
if self.mode in [self.MODE_CONTINUOUS_HIGH_RES,
self.MODE_CONTINUOUS_HIGH_RES_2,
self.MODE_CONTINUOUS_LOW_RES]:
measurement_time = 0.12 # 高分辨率模式120ms
else:
measurement_time = 0.18 # 单次模式180ms
time.sleep(measurement_time)
# 读取2字节数据
data = self.bus.read_i2c_block_data(self.address, 0x00, 2)
# 计算光照值
# 高分辨率模式: 1 lux/LSB
# 高分辨率模式2: 0.5 lux/LSB
if self.mode == self.MODE_CONTINUOUS_HIGH_RES_2:
light_level = ((data[0] << 8) | data[1]) / 1.2
else:
light_level = (data[0] << 8) | data[1]
# 数据有效性检查
if 0 <= light_level <= 65535:
self.last_reading = light_level
self.last_read_time = time.time()
return light_level
else:
return self.last_reading # 返回上次有效读数
except IOError as e:
print(f"读取光照失败: {e}")
return self.last_reading
def get_light_level(self) -> float:
"""获取当前光照强度"""
return self._read_light()
def get_light_category(self) -> str:
"""获取光照类别描述"""
lux = self.last_reading
if lux < 10:
return "非常暗"
elif lux < 50:
return "昏暗"
elif lux < 200:
return "室内普通照明"
elif lux < 500:
return "明亮室内"
elif lux < 1000:
return "阳光直射室内"
elif lux < 10000:
return "阴天室外"
else:
return "晴天室外"
def is_dark_environment(self, threshold: float = None) -> bool:
"""判断是否为黑暗环境"""
if threshold is None:
threshold = 50 # 默认阈值50 lux
return self.last_reading < threshold
def get_sensor_status(self) -> dict:
"""获取传感器状态信息"""
return {
"address": hex(self.address),
"mode": hex(self.mode),
"light_level": round(self.last_reading, 2),
"light_category": self.get_light_category(),
"is_dark": self.is_dark_environment(),
"last_read_time": self.last_read_time
}
def cleanup(self):
"""清理传感器资源"""
self._power_down()
self.bus.close()
4. PWM调光控制器模块 (lamp_control/pwm_controller.py)
"""
PWM调光控制器模块
通过PCA9685 PWM控制器精确控制LED亮度
"""
import smbus2
import time
from config import PWM_FREQUENCY, PWM_CHANNEL, PWM_INVERT
class PWMController:
# PCA9685寄存器地址
MODE1 = 0x00
MODE2 = 0x01
SUBADR1 = 0x02
SUBADR2 = 0x03
SUBADR3 = 0x04
PRESCALE = 0xFE
LED0_ON_L = 0x06
LED0_ON_H = 0x07
LED0_OFF_L = 0x08
LED0_OFF_H = 0x09
def __init__(self):
"""初始化PWM控制器"""
self.bus = smbus2.SMBus(1)
self.address = 0x40 # PCA9685默认地址
self.frequency = PWM_FREQUENCY
self.channels = {}
self._initialize_pca9685()
print(f"✅ PWM控制器初始化成功")
print(f" 地址: 0x{self.address:02X}")
print(f" 频率: {PWM_FREQUENCY} Hz")
def _initialize_pca9685(self):
"""初始化PCA9685芯片"""
try:
# 复位并设置睡眠模式以配置频率
self.bus.write_byte_data(self.address, self.MODE1, 0x00)
time.sleep(0.005)
# 设置预分频器以获得所需频率
prescale_val = int(25000000.0 / (4096 * self.frequency)) - 1
prescale_val = max(3, min(255, prescale_val)) # 限制范围
# 进入睡眠模式
self.bus.write_byte_data(self.address, self.MODE1, 0x10)
# 设置预分频器
self.bus.write_byte_data(self.address, self.PRESCALE, prescale_val)
# 退出睡眠模式
self.bus.write_byte_data(self.address, self.MODE1, 0x00)
time.sleep(0.005)
# 设置MODE2寄存器（输出驱动模式）
mode2_val = 0x04 if PWM_INVERT else 0x00 # OUTDRV = 1 (totem pole)
self.bus.write_byte_data(self.address, self.MODE2, mode2_val)
print(f" PWM频率配置完成: {self.frequency} Hz")
except IOError as e:
print(f"PCA9685初始化失败: {e}")
raise
def set_pwm_channel(self, channel: int, on: int, off: int):
"""
设置单个PWM通道的输出
channel: 通道号 (0-15)
on: LED开启时间点 (0-4095)
off: LED关闭时间点 (0-4095)
"""
if not 0 <= channel <= 15:
raise ValueError(f"无效的通道号: {channel}")
if not 0 <= on <= 4095:
raise ValueError(f"无效的ON值: {on}")
if not 0 <= off <= 4095:
raise ValueError(f"无效的OFF值: {off}")
try:
self.bus.write_byte_data(self.address, self.LED0_ON_L + 4 * channel, on & 0xFF)
self.bus.write_byte_data(self.address, self.LED0_ON_H + 4 * channel, on >> 8)
self.bus.write_byte_data(self.address, self.LED0_OFF_L + 4 * channel, off & 0xFF)
self.bus.write_byte_data(self.address, self.LED0_OFF_H + 4 * channel, off >> 8)
self.channels[channel] = {"on": on, "off": off}
except IOError as e:
print(f"设置PWM通道{channel}失败: {e}")
def set_brightness(self, channel: int, brightness: float):
"""
设置指定通道的亮度
channel: 通道号 (0-15)
brightness: 亮度百分比 (0.0-100.0)
"""
brightness = max(0.0, min(100.0, brightness))
if brightness <= 0:
# 完全关闭
self.set_pwm_channel(channel, 0, 4096)
elif brightness >= 100:
# 完全打开
self.set_pwm_channel(channel, 0, 4095)
else:
# 计算OFF值
off_value = int(4095 * brightness / 100.0)
self.set_pwm_channel(channel, 0, off_value)
print(f"通道{channel}亮度设置为: {brightness:.1f}%")
def gradual_dim(self, channel: int, from_brightness: float,
to_brightness: float, duration: float):
"""
渐变调光
channel: 通道号
from_brightness: 起始亮度
to_brightness: 目标亮度
duration: 渐变持续时间（秒）
"""
steps = 50 # 渐变步数
step_time = duration / steps
brightness_step = (to_brightness - from_brightness) / steps
print(f"开始渐变调光: {from_brightness:.1f}% → {to_brightness:.1f}% ({duration}秒)")
for i in range(steps + 1):
current_brightness = from_brightness + brightness_step * i
self.set_brightness(channel, current_brightness)
time.sleep(step_time)
print(f"渐变调光完成")
def turn_off_all_channels(self):
"""关闭所有PWM通道"""
for channel in range(16):
self.set_pwm_channel(channel, 0, 4096)
print("所有PWM通道已关闭")
def get_channel_status(self, channel: int) -> dict:
"""获取指定通道的状态"""
if channel in self.channels:
return self.channels[channel].copy()
return {"on": 0, "off": 4096}
def cleanup(self):
"""清理PWM控制器资源"""
self.turn_off_all_channels()
self.bus.close()
5. 倒计时定时器模块 (timer/countdown_timer.py)
"""
倒计时定时器模块
管理台灯的定时关闭功能，支持动态调整和渐进式关闭
"""
import threading
import time
from datetime import datetime, timedelta
from config import (
DEFAULT_TIMER_MINUTES, MIN_TIMER_MINUTES, MAX_TIMER_MINUTES,
TIMER_WARNING_BEFORE, GRADUAL_OFF_DURATION
)
class CountdownTimer:
def __init__(self, callback=None):
"""
初始化倒计时定时器
callback: 定时器到期时的回调函数
"""
self.duration_seconds = DEFAULT_TIMER_MINUTES * 60
self.remaining_seconds = self.duration_seconds
self.callback = callback
self.timer_thread = None
self.warning_thread = None
self.is_running = False
self.is_paused = False
self.start_time = None
self.pause_time = None
self.warning_triggered = False
self.gradual_off_active = False
self.timer_lock = threading.Lock()
print(f"✅ 倒计时定时器初始化成功")
print(f" 默认时长: {DEFAULT_TIMER_MINUTES}分钟")
print(f" 警告提前: {TIMER_WARNING_BEFORE}秒")
print(f" 渐暗时长: {GRADUAL_OFF_DURATION}秒")
def start(self, duration_minutes: int = None):
"""
启动倒计时
duration_minutes: 定时时长（分钟），None使用默认值
"""
with self.timer_lock:
# 停止现有定时器
self.stop()
# 设置时长
if duration_minutes is not None:
duration_minutes = max(MIN_TIMER_MINUTES,
min(MAX_TIMER_MINUTES, duration_minutes))
self.duration_seconds = duration_minutes * 60
self.remaining_seconds = self.duration_seconds
self.is_running = True
self.is_paused = False
self.warning_triggered = False
self.gradual_off_active = False
self.start_time = time.time()
# 启动定时器线程
self.timer_thread = threading.Thread(target=self._timer_loop, daemon=True)
self.timer_thread.start()
# 启动警告检查线程
self.warning_thread = threading.Thread(target=self._warning_check_loop, daemon=True)
self.warning_thread.start()
print(f"⏱️ 定时器启动，时长: {self.duration_seconds//60}分钟")
def stop(self):
"""停止倒计时"""
with self.timer_lock:
self.is_running = False
self.is_paused = False
if self.timer_thread:
self.timer_thread.join(timeout=1.0)
if self.warning_thread:
self.warning_thread.join(timeout=1.0)
print("⏹️ 定时器已停止")
def pause(self):
"""暂停倒计时"""
with self.timer_lock:
if self.is_running and not self.is_paused:
self.is_paused = True
self.pause_time = time.time()
print("⏸️ 定时器已暂停")
def resume(self):
"""恢复倒计时"""
with self.timer_lock:
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！