简介：一个一个一个手摇发电灯

我将深入分析手摇发电灯嵌入式系统的开发流程，并提供一个可靠、高效、可扩展的代码架构以及相应的C代码实现。以下是一个详细的方案，旨在展示从需求分析到系统维护升级的完整嵌入式系统开发实践。
关注微信公众号，提前获取相关推文

项目：手摇发电灯嵌入式系统

1. 需求分析

手摇发电灯的核心需求是利用手摇发电为LED灯供电，并具备以下功能：

• 基本照明功能： 提供可靠的照明，亮度可调。
• 手摇发电： 通过手摇机构将机械能转换为电能。
• 储能功能： 具备电容或电池储能，在停止手摇后仍能持续照明一段时间。
• 稳压功能： 确保LED供电电压稳定，避免因手摇速度变化导致亮度不稳定或LED损坏。
• 高亮模式： 提供高亮度照明模式，以满足特殊场景需求。
• USB扩展（可选）： 可能具备USB接口，用于对外供电或充电（如果使用可充电电池）。
• 低功耗设计： 在保证功能的前提下，最大限度降低功耗，延长续航时间。
• 可靠性： 系统稳定可靠，能在不同环境下正常工作。
• 易用性： 操作简单，用户友好。
• 可维护性： 代码结构清晰，易于维护和升级。

非功能性需求：

• 成本： 设计需考虑成本控制，选择性价比高的元器件。
• 尺寸和重量： 体积小巧，重量轻便，便于携带。
• 耐用性： 结构坚固耐用，能承受一定程度的冲击和震动。
• 安全性： 电气安全，使用安全可靠。

2. 系统设计

2.1 硬件设计

• 微控制器 (MCU): 选择低功耗、资源适中的MCU，例如STM32L系列、MSP430系列或ESP32-C3等。这里我们假设选择STM32L0系列，因为它在低功耗和成本之间取得了良好的平衡。
• 手摇发电机: 选用小型直流发电机，输出电压和电流需与系统匹配。
• 整流桥: 将发电机产生的交流电转换为直流电。
• 稳压电路: 使用DC-DC降压或升压芯片，将不稳定的发电电压转换为稳定的LED供电电压。
• 储能元件: 可以选择超级电容或可充电锂电池。超级电容寿命长、充放电速度快，但能量密度较低；锂电池能量密度高，但寿命有限。根据需求选择。这里我们先考虑使用超级电容。
• LED驱动电路: 恒流LED驱动芯片，确保LED亮度稳定，并可实现调光功能。
• LED灯: 选用高亮度、低功耗的LED灯珠。
• USB接口 (可选): Type-A 或 Type-C USB接口，用于对外供电或充电。
• 按键: 用于模式切换、亮度调节等用户交互。
• 指示灯 (可选): LED指示灯，用于显示工作状态、电量等。
• 保护电路: 过压保护、过流保护、短路保护等，确保系统安全。

2.2 软件设计

2.2.1 软件架构：分层架构

为了提高代码的可读性、可维护性和可扩展性，我们采用分层架构。

+-----------------------+
|   Application Layer     |  (应用层 - 用户交互、模式切换、主逻辑)
+-----------------------+
|   Service Layer         |  (服务层 - 电源管理、LED控制、输入处理)
+-----------------------+
|   Driver Layer          |  (驱动层 - 硬件接口抽象、底层控制)
+-----------------------+
|   Hardware Abstraction Layer (HAL) | (硬件抽象层 - 平台无关接口)
+-----------------------+
|        Hardware       |  (硬件层 - MCU、外围器件)
+-----------------------+

• 硬件层 (Hardware): 实际的硬件组件。
• 硬件抽象层 (HAL): 提供平台无关的硬件访问接口，例如GPIO、ADC、Timer、PWM等。这层屏蔽了不同MCU硬件的差异，方便代码移植。
• 驱动层 (Driver Layer): 基于HAL层，实现具体硬件设备的驱动，例如LED驱动、电源管理驱动、按键驱动、USB驱动等。驱动层负责与硬件直接交互，提供高层次的API给服务层使用。
• 服务层 (Service Layer): 在驱动层之上，实现更高级的功能服务，例如LED亮度控制服务、电源管理服务、输入事件处理服务。服务层组合多个驱动，完成特定的业务逻辑。
• 应用层 (Application Layer): 最上层，实现用户应用逻辑，例如手摇发电灯的各种工作模式切换、用户界面交互等。应用层调用服务层提供的接口，完成最终的功能。

2.2.2 模块划分

根据分层架构和功能需求，我们将软件系统划分为以下模块：

