Mouse_Plan/
|-- main.cpp                         # Qt 应用入口
|-- mainwindow.h                     # MainWindow 类声明
|-- mainwindow.cpp                   # MainWindow 壳文件（实现已迁移到 modules）
|-- mainwindow.ui                    # Qt Designer UI 文件
|-- appdata.h                        # 数据模型与存储接口
|-- appdata.cpp                      # 本地存储与 JSON 序列化
|-- img.qrc                          # Qt 资源索引
|-- Mouse_Plan_2.pro                 # qmake 项目文件
|-- Mouse_Plan_2.pro.user            # Qt Creator 本地用户配置
|-- Mouse_Plan_2.code-workspace      # VS Code 工作区文件
|-- README.md                        # 项目架构文档
|-- .vscode/                         # 本地编辑器配置
|-- config/                          # 全局相关的配置文件
|-- img/                             # 图片资源
|-- android/                         # Android 打包配置--略

|
|-- modules/                                            # 分层应用代码（按 common/themes/ui 拆分）
|   |-- common/                                         # 跨主题通用能力层
|   |   |-- agreement/                                  # 协议文本加载与模式切换（本地/在线）
|   |   |   |-- agreement_text_loader.h                 # 协议加载器接口
|   |   |   \-- agreement_text_loader.cpp               # 协议文件读取与回退逻辑实现
|   |   |-- config/                                     # 公共配置常量
|   |   |   \-- network_config.h                        # 网络地址与接口配置常量
|   |   |-- theme/                                      # 主题策略与可用性控制
|   |   |   |-- theme_feature_gate.h                    # 主题开关/可用性判断接口
|   |   |   |-- theme_feature_gate.cpp                  # 主题可用性拦截实现
|   |   |   |-- theme_strategy_factory.h                # 主题策略工厂接口
|   |   |   \-- theme_strategy_factory.cpp              # 主题策略分发与构建实现
|   |   |-- ui/                                         # 公共 UI 构建与弹窗工具
|   |   |   |-- common_ui_pages.cpp                     # 通用页面片段创建
|   |   |   |-- runtime_dialog_helpers.h                # 运行时弹窗工具接口
|   |   |   \-- runtime_dialog_helpers.cpp              # 运行时弹窗工具实现
|   |   \-- update/                                     # 应用更新辅助能力
|   |       |-- update_client_helper.h                  # 更新客户端接口
|   |       \-- update_client_helper.cpp                # 更新检查与下载辅助实现
|   |           
|   |-- themes/                                         # 主题业务层（按主题拆分）
|   |   \-- fitness/                                    # 健身主题业务
|   |       |-- calendar/                               # 日历标记与日期展示
|   |       |   |-- fitness_calendar_mark_builder.h     # 日历标记构建接口
|   |       |   \-- fitness_calendar_mark_builder.cpp   # 日历训练/休息标记生成
|   |       |-- data/                                   # 健身主题数据模型与仓储
|   |       |   |-- fitness_data_models.h               # 健身业务数据结构
|   |       |   |-- fitness_data_repository.h           # 数据仓储接口
|   |       |   \-- fitness_data_repository.cpp         # 数据读取与聚合实现
|   |       |-- network/                                # 健身主题网络接口定义
|   |       |   |-- fitness_online_api.h                # 在线 API 声明
|   |       |   \-- fitness_online_api.cpp              # 在线 API 常量实现
|   |       \-- plan/                                   # 计划与记录核心流程
|   |           |-- fitness_plan_flow_helper.h          # 计划流程辅助接口
|   |           |-- fitness_plan_flow_helper.cpp        # 计划流程计算实现
|   |           |-- fitness_plan_runtime.cpp            # 计划运行时公共逻辑
|   |           |-- fitness_plan_item_actions.cpp       # 计划项操作（完成/忽略/编辑）
|   |           |-- fitness_training_record_actions.cpp # 训练记录提交与补录
|   |           \-- mainwindow_fitness_plan_manager.cpp # 计划管理页与主窗口联动
|   |
|   \-- ui/                                             # 主窗口交互层（按页面功能拆分）
|       |-- common/                                     # 启动、登录后流程等主线逻辑
|       |   |-- mainwindow_bootstrap.cpp                # MainWindow 初始化与启动流程
|       |   \-- mainwindow_session_flow.cpp             # 会话流程、页面切换与状态同步
|       |-- home/                                       # 首页相关实现预留目录
|       |-- login/                                      # 登录与注册流程
|       |   |-- login_register_flow.h                   # 登录/注册流程接口
|       |   \-- login_register_flow.cpp                 # 登录/注册流程实现
|       |-- profile/                                    # 个人中心相关交互
|       |   |-- profile_interaction_helper.h            # 个人中心交互辅助接口
|       |   |-- profile_interaction_helper.cpp          # 个人中心交互辅助实现
|       |   \-- mainwindow_profile_actions.cpp          # 主窗口个人页动作实现
|       \-- theme/                                      # 主题切换与账号主题行为
|           |-- mainwindow_theme_actions.cpp            # 主窗口主题相关动作实现
|           \-- theme_account_actions.cpp               # 主题与账号联动动作实现
|
|-- MousePlan_Server/                # Node.js 后端服务
|   |-- .env
|   |-- .gitignore
|   |-- .htaccess
|   |-- Mouse_Add_code              #添加注册码的服务器接口
|   |-- package.json
|   |-- package-lock.json
|   |-- README.md                   #使用文档
|   |-- src/
|   |   |-- config.js
|   |   |-- db.js                   
|   |   \-- index.js
|   |-- data/
|   |   |-- .gitkeep
|   |   |-- db.json                 # 服务器数据的json串
|   |   \-- updates/                # APK/更新包投放目录
|   \-- node_modules/               # 已安装 npm 依赖相关

