1
/data/
2
├── code/
3
│   ├── photo/
4
│   │   └── img_top.jpg          # 主界面背景图（800×480）
5
│   ├── music/
6
│   │   └── *.wav                # WAV音乐文件
7
│   ├── picture/
8
│   │   ├── photo_*.jpg          # 相机拍摄的照片
9
│   │   └── painting_*.jpg       # 画板保存的图片
10
│   ├── audio/
11
│   │   └── rec_*.wav            # 录音机录制的音频
12
│   ├── doc/
13
│   │   ├── *.txt                # 小说TXT文件
14
│   │   └── doc_read.txt         # 阅读进度（自动生成）
15
│   ├── video/
16
│   │   └── new.mp4              # 测试视频
17
│   ├── setup/
18
│   │   ├── setup.png            # 启动画面图片
19
│   │   └── setup.wav            # 启动画面音频
20
│   └── font/                    # 字体文件（可选）

1
主界面 → 30秒无操作 → deinit_home() → stby.main() → 点击唤醒 → init_home() → show_image()

1
import setup
2
import test_touch
3

4
if __name__ == "__main__":
5
    setup.main()                # ① 先运行启动画面
6
    test_touch.touch_main()     # ② 再进入主界面

1
_amp_inited = False
2
def init_amp():
3
    global _amp_inited, HT_CTRL
4
    if not _amp_inited:                    # FPIOA 只执行一次
5
        fpioa = FPIOA()
6
        fpioa.set_function(AMP_PIN, FPIOA.GPIO10)
7
        _amp_inited = True
8
    HT_CTRL = Pin(AMP_PIN, Pin.OUT, pull=Pin.PULL_NONE, drive=7)
9
    HT_CTRL.high()                         # 拉高使能功放

1
_tap_times = []
2
_last_press_time = 0
3
_touch_was_pressed = False
4
DEBOUNCE_MS = 150
5

6
def check_skip(tp):
7
    now = time.ticks_ms()
8
    _tap_times = [t for t in _tap_times
9
                  if time.ticks_diff(now, t) < TAP_WINDOW_MS]  # 清理过期记录
10
    points = tp.read(5)
11
    if points:
12
        if not _touch_was_pressed:                              # 上升沿检测
13
            if time.ticks_diff(now, _last_press_time) > DEBOUNCE_MS:  # 消抖
14
                _tap_times.append(now)
15
            _touch_was_pressed = True
16
    else:
17
        _touch_was_pressed = False
18
    return len(_tap_times) >= TAP_COUNT   # 达到点击次数则跳过

1
def play_wav_skippable(filepath, tp):
2
    wf = wave.open(filepath, 'rb')
3
    chunk = int(framerate / 25)             # 每块 40ms 音频
4
    p = PyAudio()
5
    stream = p.open(output=True, frames_per_buffer=chunk)
6
    stream.volume(vol=100)
7

8
    data = wf.read_frames(chunk)
9
    while data:
10
        for _ in range(2):                  # 每次写 2 块
11
            if data:
12
                stream.write(data)
13
                data = wf.read_frames(chunk)
14
        if check_skip(tp):                  # 每 2 块检查一次跳过
15
            break

1
def main():
2
    init_amp()                              # 使能功放
3
    Display.init(Display.ST7701, ...)       # 初始化显示屏
4
    MediaManager.init()                     # 初始化媒体管线
5
    tp = TOUCH(0)                           # 初始化触摸
6
    show_setup_image()                      # 显示图片
7
    play_wav_skippable(SETUP_WAV, tp)       # 播放音频（可跳过）
8
    # ... finally: Display.deinit() → MediaManager.deinit() → deinit_amp()

1
ICON_AREAS = (
2
    ("相机图标",       42,  90,  160, 240),
3
    ("音乐播放器图标", 193, 90,  311, 240),
4
    ("WiFi配网图标",   344, 90,  462, 240),
5
    ("相册图标",       495, 90,  612, 240),
6
    ("天气预报图标",   645, 90,  763, 240),
7
    ("小说阅读器图标", 42,  267, 160, 417),
8
    ("录音机图标",     193, 267, 311, 417),
9
    ("画板图标",       344, 267, 462, 417),
10
    ("云平台监控图标", 495, 267, 612, 417),
11
    ("系统设置图标",   645, 267, 763, 417),
12
)

1
_shared_tp = None   # 全局触摸单例
2
def init_home():
3
    global _shared_tp
4
    Display.init(Display.ST7701, width=800, height=480, to_ide=True)
5
    MediaManager.init()
6
    if _shared_tp is None:
7
        _shared_tp = TOUCH(0)     # 全局只创建一次