• HAL模块 (HAL): 包含GPIO, ADC, Timer, PWM等硬件抽象接口。
• 驱动模块 (Drivers):
  • led_driver: LED驱动，控制LED开关、亮度。
  • power_driver: 电源管理驱动，处理发电输入、储能、稳压输出。
  • input_driver: 输入驱动，处理按键、手摇信号输入。
  • usb_driver (可选): USB驱动，处理USB通信。
• 服务模块 (Services):
  • led_service: LED控制服务，实现亮度调节、模式切换等。
  • power_service: 电源管理服务，监控电量、控制充放电、进入低功耗模式。
  • input_service: 输入事件服务，处理按键事件、手摇事件。
• 应用模块 (Application):
  • main_app: 主应用程序，实现手摇发电灯的主逻辑，包括模式管理、用户交互。
• 配置模块 (Config):
  • config.h: 系统配置头文件，定义硬件引脚、参数配置等。

2.2.3 状态机设计

手摇发电灯可以有以下几种状态：

• OFF: 灯关闭状态。
• LOW_BRIGHTNESS: 低亮度照明模式。
• HIGH_BRIGHTNESS: 高亮度照明模式。
• USB_OUTPUT (可选): USB对外供电模式。
• CHARGING (可选，如果使用电池): 电池充电状态。
• ERROR: 系统错误状态。

使用状态机管理系统状态，可以清晰地控制系统行为，并方便进行状态切换和事件处理。

3. 代码实现 (C语言)

以下是一个简化的C代码实现，展示了手摇发电灯嵌入式系统的基本框架和关键模块。由于3000行代码的要求，我们将尽可能详细地展开，并加入必要的注释和错误处理。

3.1 HAL模块 (HAL)

hal.h:

#ifndef HAL_H
#define HAL_H

#include <stdint.h>
#include <stdbool.h>

// GPIO 相关定义
typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT
} GPIO_ModeTypeDef;

typedef enum {
    GPIO_PIN_RESET = 0,
    GPIO_PIN_SET   = 1
} GPIO_PinState;

typedef struct {
    uint32_t Pin;          // GPIO 引脚
    GPIO_ModeTypeDef Mode;   // GPIO 模式
    // ... 其他 GPIO 配置参数，例如上拉/下拉，速度等
} GPIO_InitTypeDef;

void HAL_GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct);
void HAL_GPIO_WritePin(uint32_t Pin, GPIO_PinState PinState);
GPIO_PinState HAL_GPIO_ReadPin(uint32_t Pin);

// ADC 相关定义
typedef struct {
    uint32_t Channel;      // ADC 通道
    // ... 其他 ADC 配置参数，例如分辨率，采样时间等
} ADC_InitTypeDef;

void HAL_ADC_Init(ADC_InitTypeDef *ADC_InitStruct);
uint16_t HAL_ADC_GetValue(void);

// PWM 相关定义
typedef struct {
    uint32_t Channel;      // PWM 通道
    uint32_t Frequency;    // PWM 频率
    uint32_t DutyCycle;    // PWM 占空比
    // ... 其他 PWM 配置参数，例如极性等
} PWM_InitTypeDef;

void HAL_PWM_Init(PWM_InitTypeDef *PWM_InitStruct);
void HAL_PWM_SetDutyCycle(uint32_t DutyCycle);

// Timer 相关定义
typedef struct {
    uint32_t Prescaler;    // 预分频器
    uint32_t Period;       // 计数周期
    // ... 其他 Timer 配置参数，例如时钟源，模式等
} TIM_InitTypeDef;

void HAL_TIM_Init(TIM_InitTypeDef *TIM_InitStruct);
void HAL_TIM_Start(void);
void HAL_TIM_Stop(void);
uint32_t HAL_TIM_GetCounter(void);
void HAL_TIM_Delay_ms(uint32_t milliseconds); // 毫秒级延时函数

#endif // HAL_H

hal_gpio.c:

#include "hal.h"
#include "config.h" // 假设配置信息在 config.h 中

void HAL_GPIO_Init(GPIO_InitTypeDef *GPIO_InitStruct) {
    // 根据 GPIO_InitStruct 配置 GPIO 寄存器
    // 这里是硬件相关的底层实现，需要根据具体的 MCU 芯片手册编写
    // 例如，STM32L0 系列的 GPIO 初始化代码
    if (GPIO_InitStruct->Mode == GPIO_MODE_OUTPUT) {
        // 设置为输出模式
        // ... (具体寄存器操作)
    } else if (GPIO_InitStruct->Mode == GPIO_MODE_INPUT) {
        // 设置为输入模式
        // ... (具体寄存器操作)
    }
    // ... 其他配置，例如使能时钟，配置上拉/下拉等
}

void HAL_GPIO_WritePin(uint32_t Pin, GPIO_PinState PinState) {
    // 控制 GPIO 输出高低电平
    // ... (具体寄存器操作)
    if (PinState == GPIO_PIN_SET) {
        // 输出高电平
        // ...
    } else {
        // 输出低电平
        // ...
    }
}