// 在 mphalport.h 或相应移植文件中实现

#include <stdio.h>
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mphal.h"
#include "xparameters.h"
#include "xuartps.h"

// 时间控制函数
mp_uint_t mp_hal_ticks_ms(void) {
    // 返回系统启动后的毫秒数
    return 0;
}

mp_uint_t mp_hal_ticks_us(void) {
    // 返回系统启动后的微秒数
    return 0;
}

mp_uint_t mp_hal_ticks_cpu(void) {
    // 返回CPU时钟计数（用于高精度计时）
    return 0;
}

void mp_hal_delay_ms(mp_uint_t ms) {
    // 阻塞延时毫秒
}

void mp_hal_delay_us(mp_uint_t us) {
    // 阻塞延时微秒
}

// 标准输入输出函数
int mp_hal_stdin_rx_chr(void) {
    // u8 ReceivedData;

    // // 尝试接收一个字节
    // if (Uart1_ReceiveByte(&ReceivedData)) {
    //     // 接收到数据，直接回显
    //     //XUartPs_SendByte(Uart1_Inst.Config.BaseAddress, ReceivedData);
    // return ReceivedData;
    // }
    return 0 //空实现
}

void mp_hal_stdout_tx_str(const char *str) {
    // 向标准输出发送字符串
//  printf("%.*s", strlen(str), str);
}

mp_uint_t mp_hal_stdout_tx_strn(const char *str, size_t len) {
    // 向标准输出发送指定长度字符串
//  printf("%.*s", len, str);
    return len;
}

void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
//  printf("%.*s", len, str);
}

uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
    // 检查标准输入/输出状态（用于非阻塞操作）
    return 0;
}

// 引脚读取
int mp_hal_pin_read(mp_hal_pin_obj_t *pin) {
    // 读取引脚电平
    return 0;
}

// 引脚写入
void mp_hal_pin_write(mp_hal_pin_obj_t *pin, int value) {
    // 设置引脚电平
}

// 引脚模式设置
void mp_hal_pin_open_set(void *machine_pin, int mode) {
    // 设置引脚模式（输入/输出等）
}

// 系统控制函数
void mp_hal_set_interrupt_char(char c) {
    // 设置中断字符（如Ctrl+C）
}

uint64_t mp_hal_time_ns(void) {
    // 返回自纪元以来的纳秒数
    return 0;
}