8
    return _shared_tp

1
def deinit_home():
2
    Display.deinit()
3
    time.sleep_ms(80)        # 等显示管线完全释放
4
    MediaManager.deinit()
5
    time.sleep_ms(50)        # 等媒体管线完全释放

1
last_activity = time.ticks_ms()
2

3
while True:
4
    now = time.ticks_ms()
5
    # 检测超时
6
    if time.ticks_diff(now, last_activity) > stby.STANDBY_TIMEOUT * 1000:
7
        deinit_home()
8
        stby.main()              # 进入待机
9
        tp = init_home()         # 唤醒后重新初始化主界面
10
        show_image()
11
        update_status_bar()
12
        last_activity = time.ticks_ms()  # 重置计时器
13

14
    if points != ():
15
        last_activity = now      # 有触摸即刷新活动时间

1
def update_status_bar():
2
    """右上角 OSD1：时间(HH:MM) + WiFi 图标"""
3
    clock_time.draw_time_wifi_overlay(mywificon.draw_icon, x=690, y=6)

1
_fpioa_done = False
2
_shared_tp = None
3

4
def init_player_hardware():
5
    global _fpioa_done, _shared_tp
6
    if not _fpioa_done:
7
        fpioa = FPIOA()
8
        fpioa.set_function(10, FPIOA.GPIO10)
9
        _fpioa_done = True        # FPIOA 只初始化一次
10
    ...
11
    if _shared_tp is None:
12
        _shared_tp = TOUCH(0)     # TOUCH 只创建一次
13
    tp = _shared_tp

1
def audio_play_chunk():
2
    chunks_per_frame = 3
3
    for _ in range(chunks_per_frame):
4
        data = audio_wf.read_frames(audio_chunk_size)
5
        if data:
6
            audio_stream.write(data)

1
def audio_seek(ratio):
2
    target = int(audio_total_frames * ratio)
3
    audio_wf.close()
4
    audio_wf = wave.open(audio_filepath, 'rb')
5
    skipped = 0
6
    while skipped < target:
7
        audio_wf.read_frames(audio_chunk_size)  # 跳过不需要的帧
8
        skipped += audio_chunk_size

1
def apply_theme(dark=True):
2
    global C_BG_TOP, C_BG_BOT, C_PANEL, ...  # 所有颜色变量
3
    if dark:
4
        C_BG_TOP = (18, 38, 70)      # 深蓝
5
        ...
6
    else:
7
        C_BG_TOP = (238, 242, 248)   # 浅灰
8
        ...

1
sensor = Sensor(id=2)                       # CSI-2 摄像头
2
sensor.reset()                              # 硬件复位
3
sensor.set_framesize(width=800, height=480) # 匹配屏幕分辨率
4
sensor.set_pixformat(Sensor.RGB565)         # RGB565 格式
5
sensor.run()                                # 开始采集

1
def save_photo(img, filename):
2
    data = img.compress(quality=95)          # JPEG 压缩
3
    with open(filename, "wb") as f:
4
        f.write(data)
5

6
def handle_touch(points):
7
    ...
8
    if in_rect(x, y, ...):                  # 点击拍照按钮
9
        photo_count += 1
10
        filename = get_next_name()           # photo_00001.jpg
11
        save_photo(img, filename)
12
        beep()                               # 蜂鸣器响一声

1
_fpioa_done = False
2
def beep_init():
3
    global _beep_pwm, _fpioa_done
4
    if not _fpioa_done:
5
        fpioa = FPIOA()
6
        fpioa.set_function(61, FPIOA.PWM1)  # GPIO61 → PWM1
7
        _fpioa_done = True
8
    _beep_pwm = PWM(1)
9
    _beep_pwm.freq(4000)                     # 4kHz 频率
10

11
def beep():
12
    _beep_pwm.duty_u16(32768)                # 50% 占空比
13
    time.sleep_ms(80)                        # 响 80ms
14
    _beep_pwm.duty_u16(0)                    # 关闭

1
def rec_start():
2
    _rec_chunk = int(44100 / 25)             # 每块 1764 采样点
3
    _rec_p = PyAudio()
4
    _rec_stream = _rec_p.open(
5
        format=paInt16, channels=1, rate=44100,
6
        input=True, frames_per_buffer=_rec_chunk)
7

8
def rec_update():
9
    data = _rec_stream.read()                # 读取一个音频块
10
    _rec_frames.append(data)                 # 存入缓冲区
11
    rec_elapsed_ms = int(_rec_frame_count * _rec_chunk / 44100 * 1000)
12
    if rec_elapsed_ms >= MAX_REC_SEC * 1000:
13
        rec_stop()                           # 达到最大时长自动停止

1
def rec_stop():
2
    wf = wave.open(filename, 'wb')
3
    wf.set_channels(1)
4
    wf.set_sampwidth(_rec_p.get_sample_size(paInt16))
5
    wf.set_framerate(44100)
6
    wf.write_frames(b''.join(_rec_frames))   # 拼接所有块写入
7
    wf.close()
8
    _rec_p.terminate()                       # 释放 PyAudio

1
_play_should_stop = False
2

3
def play_request_stop():
4
    """触摸回调中只设标志"""
5
    _play_should_stop = True
6

7
def play_do_stop():
8
    """在 play_update 中安全关闭"""
9
    if not _play_should_stop: return
10
    _play_wf.close()                         # 先关文件
11
    _play_stream.stop_stream()               # 停流
12
    _play_stream.close()                     # 关流
13
    time.sleep_ms(30)                        # 等 DMA 释放
14
    _play_p.terminate()                      # 最后关 PyAudio

1
def draw_fullscreen():
2
    # OSD0 底层：照片
3
    photo = image.Image(filepath)
4
    Display.show_image(photo.to_rgb565(), layer=Display.LAYER_OSD0)
5

6
    # OSD1 顶层：UI 覆盖层
7
    ui = image.Image(800, 480, image.ARGB8888)
8
    ui.clear()                                 # 透明底色
9
    ui.draw_rectangle(0, 0, 800, 44, color=(0,0,0,180), fill=True)  # 半透明条
10
    ui.draw_string_advanced(...)               # 文件名、序号、按钮
11
    Display.show_image(ui, layer=Display.LAYER_OSD1)

1
def reset_touch_state():
2
    global _touch_pressed, _debounce_until
3
    _touch_pressed = False
4
    _debounce_until = 0

1
if last_point is not None:
2
    dx = x - last_point.x
3
    dy = y - last_point.y
4
    dist = (dx*dx + dy*dy) ** 0.5
5
    if dist <= 30:                             # 距离合理才连线