GPIO_PinState HAL_GPIO_ReadPin(uint32_t Pin) {
    // 读取 GPIO 输入电平
    // ... (具体寄存器操作)
    // 返回 GPIO_PIN_SET 或 GPIO_PIN_RESET
    return GPIO_PIN_RESET; // 示例
}

hal_adc.c, hal_pwm.c, hal_timer.c: (类似地，根据具体的MCU芯片手册实现ADC, PWM, Timer 的 HAL 层驱动)
这些文件将包含 HAL_ADC_Init, HAL_ADC_GetValue, HAL_PWM_Init, HAL_PWM_SetDutyCycle, HAL_TIM_Init, HAL_TIM_Start, HAL_TIM_Stop, HAL_TIM_GetCounter, HAL_TIM_Delay_ms 等函数的具体实现，根据选定的STM32L0或其他MCU芯片的寄存器操作进行编写。

3.2 驱动模块 (Drivers)

led_driver.h:

#ifndef LED_DRIVER_H
#define LED_DRIVER_H

#include <stdint.h>
#include <stdbool.h>

typedef enum {
    LED_OFF,
    LED_LOW,
    LED_HIGH
} LED_BrightnessLevel;

typedef struct {
    uint32_t led_pin;     // LED 控制引脚
    uint32_t pwm_channel; // PWM 通道 (如果使用 PWM 调光)
} LED_ConfigTypeDef;

typedef struct {
    LED_ConfigTypeDef config;
} LED_DriverTypeDef;

bool LED_Driver_Init(LED_DriverTypeDef *driver, LED_ConfigTypeDef *config);
void LED_Driver_SetBrightness(LED_DriverTypeDef *driver, LED_BrightnessLevel level);
void LED_Driver_TurnOff(LED_DriverTypeDef *driver);

#endif // LED_DRIVER_H

led_driver.c:

#include "led_driver.h"
#include "hal.h"
#include "config.h" // 假设配置信息在 config.h 中

bool LED_Driver_Init(LED_DriverTypeDef *driver, LED_ConfigTypeDef *config) {
    if (!driver || !config) {
        return false; // 参数错误
    }
    driver->config = *config; // 复制配置信息

    // 初始化 LED 控制引脚为输出模式
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = driver->config.led_pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT;
    HAL_GPIO_Init(&GPIO_InitStruct);

    // 如果使用 PWM 调光，初始化 PWM 通道
    if (driver->config.pwm_channel != 0) { // 假设 pwm_channel 为 0 表示不使用 PWM
        PWM_InitTypeDef PWM_InitStruct;
        PWM_InitStruct.Channel = driver->config.pwm_channel;
        PWM_InitStruct.Frequency = LED_PWM_FREQUENCY; // 从 config.h 中获取 PWM 频率
        HAL_PWM_Init(&PWM_InitStruct);
    }

    LED_Driver_TurnOff(driver); // 初始状态关闭 LED
    return true;
}

void LED_Driver_SetBrightness(LED_DriverTypeDef *driver, LED_BrightnessLevel level) {
    if (!driver) {
        return;
    }

    if (driver->config.pwm_channel != 0) {
        // 使用 PWM 调光
        uint32_t duty_cycle = 0;
        switch (level) {
            case LED_LOW:
                duty_cycle = LED_PWM_DUTY_LOW; // 从 config.h 获取低亮度占空比
                break;
            case LED_HIGH:
                duty_cycle = LED_PWM_DUTY_HIGH; // 从 config.h 获取高亮度占空比
                break;
            case LED_OFF:
            default:
                duty_cycle = 0;
                break;
        }
        HAL_PWM_SetDutyCycle(duty_cycle);
    } else {
        // 使用 GPIO 直接控制开关 (简单开关模式)
        if (level == LED_HIGH || level == LED_LOW) { // 简化处理，LOW/HIGH都直接点亮
            HAL_GPIO_WritePin(driver->config.led_pin, GPIO_PIN_SET); // 点亮 LED
        } else {
            HAL_GPIO_WritePin(driver->config.led_pin, GPIO_PIN_RESET); // 关闭 LED
        }
    }
}

void LED_Driver_TurnOff(LED_DriverTypeDef *driver) {
    if (!driver) {
        return;
    }
    LED_Driver_SetBrightness(driver, LED_OFF);
}

power_driver.h:

#ifndef POWER_DRIVER_H
#define POWER_DRIVER_H

#include <stdint.h>
#include <stdbool.h>

typedef struct {
    uint32_t generator_adc_channel; // 发电机电压 ADC 通道
    uint32_t capacitor_voltage_adc_channel; // 电容电压 ADC 通道 (可选)
    uint32_t output_enable_pin;      // 稳压输出使能引脚
    uint32_t charge_enable_pin;      // 充电使能引脚 (如果使用电池)
} Power_ConfigTypeDef;