/*
 * This file is part of the MicroPython project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2021 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

//暂时为空

#include "py/gc.h"
#include <stdint.h>    // 定义 uintptr_t 类型
#include <stddef.h>    // 定义 size_t 类型

// 确保链接脚本中的符号正确定义
extern int _stack;
extern int _stack_end;

// 3. 辅助函数：获取当前所有寄存器的值并保存到数组中
// 这些寄存器可能包含当前函数调用上下文中的对象指针
static void gc_helper_get_regs(volatile uintptr_t arr[]) {
    // 使用扩展汇编明确告知编译器我们需要读取这些通用寄存器的值
    __asm__ volatile (
        "mov %0, r0\n"   // 将寄存器 r0 的值存入数组第0个元素
        "mov %1, r1\n"   // 将寄存器 r1 的值存入数组第1个元素
        "mov %2, r2\n"   // ... 以此类推
        "mov %3, r3\n"
        "mov %4, r4\n"
        "mov %5, r5\n"
        "mov %6, r6\n"
        "mov %7, r7\n"
        "mov %8, r8\n"
        "mov %9, r9\n"
        "mov %10, r10\n"
        "mov %11, r11\n"
        "mov %12, r12\n" // 寄存器 r12
        : "=r" (arr[0]), "=r" (arr[1]), "=r" (arr[2]), "=r" (arr[3]),
          "=r" (arr[4]), "=r" (arr[5]), "=r" (arr[6]), "=r" (arr[7]),
          "=r" (arr[8]), "=r" (arr[9]), "=r" (arr[10]), "=r" (arr[11]),
          "=r" (arr[12])
        : // 没有输入操作数
        : // 没有显式声明的被破坏寄存器（编译器会自动处理）
    );
}

// 4. 实现 gc_collect 函数
void gc_collect(void) {
    // 启动垃圾回收过程
    gc_collect_start();

    // 第二阶段：扫描根对象（寄存器和栈）

    // 扫描CPU寄存器
    // 在当前栈帧上创建一个数组来保存寄存器值
    volatile uintptr_t regs[13]; // 用于保存 R0-R12
    gc_helper_get_regs(regs);

    // 将保存寄存器值的数组本身也作为一个需要扫描的根区域
    // 因为数组里的每个元素都可能是某个Python对象的地址
    gc_collect_root((void**)regs, sizeof(regs) / sizeof(uintptr_t));

    // 扫描整个栈空间
    // 计算栈的大小（以 void* 为单位）。因为栈是向下生长的，所以：
    // 栈的起始地址（低地址）是 _stack_end
    // 栈的结束地址（高地址）是 _stack
    uintptr_t stack_top = (uintptr_t)&_stack_end;
    uintptr_t stack_bottom = (uintptr_t)&_stack;
    // 确保计算不会出现负数，进行安全转换
    size_t stack_size_in_words = (stack_bottom > stack_top) ?
                                (stack_bottom - stack_top) / sizeof(void*) : 0;

    if (stack_size_in_words > 0) {
        gc_collect_root((void**)stack_top, stack_size_in_words);
    }

    // 第三阶段：结束垃圾回收，进行实际的清扫工作
    gc_collect_end();
}

/*
 * This file is part of the MicroPython project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2021 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <string.h>
#include "py/compile.h"
#include "py/runtime.h"
#include "py/gc.h"

#define HEAP_SIZE (32 * 1024) // 定义内存大小
static char heap[HEAP_SIZE];
extern int Uart1_ReceiveByte(u8 *Data);


//初始化
void py_init()
{
    gc_init(heap, heap + sizeof(heap)); //内存初始化
    mp_init(); //python初始化
}

void py_uinit()
{
    mp_deinit();
}

static const char *demo_single_input =
    "print('hello world!', list(x + 1 for x in range(10)), end='eol\\n')";

static const char *demo_file_input =
    "import micropython\n"
    "\n"
    "print(dir(micropython))\n"
    "\n"
    "for i in range(10):\n"
    "    print('iter {:08}'.format(i))";

void do_str(const char *src, mp_parse_input_kind_t input_kind) {
    nlr_buf_t nlr;
    if (nlr_push(&nlr) == 0) {
        // Compile, parse and execute the given string.
        mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
        qstr source_name = lex->source_name;
        mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
        mp_call_function_0(module_fun);
        nlr_pop();
    } else {
        // Uncaught exception: print it out.
        mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
    }
}

// Main entry point: initialise the runtime and execute demo strings.
void bare_main(void) {
    mp_init();
    do_str(demo_single_input, MP_PARSE_SINGLE_INPUT);
    do_str(demo_file_input, MP_PARSE_FILE_INPUT);
    mp_deinit();
}

// Called if an exception is raised outside all C exception-catching handlers.
void nlr_jump_fail(void *val) {
    for (;;) {
    }
}

#ifndef NDEBUG
// Used when debugging is enabled.
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
    for (;;) {
    }
}
#endif

// 在 mphalport.h 或相应移植文件中实现

#include <stdio.h>
#include "py/runtime.h"
#include "py/stream.h"
#include "py/mphal.h"
#include "xparameters.h"
#include "xuartps.h"

// 时间控制函数
mp_uint_t mp_hal_ticks_ms(void) {
    // 返回系统启动后的毫秒数
    return 0;
}

mp_uint_t mp_hal_ticks_us(void) {
    // 返回系统启动后的微秒数
    return 0;
}

mp_uint_t mp_hal_ticks_cpu(void) {
    // 返回CPU时钟计数（用于高精度计时）
    return 0;
}

void mp_hal_delay_ms(mp_uint_t ms) {
    // 阻塞延时毫秒
}

void mp_hal_delay_us(mp_uint_t us) {
    // 阻塞延时微秒
}

// 标准输入输出函数
int mp_hal_stdin_rx_chr(void) {
    u8 ReceivedData;

    // 尝试接收一个字节
    if (Uart1_ReceiveByte(&ReceivedData)) {
        // 接收到数据，直接回显
        //XUartPs_SendByte(Uart1_Inst.Config.BaseAddress, ReceivedData);
    return ReceivedData;
    }
}

void mp_hal_stdout_tx_str(const char *str) {
    // 向标准输出发送字符串
 printf("%.*s", strlen(str), str);
}

mp_uint_t mp_hal_stdout_tx_strn(const char *str, size_t len) {
    // 向标准输出发送指定长度字符串
 printf("%.*s", len, str);
    return len;
}

void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
 printf("%.*s", len, str);
}

uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
    // 检查标准输入/输出状态（用于非阻塞操作）
    return 0;
}

// 引脚读取
int mp_hal_pin_read(mp_hal_pin_obj_t *pin) {
    // 读取引脚电平
    return 0;
}

// 引脚写入
void mp_hal_pin_write(mp_hal_pin_obj_t *pin, int value) {
    // 设置引脚电平
}

// 引脚模式设置
void mp_hal_pin_open_set(void *machine_pin, int mode) {
    // 设置引脚模式（输入/输出等）
}

// 系统控制函数
void mp_hal_set_interrupt_char(char c) {
    // 设置中断字符（如Ctrl+C）
}

uint64_t mp_hal_time_ns(void) {
    // 返回自纪元以来的纳秒数
    return 0;
}

/******************************************************************************
*
* Copyright (C) 2009 - 2014 Xilinx, Inc.  All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* Use of the Software is limited solely to applications:
* (a) running on a Xilinx device, or
* (b) that interact with a Xilinx device through a bus or interconnect.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the Xilinx shall not be used
* in advertising or otherwise to promote the sale, use or other dealings in
* this Software without prior written authorization from Xilinx.
*
******************************************************************************/