6
        steps = max(1, int(dist // 8))
7
        for i in range(1, steps+1):           # 在两点间插值
8
            nx = int(last_point.x + i * dx / (steps+1))
9
            ny = int(last_point.y + i * dy / (steps+1))
10
            canvas.draw_circle(nx, ny, brush_size, ...)

1
def handle_touch(points):
2
    actions = []                               # 用列表收集动作
3
    ...
4
    if in_rect(x, y, *CLEAR_BTN):
5
        return ('clear',)                      # 返回元组
6
    ...
7
    actions.append(('draw', x, y))
8
    return ('draw', actions) if actions else None

1
def start_ap():
2
    _ap = network.WLAN(network.AP_IF)          # AP 模式
3
    _ap.active(True)
4
    _ap.config(ssid="LushanPi-Config", key="12345678")
5
    _ap_ip = _ap.ifconfig()[0]                 # 通常 192.168.4.1
6

7
def start_server():
8
    _server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
9
    _server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
10
    _server.bind(('0.0.0.0', 80))              # 监听 80 端口
11
    _server.listen(1)
12
    _server.settimeout(0.3)                    # 非阻塞超时 300ms

1
def handle_http():
2
    try:
3
        conn, addr = _server.accept()          # 接受连接
4
        req = conn.recv(1024)                  # 读取请求
5
        if b"POST /connect" in req:            # 表单提交
6
            body = req.split(b"\r\n\r\n")[1]  # 提取 POST body
7
            ssid, pwd = parse_form(body)       # 解析 SSID 和密码
8
            conn.send(ok_page)                 # 返回成功页面
9
            return True                        # 通知主循环
10
        else:                                  # GET /
11
            conn.send(config_page)             # 返回配网页面
12
    except OSError:
13
        pass                                   # 超时，无连接

1
raw = w.ssid
2
ssid = raw.decode() if isinstance(raw, bytes) else str(raw)

1
def fetch_weather():
2
    r = urequest.urlopen(WEATHER_URL)            # HTTPS GET
3
    text = r.read(40000).decode('utf-8')         # 读取网页
4
    match = re.search(r'var observe24h_data = (.*?);', text)
5
    if match:
6
        data = json.loads(match.group(1))
7
        weather[0] = CITY_NAME
8
        weather[1] = str(data['od']['od2'][0]['od22'])  # 温度
9
        weather[2] = str(data['od']['od2'][0]['od27'])  # 湿度
10
        weather[3] = str(data['od']['od2'][0]['od24'])  # 风向
11
        weather[4] = str(data['od']['od2'][0]['od28'])  # 空气质量

1
def zero_str(n):
2
    num = int(n)
3
    return "0" + str(num) if 0 < num < 10 else str(num)

1
while True:
2
    points = tp.read(5)       # 检测触摸
3
    if points:
4
        if not pressed:
5
            break              # 任意触摸 → 退出循环 → 返回主界面
6
        pressed = True
7
    else:
8
        pressed = False
9
    # 绘制待机界面
10
    img = image.Image(800, 480, image.ARGB8888)
11
    draw_standby(img)
12
    Display.show_image(img)
13
    time.sleep_ms(200)

1
import stby                     # 导入待机模块
2

3
def main():
4
    timeout = stby.STANDBY_TIMEOUT   # 读取当前配置
5
    ...
6
    # 调整
7
    if 点击减号 and timeout > 10:
8
        timeout -= 5
9
    if 点击加号 and timeout < 60:
10
        timeout += 5
11
    # 保存
12
    stby.STANDBY_TIMEOUT = timeout   # 写回模块变量

1
CHARS_PER_LINE = 680 // 18  # ≈37 字符/行
2
LINES_PER_PAGE = 410 // 22  # ≈18 行/页
3

4
def split_pages(text):
5
    lines = []
6
    for paragraph in text.split('\n'):
7
        para = paragraph.rstrip()
8
        while len(para) > 0:
9
            lines.append(para[:CHARS_PER_LINE])  # 截断超长行
10
            para = para[CHARS_PER_LINE:]
11
    # 按每页行数分页
12
    for i in range(0, len(lines), LINES_PER_PAGE):
13
        pages.append(lines[i:i+LINES_PER_PAGE])
14
    return pages

1
def read_file_text(filepath):
2
    data = open(filepath, 'rb').read()
3
    if data[:3] == b'\xef\xbb\xbf':    # UTF-8 BOM
4
        data = data[3:]
5
    try: return data.decode('utf-8')
6
    except: pass
7
    try: return data.decode('gbk')     # 中文 Windows 常用编码
8
    except: pass
9
    return data.decode('utf-8', 'ignore')  # 最终回退

1
def save_progress(filename, page, total):
2
    prog = load_progress()                   # 读取所有进度
3
    prog[filename] = page                    # 更新当前文件
4
    with open(PROGRESS_FILE, 'w') as f:
5
        for fn, pg in prog.items():
6
            f.write(fn + "=" + str(pg) + "\n")

1
last_page = -1
2
while True:
3
    ...
4
    if screen == 'reading':
5
        if page_changed or last_page != cur_page:
6
            img = image.Image(...)
7
            draw_reading(img, cur_novel, pages, cur_page)
8
            Display.show_image(img)
9
            last_page = cur_page
10
        time.sleep_ms(30)          # 仅 30ms 循环
11
    else:
12
        ...
13
        time.sleep_ms(80)          # 网格界面 80ms 循环

1
def sync_time():
2
    import ntptime
3
    ntptime.settime()              # 同步 RTC

1
def draw_time_wifi_overlay(wifi_icon_drawer, x, y):
2
    img = image.Image(100, 32, image.ARGB8888)
3
    img.clear()
4
    img.draw_string_advanced(4, 6, 18, get_time_str(), color=(255,255,255))
5
    wifi_icon_drawer(img, 68, 5)    # 委托 mywificon 绘制 WiFi 图标
6
    Display.show_image(img, x=x, y=y, layer=Display.LAYER_OSD1)

1
def time():
2
    NTP_QUERY = bytearray(48)
3
    NTP_QUERY[0] = 0x1B                         # NTP 请求标识
4
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # UDP
5
    s.sendto(NTP_QUERY, addr)
6
    msg = s.recv(48)
7
    val = struct.unpack("!I", msg[40:44])[0]    # 解析 32 位时间戳
8
    if val < 3913056000:                        # Y2036 修复
9
        val += 0x100000000                      # 加 2^32
10
    return val - 2208988800                     # NTP → Unix 时间戳

1
def urlopen(url, data=None, method="GET"):
2
    proto, dummy, host, path = url.split("/", 3)  # 解析 URL
3
    port = 80 if proto == "http:" else 443        # 端口
4
    ai = socket.getaddrinfo(host, port)[0]         # DNS 解析
5
    s = socket.socket(ai[0], ai[1], ai[2])         # TCP 连接
6
    s.connect(ai[-1])
7
    if proto == "https:":
8
        s = ssl.wrap_socket(s)                     # SSL 加密
9
    s.write(method + " /" + path + " HTTP/1.0\r\n...")
10
    return s                                       # 返回 socket 供 read()