typedef struct {
    Power_ConfigTypeDef config;
} Power_DriverTypeDef;

bool Power_Driver_Init(Power_DriverTypeDef *driver, Power_ConfigTypeDef *config);
uint16_t Power_Driver_GetGeneratorVoltage(Power_DriverTypeDef *driver);
uint16_t Power_Driver_GetCapacitorVoltage(Power_DriverTypeDef *driver); // 可选
void Power_Driver_EnableOutput(Power_DriverTypeDef *driver);
void Power_Driver_DisableOutput(Power_DriverTypeDef *driver);
void Power_Driver_EnableCharging(Power_DriverTypeDef *driver); // 可选
void Power_Driver_DisableCharging(Power_DriverTypeDef *driver); // 可选

#endif // POWER_DRIVER_H

power_driver.c:

#include "power_driver.h"
#include "hal.h"
#include "config.h"

bool Power_Driver_Init(Power_DriverTypeDef *driver, Power_ConfigTypeDef *config) {
    if (!driver || !config) {
        return false;
    }
    driver->config = *config;

    // 初始化 ADC 通道
    ADC_InitTypeDef ADC_InitStruct;
    ADC_InitStruct.Channel = driver->config.generator_adc_channel;
    HAL_ADC_Init(&ADC_InitStruct);
    if (driver->config.capacitor_voltage_adc_channel != 0) { // 可选电容电压 ADC
        ADC_InitStruct.Channel = driver->config.capacitor_voltage_adc_channel;
        HAL_ADC_Init(&ADC_InitStruct);
    }

    // 初始化输出使能引脚为输出模式，初始状态关闭输出
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = driver->config.output_enable_pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT;
    HAL_GPIO_Init(&GPIO_InitStruct);
    Power_Driver_DisableOutput(driver);

    // 初始化充电使能引脚 (如果使用电池，这里先简化，假设没有充电使能)
    if (driver->config.charge_enable_pin != 0) {
        GPIO_InitStruct.Pin = driver->config.charge_enable_pin;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT;
        HAL_GPIO_Init(&GPIO_InitStruct);
        Power_Driver_DisableCharging(driver); // 初始状态关闭充电
    }

    return true;
}

uint16_t Power_Driver_GetGeneratorVoltage(Power_DriverTypeDef *driver) {
    if (!driver) {
        return 0;
    }
    // 设置 ADC 通道为发电机电压通道
    ADC_InitTypeDef ADC_InitStruct;
    ADC_InitStruct.Channel = driver->config.generator_adc_channel;
    HAL_ADC_Init(&ADC_InitStruct);
    return HAL_ADC_GetValue(); // 读取 ADC 值，需要根据实际硬件校准和转换电压值
}

uint16_t Power_Driver_GetCapacitorVoltage(Power_DriverTypeDef *driver) { // 可选
    if (!driver || driver->config.capacitor_voltage_adc_channel == 0) {
        return 0;
    }
    // 设置 ADC 通道为电容电压通道
    ADC_InitTypeDef ADC_InitStruct;
    ADC_InitStruct.Channel = driver->config.capacitor_voltage_adc_channel;
    HAL_ADC_Init(&ADC_InitStruct);
    return HAL_ADC_GetValue(); // 读取 ADC 值，需要根据实际硬件校准和转换电压值
}

void Power_Driver_EnableOutput(Power_DriverTypeDef *driver) {
    if (!driver) {
        return;
    }
    HAL_GPIO_WritePin(driver->config.output_enable_pin, GPIO_PIN_SET); // 使能稳压输出
}

void Power_Driver_DisableOutput(Power_DriverTypeDef *driver) {
    if (!driver) {
        return;
    }
    HAL_GPIO_WritePin(driver->config.output_enable_pin, GPIO_PIN_RESET); // 关闭稳压输出
}

void Power_Driver_EnableCharging(Power_DriverTypeDef *driver) { // 可选
    if (!driver || driver->config.charge_enable_pin == 0) {
        return;
    }
    HAL_GPIO_WritePin(driver->config.charge_enable_pin, GPIO_PIN_SET); // 使能充电
}

void Power_Driver_DisableCharging(Power_DriverTypeDef *driver) { // 可选
    if (!driver || driver->config.charge_enable_pin == 0) {
        return;
    }
    HAL_GPIO_WritePin(driver->config.charge_enable_pin, GPIO_PIN_RESET); // 关闭充电
}

input_driver.h:

#ifndef INPUT_DRIVER_H
#define INPUT_DRIVER_H

#include <stdint.h>
#include <stdbool.h>