/*
 * helloworld.c: simple test application
 *
 * This application configures UART 16550 to baud rate 9600.
 * PS7 UART (Zynq) is not initialized by this application, since
 * bootrom/bsp configures it to baud rate 115200
 *
 * ------------------------------------------------
 * | UART TYPE   BAUD RATE                        |
 * ------------------------------------------------
 *   uartns550   9600
 *   uartlite    Configurable only in HW design
 *   ps7_uart    115200 (configured by bootrom/bsp)
 */

#include "xparameters.h"
#include "xuartps.h"
#include "xuartps_hw.h"
#include <string.h>
#include <stdio.h>
#include "platform.h"
#include "xgpio.h"
#include <unistd.h>  // for sleep()
#include "xil_printf.h"
// MicroPython 头文件
#include "bare-arm/pymain.h"


#define LED_DEVICE_ID XPAR_AXI_GPIO_0_DEVICE_ID
XGpio LEDInst;

// 串口1设备ID
#define UART1_DEVICE_ID XPAR_PS7_UART_1_DEVICE_ID

// 全局串口实例
XUartPs Uart1_Inst;

// 输入缓冲区大小
#define INPUT_BUFFER_SIZE 256
static char input_buffer[INPUT_BUFFER_SIZE];
static int input_index = 0;
int Uart1_ReceiveByte(u8 *Data);

// 简单的串口初始化函数
int Uart1_Simple_Init(void)
{
    XUartPs_Config *UartConfig;
    int Status;

    // 查找串口配置
    UartConfig = XUartPs_LookupConfig(UART1_DEVICE_ID);
    if (UartConfig == NULL) {
        xil_printf("UART1 LookupConfig Failed!\r\n");
        return XST_FAILURE;
    }

    // 初始化串口
    Status = XUartPs_CfgInitialize(&Uart1_Inst, UartConfig, UartConfig->BaseAddress);
    if (Status != XST_SUCCESS) {
        xil_printf("UART1 CfgInitialize Failed!\r\n");
        return XST_FAILURE;
    }

    // 设置波特率为115200
    XUartPs_SetBaudRate(&Uart1_Inst, 115200);

    // 设置正常操作模式
    XUartPs_SetOperMode(&Uart1_Inst, XUARTPS_OPER_MODE_NORMAL);

    xil_printf("UART1 Simple Initialization Successful!\r\n");
    return XST_SUCCESS;
}

// 轮询方式接收一个字符（非阻塞）
int Uart1_ReceiveByte(u8 *Data)
{
    // 检查是否有数据可读
    if (XUartPs_IsReceiveData(Uart1_Inst.Config.BaseAddress)) {
        *Data = XUartPs_ReadReg(Uart1_Inst.Config.BaseAddress, XUARTPS_FIFO_OFFSET);
        return 1; // 成功接收到数据
    }
    return 0; // 没有数据
}

// 发送字符串到串口
void Uart1_SendString(const char *str)
{
    int len = strlen(str);
    int sent = 0;

    while (sent < len) {
        sent += XUartPs_Send(&Uart1_Inst, (u8*)&str[sent], len - sent);
    }
}


// 简单的回显处理函数
void Uart1_EchoHandler(void)
{
    u8 ReceivedData;

    // 尝试接收一个字节
    if (Uart1_ReceiveByte(&ReceivedData)) {
        // 回显字符
        XUartPs_SendByte(Uart1_Inst.Config.BaseAddress, ReceivedData);

        // 处理回车键
        if (ReceivedData == '\r' || ReceivedData == '\n') {
            if (input_index > 0) {
                input_buffer[input_index] = '\0'; // 添加字符串结束符

                // 换行
                Uart1_SendString("\r\n");

                // 处理特殊命令
                if (strcmp(input_buffer, "exit") == 0) {
                    Uart1_SendString("Exiting MicroPython REPL...\r\n");
                    input_index = 0;
                    return;
                }
                else if (strcmp(input_buffer, "help") == 0) {
                    Uart1_SendString("MicroPython REPL Commands:\r\n");
                    Uart1_SendString("  help - Show this help message\r\n");
                    Uart1_SendString("  exit - Exit REPL mode\r\n");
                    Uart1_SendString("  Enter Python code to execute\r\n");
                }
                else if (strlen(input_buffer) > 0) {
                    // 执行Python代码
                    do_str(input_buffer, MP_PARSE_SINGLE_INPUT);
                }

                input_index = 0;
            }

            // 显示提示符
            Uart1_SendString(">>> ");
        }
        // 处理退格键
        else if (ReceivedData == 0x7F || ReceivedData == 0x08) { // Backspace or Delete
            if (input_index > 0) {
                input_index--;
                // 在终端上显示退格效果
                Uart1_SendString("\b \b");
            }
        }
        // 处理普通字符
        else if (ReceivedData >= 0x20 && ReceivedData <= 0x7E) { // 可打印字符
            if (input_index < INPUT_BUFFER_SIZE - 1) {
                input_buffer[input_index++] = ReceivedData;
            }
        }
    }
}