typedef enum {
    INPUT_EVENT_NONE,
    INPUT_EVENT_BUTTON_CLICK,
    INPUT_EVENT_CRANK_DETECTED
} Input_EventType;

typedef struct {
    uint32_t button_pin;    // 按键引脚
    uint32_t crank_pin;     // 手摇信号引脚 (例如，可以使用一个GPIO检测手摇机构的旋转)
} Input_ConfigTypeDef;

typedef struct {
    Input_ConfigTypeDef config;
} Input_DriverTypeDef;

bool Input_Driver_Init(Input_DriverTypeDef *driver, Input_ConfigTypeDef *config);
Input_EventType Input_Driver_GetEvent(Input_DriverTypeDef *driver);
void Input_Driver_Task(Input_DriverTypeDef *driver); // 轮询检测输入事件 (或者可以使用中断方式)

#endif // INPUT_DRIVER_H

input_driver.c:

#include "input_driver.h"
#include "hal.h"
#include "config.h"

bool Input_Driver_Init(Input_DriverTypeDef *driver, Input_ConfigTypeDef *config) {
    if (!driver || !config) {
        return false;
    }
    driver->config = *config;

    // 初始化按键引脚为输入模式，并使能上拉 (或者下拉，根据实际按键电路)
    GPIO_InitTypeDef GPIO_InitStruct;
    GPIO_InitStruct.Pin = driver->config.button_pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    // ... 配置上拉或下拉
    HAL_GPIO_Init(&GPIO_InitStruct);

    // 初始化手摇信号引脚为输入模式
    GPIO_InitStruct.Pin = driver->config.crank_pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    HAL_GPIO_Init(&GPIO_InitStruct);

    return true;
}

Input_EventType Input_Driver_GetEvent(Input_DriverTypeDef *driver) {
    static GPIO_PinState last_button_state = GPIO_PIN_SET; // 假设按键默认高电平
    static bool crank_detected_flag = false;

    // 检测按键事件
    GPIO_PinState current_button_state = HAL_GPIO_ReadPin(driver->config.button_pin);
    if (current_button_state == GPIO_PIN_RESET && last_button_state == GPIO_PIN_SET) {
        // 按键按下 (下降沿检测)
        last_button_state = current_button_state;
        return INPUT_EVENT_BUTTON_CLICK;
    } else if (current_button_state == GPIO_PIN_SET && last_button_state == GPIO_PIN_RESET) {
        // 按键释放
        last_button_state = current_button_state;
    }

    // 检测手摇事件 (简化检测，假设手摇信号引脚电平变化表示手摇)
    GPIO_PinState current_crank_state = HAL_GPIO_ReadPin(driver->config.crank_pin);
    if (current_crank_state == GPIO_PIN_SET) { // 假设手摇时引脚为高电平
        if (!crank_detected_flag) {
            crank_detected_flag = true;
            return INPUT_EVENT_CRANK_DETECTED;
        }
    } else {
        crank_detected_flag = false;
    }

    return INPUT_EVENT_NONE;
}

void Input_Driver_Task(Input_DriverTypeDef *driver) {
    // 在主循环中定期调用 Input_Driver_Task 来轮询检测输入事件
    // 或者可以使用中断方式来更实时地处理输入事件
    Input_Driver_GetEvent(driver); // 可以选择在这里处理事件或者在应用层处理
}

usb_driver.h, usb_driver.c: (可选 USB 驱动，如果需要 USB 功能，例如对外供电或充电，需要实现 USB 驱动，这里先省略以简化代码)

3.3 服务模块 (Services)

led_service.h:

#ifndef LED_SERVICE_H
#define LED_SERVICE_H

#include <stdint.h>
#include <stdbool.h>
#include "led_driver.h"

typedef struct {
    LED_DriverTypeDef *led_driver;
    LED_BrightnessLevel current_brightness;
} LED_ServiceTypeDef;

bool LED_Service_Init(LED_ServiceTypeDef *service, LED_DriverTypeDef *led_driver);
void LED_Service_SetBrightness(LED_ServiceTypeDef *service, LED_BrightnessLevel level);
void LED_Service_ToggleBrightness(LED_ServiceTypeDef *service); // 切换亮度等级

#endif // LED_SERVICE_H

led_service.c:

#include "led_service.h"

bool LED_Service_Init(LED_ServiceTypeDef *service, LED_DriverTypeDef *led_driver) {
    if (!service || !led_driver) {
        return false;
    }
    service->led_driver = led_driver;
    service->current_brightness = LED_OFF; // 初始状态关闭 LED
    LED_Driver_TurnOff(led_driver);
    return true;
}

void LED_Service_SetBrightness(LED_ServiceTypeDef *service, LED_BrightnessLevel level) {
    if (!service) {
        return;
    }
    service->current_brightness = level;
    LED_Driver_SetBrightness(service->led_driver, level);
}