int main()
{
init_platform();
py_init();//初始化python
    xil_printf("ZYNQ MicroPython REPL Starting...\r\n");

    int status;
    status = XGpio_Initialize(&LEDInst, LED_DEVICE_ID);
    if(status != XST_SUCCESS)
        return XST_FAILURE;
    XGpio_SetDataDirection(&LEDInst, 1, 0);     // 设置GPIO方向为输出

    XGpio_DiscreteWrite(&LEDInst, 1, 0b000);//测试LED

    print("Hello World\n\r");

    // 测试1: 基本输出和字符串操作
    do_str("print('=== MicroPython Basic Test ===')", MP_PARSE_SINGLE_INPUT);
    do_str("print('Hello, ZYNQ!')", MP_PARSE_SINGLE_INPUT);

    // 测试2: 创建和操作数组（列表）
    do_str("arr = [1, 2, 3, 4, 5]", MP_PARSE_SINGLE_INPUT);
    do_str("print('Array:', arr)", MP_PARSE_SINGLE_INPUT);
    do_str("arr.append(6)", MP_PARSE_SINGLE_INPUT);
    do_str("print('After append:', arr)", MP_PARSE_SINGLE_INPUT);
    do_str("print('Array length:', len(arr))", MP_PARSE_SINGLE_INPUT);

    // 测试3: 算术运算
    do_str("a, b = 10, 3", MP_PARSE_SINGLE_INPUT);
    do_str("print('10 + 3 =', a + b)", MP_PARSE_SINGLE_INPUT);
    do_str("print('10 - 3 =', a - b)", MP_PARSE_SINGLE_INPUT);
    do_str("print('10 * 3 =', a * b)", MP_PARSE_SINGLE_INPUT);
    do_str("print('10 // 3 =', a // b)", MP_PARSE_SINGLE_INPUT);

    // 测试4: 逻辑判断和条件语句
    do_str("x = 15", MP_PARSE_SINGLE_INPUT);
    do_str("if x > 10: print('x is greater than 10')", MP_PARSE_SINGLE_INPUT);
    do_str("if x % 2 == 0: print('x is even')", MP_PARSE_SINGLE_INPUT);
    do_str("else: print('x is odd')", MP_PARSE_SINGLE_INPUT);

    // 测试5: 循环操作
    do_str("print('Counting from 0 to 4:')", MP_PARSE_SINGLE_INPUT);
    do_str("for i in range(5): print('Number:', i)", MP_PARSE_SINGLE_INPUT);

    // 测试6: 列表推导式（Python特色功能）
    do_str("squares = [i**2 for i in range(6)]", MP_PARSE_SINGLE_INPUT);
    do_str("print('Squares of 0-5:', squares)", MP_PARSE_SINGLE_INPUT);

    // 测试7: 字典操作
    do_str("student = {'name': 'ZYNQ', 'score': 95}", MP_PARSE_SINGLE_INPUT);
    do_str("print('Student info:', student)", MP_PARSE_SINGLE_INPUT);
    do_str("print('Student name:', student['name'])", MP_PARSE_SINGLE_INPUT);

    // 测试8: 函数定义和调用
    do_str("def multiply(x, y): return x * y", MP_PARSE_SINGLE_INPUT);
    do_str("result = multiply(7, 8)", MP_PARSE_SINGLE_INPUT);
    do_str("print('7 * 8 =', result)", MP_PARSE_SINGLE_INPUT);

    do_str("print('=== All tests completed! ===')", MP_PARSE_SINGLE_INPUT);

//    while(1) //注释主循环，则会进入REPL交互模式
//    {
//        // 主循环
//    }

    // 初始化串口1
    if (Uart1_Simple_Init() != XST_SUCCESS) {
        xil_printf("UART1 Init Failed! System Halted.\r\n");
        while(1); // 初始化失败，停止系统
    }

    Uart1_SendString("========================================\r\n");
    Uart1_SendString("    ZYNQ MicroPython REPL Environment\r\n");
    Uart1_SendString("========================================\r\n");
    Uart1_SendString("Type 'help' for available commands.\r\n");
    Uart1_SendString("Type Python code to execute immediately.\r\n");
    Uart1_SendString(">>> ");

    // 主循环 - REPL交互模式
    while(1) {
        Uart1_EchoHandler();
        // 可以在这里添加其他任务或微小延迟
    }

    py_uinit();
    cleanup_platform();

    return 0;
}