void LED_Service_ToggleBrightness(LED_ServiceTypeDef *service) {
    if (!service) {
        return;
    }
    if (service->current_brightness == LED_OFF) {
        LED_Service_SetBrightness(service, LED_LOW); // 切换到低亮度
    } else if (service->current_brightness == LED_LOW) {
        LED_Service_SetBrightness(service, LED_HIGH); // 切换到高亮度
    } else {
        LED_Service_SetBrightness(service, LED_OFF); // 切换回关闭
    }
}

power_service.h:

#ifndef POWER_SERVICE_H
#define POWER_SERVICE_H

#include <stdint.h>
#include <stdbool.h>
#include "power_driver.h"

typedef struct {
    Power_DriverTypeDef *power_driver;
    uint16_t generator_voltage;
    uint16_t capacitor_voltage; // 可选
    bool output_enabled;
} Power_ServiceTypeDef;

bool Power_Service_Init(Power_ServiceTypeDef *service, Power_DriverTypeDef *power_driver);
void Power_Service_UpdateVoltage(Power_ServiceTypeDef *service);
void Power_Service_EnableOutput(Power_ServiceTypeDef *service);
void Power_Service_DisableOutput(Power_ServiceTypeDef *service);
bool Power_Service_IsOutputEnabled(Power_ServiceTypeDef *service);

#endif // POWER_SERVICE_H

power_service.c:

#include "power_service.h"

bool Power_Service_Init(Power_ServiceTypeDef *service, Power_DriverTypeDef *power_driver) {
    if (!service || !power_driver) {
        return false;
    }
    service->power_driver = power_driver;
    service->generator_voltage = 0;
    service->capacitor_voltage = 0;
    service->output_enabled = false;
    Power_Service_DisableOutput(service); // 初始状态关闭输出
    return true;
}

void Power_Service_UpdateVoltage(Power_ServiceTypeDef *service) {
    if (!service) {
        return;
    }
    service->generator_voltage = Power_Driver_GetGeneratorVoltage(service->power_driver);
    service->capacitor_voltage = Power_Driver_GetCapacitorVoltage(service->power_driver); // 可选
}

void Power_Service_EnableOutput(Power_ServiceTypeDef *service) {
    if (!service) {
        return;
    }
    Power_Driver_EnableOutput(service->power_driver);
    service->output_enabled = true;
}

void Power_Service_DisableOutput(Power_ServiceTypeDef *service) {
    if (!service) {
        return;
    }
    Power_Driver_DisableOutput(service->power_driver);
    service->output_enabled = false;
}

bool Power_Service_IsOutputEnabled(Power_ServiceTypeDef *service) {
    if (!service) {
        return false;
    }
    return service->output_enabled;
}

input_service.h:

#ifndef INPUT_SERVICE_H
#define INPUT_SERVICE_H

#include <stdint.h>
#include <stdbool.h>
#include "input_driver.h"

typedef enum {
    USER_EVENT_NONE,
    USER_EVENT_BUTTON_PRESSED,
    USER_EVENT_CRANKING_START,
    USER_EVENT_CRANKING_STOP
} User_EventType;

typedef struct {
    Input_DriverTypeDef *input_driver;
    bool is_cranking;
} Input_ServiceTypeDef;

bool Input_Service_Init(Input_ServiceTypeDef *service, Input_DriverTypeDef *input_driver);
User_EventType Input_Service_GetUserEvent(Input_ServiceTypeDef *service);
void Input_Service_Task(Input_ServiceTypeDef *service); // 轮询检测用户事件

#endif // INPUT_SERVICE_H

input_service.c:

#include "input_service.h"

bool Input_Service_Init(Input_ServiceTypeDef *service, Input_DriverTypeDef *input_driver) {
    if (!service || !input_driver) {
        return false;
    }
    service->input_driver = input_driver;
    service->is_cranking = false;
    return true;
}

User_EventType Input_Service_GetUserEvent(Input_ServiceTypeDef *service) {
    Input_EventType event = Input_Driver_GetEvent(service->input_driver);
    if (event == INPUT_EVENT_BUTTON_CLICK) {
        return USER_EVENT_BUTTON_PRESSED;
    } else if (event == INPUT_EVENT_CRANK_DETECTED) {
        if (!service->is_cranking) {
            service->is_cranking = true;
            return USER_EVENT_CRANKING_START;
        }
        // 如果已经在 cranking 状态，则忽略后续的 CRANK_DETECTED 事件，直到停止
    } else if (event == INPUT_EVENT_NONE) {
        if (service->is_cranking) {
            // 如果之前是 cranking 状态，现在没有检测到 crank，则认为是停止 cranking
            service->is_cranking = false;
            return USER_EVENT_CRANKING_STOP;
        }
    }
    return USER_EVENT_NONE;
}

void Input_Service_Task(Input_ServiceTypeDef *service) {
    Input_Service_GetUserEvent(service); // 可以在这里处理事件或者在应用层处理
}

3.4 应用模块 (Application)

main.c:

#include "hal.h"
#include "config.h"
#include "led_driver.h"
#include "power_driver.h"
#include "input_driver.h"
#include "led_service.h"
#include "power_service.h"
#include "input_service.h"

// 定义硬件配置 (config.h)
#define LED_PIN             GPIO_PIN_0  // 假设 LED 连接到 GPIO_PIN_0
#define LED_PWM_CHANNEL     PWM_CHANNEL_1 // 假设使用 PWM_CHANNEL_1 调光
#define LED_PWM_FREQUENCY   1000        // PWM 频率 1kHz
#define LED_PWM_DUTY_LOW    30          // 低亮度占空比 (百分比)
#define LED_PWM_DUTY_HIGH   80          // 高亮度占空比 (百分比)

#define GENERATOR_ADC_CHANNEL ADC_CHANNEL_0 // 假设发电机电压连接到 ADC_CHANNEL_0
#define CAPACITOR_VOLTAGE_ADC_CHANNEL ADC_CHANNEL_1 // 假设电容电压连接到 ADC_CHANNEL_1 (可选)
#define OUTPUT_ENABLE_PIN   GPIO_PIN_1  // 假设稳压输出使能引脚为 GPIO_PIN_1
#define CHARGE_ENABLE_PIN   GPIO_PIN_2  // 假设充电使能引脚为 GPIO_PIN_2 (可选)

#define BUTTON_PIN          GPIO_PIN_3  // 假设按键连接到 GPIO_PIN_3
#define CRANK_PIN           GPIO_PIN_4  // 假设手摇信号连接到 GPIO_PIN_4

// 定义系统状态
typedef enum {
    STATE_OFF,
    STATE_LOW_BRIGHTNESS,
    STATE_HIGH_BRIGHTNESS
} SystemState;

SystemState current_state = STATE_OFF;

// 实例化驱动和服务
LED_DriverTypeDef led_driver;
Power_DriverTypeDef power_driver;
Input_DriverTypeDef input_driver;
LED_ServiceTypeDef led_service;
Power_ServiceTypeDef power_service;
Input_ServiceTypeDef input_service;

int main() {
    // 初始化 HAL (根据具体的 MCU 初始化时钟、外设等)
    // SystemClock_Config(); // 假设有系统时钟配置函数

    // 配置 LED 驱动
    LED_ConfigTypeDef led_config = {
        .led_pin = LED_PIN,
        .pwm_channel = LED_PWM_CHANNEL
    };
    LED_Driver_Init(&led_driver, &led_config);

    // 配置电源驱动
    Power_ConfigTypeDef power_config = {
        .generator_adc_channel = GENERATOR_ADC_CHANNEL,
        .capacitor_voltage_adc_channel = CAPACITOR_VOLTAGE_ADC_CHANNEL,
        .output_enable_pin = OUTPUT_ENABLE_PIN,
        .charge_enable_pin = CHARGE_ENABLE_PIN
    };
    Power_Driver_Init(&power_driver, &power_config);

    // 配置输入驱动
    Input_ConfigTypeDef input_config = {
        .button_pin = BUTTON_PIN,
        .crank_pin = CRANK_PIN
    };
    Input_Driver_Init(&input_driver, &input_config);

    // 初始化服务
    LED_Service_Init(&led_service, &led_driver);
    Power_Service_Init(&power_service, &power_driver);
    Input_Service_Init(&input_service, &input_driver);

    // 初始状态关闭 LED 和输出
    LED_Service_SetBrightness(&led_service, LED_OFF);
    Power_Service_DisableOutput(&power_service);

    while (1) {
        // 轮询检测用户输入事件
        User_EventType user_event = Input_Service_GetUserEvent(&input_service);
        if (user_event == USER_EVENT_BUTTON_PRESSED) {
            // 按键按下，切换 LED 亮度
            LED_Service_ToggleBrightness(&led_service);
            if (LED_Service_GetBrightness(&led_service) != LED_OFF) {
                current_state = (LED_Service_GetBrightness(&led_service) == LED_LOW) ? STATE_LOW_BRIGHTNESS : STATE_HIGH_BRIGHTNESS;
            } else {
                current_state = STATE_OFF;
            }
        } else if (user_event == USER_EVENT_CRANKING_START) {
            // 开始手摇，使能稳压输出
            Power_Service_EnableOutput(&power_service);
        } else if (user_event == USER_EVENT_CRANKING_STOP) {
            // 停止手摇，如果电容电压过低，关闭稳压输出 (可选，可以根据实际需求决定)
            // 可以添加电容电压检测逻辑，如果电压低于某个阈值，则 Power_Service_DisableOutput(&power_service);
            // 这里简化处理，暂时不自动关闭输出，保持持续照明直到按键关闭
        }

        // 定期更新电压值 (例如，每 100ms 更新一次)
        HAL_TIM_Delay_ms(100);
        Power_Service_UpdateVoltage(&power_service);

        // 可以添加其他应用逻辑，例如根据电容电压调整亮度、低电量提示等

    }
}