#include "py/runtime.h"
#include "py/obj.h"
#include "machine_pin.h"

#include "xparameters.h"
#include "xuartps.h"
#include "xuartps_hw.h"
#include <string.h>
#include <stdio.h>
#include "xgpio.h"
#include <unistd.h>  // for sleep()
#include "xil_printf.h"

extern XGpio LEDInst;

/* ===================== Pin 构造函数 ===================== */
static mp_obj_t machine_pin_make_new(const mp_obj_type_t *type,
                                     size_t n_args,
                                     size_t n_kw,
                                     const mp_obj_t *args) {
    mp_arg_check_num(n_args, n_kw, 2, 2, false);

    machine_pin_obj_t *self = m_new_obj(machine_pin_obj_t);
    self->base.type = type;

    self->pin_id = mp_obj_get_int(args[0]);
    self->mode   = mp_obj_get_int(args[1]);

    /* GPIO 初始化（需要自己实现） */
    mp_hal_gpio_init(self->pin_id, self->mode);

    return MP_OBJ_FROM_PTR(self);
}

/* ===================== Pin.value() ===================== */
static mp_obj_t machine_pin_value(size_t n_args, const mp_obj_t *args) {
    machine_pin_obj_t *self = MP_OBJ_TO_PTR(args[0]);

    if (n_args == 1) {
        int val = mp_hal_gpio_read(self->pin_id);
        return mp_obj_new_int(val);
    } else {
        int val = mp_obj_get_int(args[1]);
        mp_hal_gpio_write(self->pin_id, val);
        return mp_const_none;
    }
}
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(
    machine_pin_value_obj, 1, 2, machine_pin_value
);

/* ===================== locals_dict ===================== */

static const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_value), MP_ROM_PTR(&machine_pin_value_obj) },

    /* 类常量 */
    { MP_ROM_QSTR(MP_QSTR_IN),  MP_ROM_INT(MACHINE_PIN_MODE_IN) },
    { MP_ROM_QSTR(MP_QSTR_OUT), MP_ROM_INT(MACHINE_PIN_MODE_OUT) },
};

static MP_DEFINE_CONST_DICT(
    machine_pin_locals_dict,
    machine_pin_locals_dict_table
);

/* ===================== Pin 类型定义 ===================== */

MP_DEFINE_CONST_OBJ_TYPE(
    machine_pin_type,
    MP_QSTR_Pin,
    MP_TYPE_FLAG_NONE,
    make_new, machine_pin_make_new,
    locals_dict, &machine_pin_locals_dict
);


void mp_hal_gpio_init(uint32_t pin, uint32_t mode)
{
    int status;
if(pin ==0 || pin==1 || pin ==2)
{
status = XGpio_Initialize(&LEDInst, LED_DEVICE_ID);
if(status != XST_SUCCESS)
printf("mp_hal_gpio_init error!!!!\r\n");
XGpio_SetDataDirection(&LEDInst, 1, mode);     // 设置GPIO方向为输出/输入
}
}
void mp_hal_gpio_write(uint32_t pin, int value)
{
if(pin ==0 || pin==1 || pin ==2)
{
// 使用位运算生成对应引脚的掩码
uint32_t pin_mask = (1 << pin);  // 将引脚号转换为位掩码

if (value) {
XGpio_DiscreteSet(&LEDInst, 1, pin_mask);  // 设置对应位为高电平
}
else {
XGpio_DiscreteClear(&LEDInst, 1, pin_mask);  // 清除对应位为低电平
}
}
}
int mp_hal_gpio_read(uint32_t pin)
{
    if(pin == 0 || pin == 1 || pin == 2)
    {
        // 读取整个GPIO通道的状态
        uint32_t gpio_state = XGpio_DiscreteRead(&LEDInst, 1);
        // 使用位掩码提取特定引脚的状态
        uint32_t pin_mask = (1 << pin);

        // 返回该引脚的状态 (0 或 1)
        return (gpio_state & pin_mask) ? 1 : 0;
    }
    return -1; // 引脚号错误返回-1
}

// machine.c
#include "py/obj.h"
#include "py/runtime.h"
#include "machine_pin.h"
#include "mpconfigport.h"

/* ===================== Pin 类型声明 ===================== */
extern const mp_obj_type_t machine_pin_type;

/* ===================== machine 模块 globals ===================== */
static const mp_rom_map_elem_t machine_module_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR_Pin), MP_ROM_PTR(&machine_pin_type) },
};

//这里我们我直接写到objmodule.c文件中，所以这里不列出数组
//static const mp_rom_map_elem_t mp_builtin_module_table[] = {
//    MICROPY_PORT_BUILTIN_MODULES
//    // ... 其他模块
//};


static MP_DEFINE_CONST_DICT(machine_module_globals, machine_module_globals_table);

/* ===================== machine 模块对象 ===================== */
const mp_obj_module_t machine_module = {
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t*)&machine_module_globals,
};

//我们手动注册
/* ===================== 注册模块 ===================== */
//MP_REGISTER_MODULE(MP_QSTR_machine, machine_module);

// 在 mphalport.h 或相应移植文件中实现

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "mphalport.h"
#include "py/runtime.h"
#include "py/mphal.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "xparameters.h"
#include "xgpio.h"
#include "xstatus.h"

extern int Uart1_ReceiveByte(u8 *Data);

// 时间控制函数
mp_uint_t mp_hal_ticks_ms(void) {
    // 返回系统启动后的毫秒数
    return 0;
}

mp_uint_t mp_hal_ticks_us(void) {
    // 返回系统启动后的微秒数
    return 0;
}

mp_uint_t mp_hal_ticks_cpu(void) {
    // 返回CPU时钟计数（用于高精度计时）
    return 0;
}

void mp_hal_delay_ms(mp_uint_t ms) {
    // 阻塞延时毫秒
}

void mp_hal_delay_us(mp_uint_t us) {
    // 阻塞延时微秒
}

// 标准输入输出函数
int mp_hal_stdin_rx_chr(void) {
    u8 ReceivedData;

    // 尝试接收一个字节
    if (Uart1_ReceiveByte(&ReceivedData)) {
        // 接收到数据，直接回显
        //XUartPs_SendByte(Uart1_Inst.Config.BaseAddress, ReceivedData);
    return ReceivedData;
    }
    return 0;
}

void mp_hal_stdout_tx_str(const char *str) {
    // 向标准输出发送字符串
 printf("%.*s", strlen(str), str);
}

mp_uint_t mp_hal_stdout_tx_strn(const char *str, size_t len) {
    // 向标准输出发送指定长度字符串
 printf("%.*s", len, str);
    return len;
}

void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
 printf("%.*s", len, str);
}


uintptr_t mp_hal_stdio_poll(uintptr_t poll_flags) {
    // 检查标准输入/输出状态（用于非阻塞操作）
    return 0;
}


// 系统控制函数
void mp_hal_set_interrupt_char(char c) {
    // 设置中断字符（如Ctrl+C）
}

uint64_t mp_hal_time_ns(void) {
    // 返回自纪元以来的纳秒数
    return 0;
}