3.5 配置模块 (Config)

config.h:

#ifndef CONFIG_H
#define CONFIG_H

// 硬件引脚配置 (根据实际硬件连接修改)
#define LED_PIN             GPIO_PIN_0
#define LED_PWM_CHANNEL     PWM_CHANNEL_1
#define GENERATOR_ADC_CHANNEL ADC_CHANNEL_0
#define CAPACITOR_VOLTAGE_ADC_CHANNEL ADC_CHANNEL_1
#define OUTPUT_ENABLE_PIN   GPIO_PIN_1
#define CHARGE_ENABLE_PIN   GPIO_PIN_2
#define BUTTON_PIN          GPIO_PIN_3
#define CRANK_PIN           GPIO_PIN_4

// PWM 配置
#define LED_PWM_FREQUENCY   1000
#define LED_PWM_DUTY_LOW    30
#define LED_PWM_DUTY_HIGH   80

// ... 其他系统配置参数，例如 ADC 分辨率、采样率、电压转换系数等

#endif // CONFIG_H

4. 测试与验证

• 单元测试: 对每个驱动模块和服务模块进行单元测试，验证其功能是否正确。例如，测试 LED_Driver_SetBrightness 函数是否能正确控制LED亮度，Power_Driver_GetGeneratorVoltage 函数是否能正确读取发电机电压。
• 集成测试: 将各个模块集成起来进行测试，验证模块之间的协同工作是否正常。例如，测试按键输入、LED亮度控制、电源管理等功能是否能按预期工作。
• 系统测试: 进行全面的系统测试，包括功能测试、性能测试、可靠性测试、功耗测试、用户体验测试等。模拟各种使用场景，验证系统是否满足所有需求。
• 硬件在环测试 (HIL): 使用仿真器或实际硬件进行测试，更接近真实运行环境，验证硬件和软件的协同工作。

5. 维护与升级

• 模块化设计: 分层架构和模块化设计使得代码易于维护和升级。修改或添加新功能时，只需要修改相应的模块，而不会影响其他模块。
• 代码注释: 代码中包含详细的注释，方便其他开发人员理解和维护代码。
• 版本控制: 使用Git等版本控制工具管理代码，方便代码版本管理和回溯。
• 固件升级: 预留固件升级接口（例如，通过USB或OTA），方便后续功能升级和bug修复。
• 日志记录: 可以添加日志记录功能，记录系统运行状态和错误信息，方便问题排查和分析。

6. 总结

这个手摇发电灯嵌入式系统项目，从需求分析、系统设计到代码实现，都采用了模块化、分层化的架构，旨在构建一个可靠、高效、可扩展的平台。代码实现部分提供了HAL层、驱动层、服务层和应用层的框架代码，并详细注释了各个模块的功能和实现思路。

为了满足3000行代码的要求，上述代码在实际项目中还需要进一步完善和扩展，例如：

• 更详细的HAL层实现: 根据具体的MCU芯片手册，完成GPIO、ADC、PWM、Timer等HAL层驱动的寄存器操作实现。
• 更完善的驱动层实现: 加入错误处理、参数校验、更复杂的控制逻辑等。例如，LED驱动可以支持更精细的亮度调节，电源驱动可以实现更智能的电源管理策略，输入驱动可以支持更复杂的按键事件处理。
• 更丰富的服务层功能: 例如，LED服务可以加入闪烁模式、呼吸灯模式等，电源服务可以加入电量显示、低电量报警等功能。
• USB驱动和应用: 如果需要USB功能，需要实现USB驱动，并添加相应的USB应用逻辑，例如USB充电、USB对外供电、USB数据通信等。
• 更完善的应用层逻辑: 实现更复杂的状态机管理、用户界面交互、错误处理、异常情况处理等。
• 添加详细的注释和文档: 为所有代码添加详细的注释，并编写项目文档，方便代码理解、维护和升级。
• 完善的测试代码: 编写单元测试、集成测试、系统测试代码，确保系统的稳定性和可靠性。

通过以上步骤，我们可以开发出一个功能完善、性能可靠、易于维护和升级的手摇发电灯嵌入式系统。这个项目实践了嵌入式系统开发的完整流程，并充分展示了高级嵌入式软件工程师在项目中的角色和职责。