编程技术分享

分享编程知识，探讨技术创新

0%

简介：手头有一个暴力风扇 要么丢了它 要么利用它 我选择了后者 所以就DIY了一个可爱的除尘器

发表于 分类于 ， ，

好的，作为一名高级嵌入式软件开发工程师，我将根据你提供的嵌入式产品图片（DIY除尘器）以及你的需求，详细阐述最适合的代码设计架构，并提供具体的C代码实现，以展示一个完整的嵌入式系统开发流程。
关注微信公众号，提前获取相关推文

项目背景与需求分析

从你提供的图片和描述来看，这是一个基于暴力风扇的DIY除尘器项目。项目的核心需求是利用暴力风扇制作一个便携式、可控的除尘设备。 我们可以进一步细化需求：

  1. 基本功能:

    • 风扇控制: 能够启动和停止风扇。
    • 模式选择 (可选): 可能需要不同的风速模式（例如：低速、高速）以适应不同的除尘场景。
    • 按键操作: 通过按键进行风扇的控制。
    • 指示灯 (可选): 通过LED指示设备状态（例如：工作状态、模式状态）。

  2. 性能需求:

    • 高效除尘: 利用暴力风扇的强大风力，实现快速有效的除尘。
    • 低功耗 (可选): 如果设备需要电池供电，则需要考虑功耗优化。
    • 稳定可靠: 系统需要稳定运行，避免意外故障。
    • 快速响应: 按键操作需要及时响应。

  3. 可扩展性需求:

    • 功能扩展: 未来可能需要添加新的功能，例如：
      • 灰尘传感器：自动检测灰尘浓度，智能调节风速。
      • 定时功能：设定定时除尘任务。
      • 无线控制：通过蓝牙或Wi-Fi进行远程控制。
    • 硬件扩展: 可能需要更换或升级硬件组件。

  4. 维护升级需求:

    • 代码可维护性: 代码需要结构清晰、易于理解和修改。
    • 软件升级: 预留软件升级的接口和机制，方便后续功能更新和bug修复。

系统设计架构

基于以上需求分析，我将采用分层模块化架构来设计这个嵌入式系统。这种架构具有良好的可读性、可维护性和可扩展性，非常适合嵌入式系统的开发。

1. 架构分层:

  • 硬件抽象层 (HAL - Hardware Abstraction Layer):

    • 作用： 隐藏底层硬件的具体细节，为上层软件提供统一的硬件访问接口。
    • 组件： GPIO驱动、定时器驱动、ADC驱动 (如果使用灰尘传感器)、PWM驱动 (如果需要风速控制)、中断控制器驱动等。
    • 优势： 提高了代码的可移植性，当更换硬件平台时，只需要修改HAL层代码即可。

  • 板级支持包 (BSP - Board Support Package):

    • 作用： 初始化硬件平台，配置系统时钟、外设等，为操作系统和应用程序提供运行环境。
    • 组件： 启动代码、时钟配置、中断向量表、外设初始化代码等。
    • 优势： 针对特定的硬件平台进行定制，确保系统能够正确运行。

  • 操作系统层 (OS Layer):

    • 作用： 管理系统资源，提供任务调度、内存管理、同步机制等服务，提高系统的并发性和实时性。
    • 组件： 实时操作系统内核 (RTOS) 例如 FreeRTOS 或 RT-Thread (这里我们假设使用 FreeRTOS)。
    • 优势： 简化复杂系统的开发，提高代码的可重用性和可维护性。

  • 中间件层 (Middleware Layer):

    • 作用： 提供通用的软件模块和服务，例如：
      • 日志管理模块： 记录系统运行日志，方便调试和维护。
      • 配置管理模块： 管理系统配置参数。
      • 电源管理模块 (可选)： 管理系统功耗，实现低功耗模式。
      • 状态机管理模块 (可选)： 管理设备的不同状态和状态转换。
    • 优势： 减少重复开发，提高开发效率，增强系统的功能。

  • 应用层 (Application Layer):

    • 作用： 实现具体的业务逻辑，例如：
      • 风扇控制模块： 处理风扇的启动、停止、调速等功能。
      • 按键处理模块： 检测按键输入，触发相应的操作。
      • 指示灯控制模块 (可选)： 控制LED指示灯的状态。
      • 灰尘传感器模块 (可选)： 读取灰尘传感器数据，进行智能控制。
    • 优势： 专注于实现业务逻辑，代码结构清晰，易于维护和扩展。

2. 模块划分:

在每一层内部，我们也将进行模块化设计，将功能划分为独立的模块。例如，在应用层，我们可以划分出以下模块：

  • fan_control_module: 负责风扇的控制逻辑。
  • button_module: 负责按键的检测和处理。
  • led_module: 负责LED指示灯的控制 (可选)。
  • dust_sensor_module: 负责灰尘传感器的读取和处理 (可选)。
  • app_task: 应用层的主任务，负责协调各个模块的工作。

3. 架构图示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
+---------------------+
|    应用层 (Application Layer)     |
| +-----------------+ +-----------------+ +-----------------+ ... |
| |  fan_control_module | |  button_module  | |   led_module    | ... |
| +-----------------+ +-----------------+ +-----------------+ ... |
+---------------------+
|   中间件层 (Middleware Layer)    |
| +-----------------+ +-----------------+ ... |
| |  log_module     | | config_module   | ... |
| +-----------------+ +-----------------+ ... |
+---------------------+
|  操作系统层 (OS Layer)     |
| +-----------------+      |
| |   FreeRTOS Kernel   |      |
| +-----------------+      |
+---------------------+
| 板级支持包 (BSP - Board Support Package) |
| +-----------------+ +-----------------+ ... |
| |  startup_code   | |  clock_config   | ... |
| +-----------------+ +-----------------+ ... |
+---------------------+
|  硬件抽象层 (HAL - Hardware Abstraction Layer) |
| +-----------------+ +-----------------+ +-----------------+ ... |
| |  gpio_driver    | | timer_driver    | |  pwm_driver    | ... |
| +-----------------+ +-----------------+ +-----------------+ ... |
+---------------------+
|      硬件平台 (Hardware Platform)       |
| +-----------------+ +-----------------+ +-----------------+ ... |
| |    Microcontroller | |     Fan      | |    Button     | ... |
| +-----------------+ +-----------------+ +-----------------+ ... |
+---------------------+

C 代码实现 (基于 STM32 和 FreeRTOS 示例)

为了演示代码实现，我将选择常用的 STM32 微控制器平台和 FreeRTOS 实时操作系统。 以下代码将包含 HAL 层、BSP 层、OS 层、中间件层 (简化) 和应用层的代码示例，并逐步完善功能。

请注意: 由于篇幅限制，以下代码只提供框架和关键部分的实现，并会逐步展开和完善。 完整的 3000+ 行代码需要包含更详细的驱动实现、错误处理、配置选项以及更完善的中间件模块。

1. HAL 层 (Hardware Abstraction Layer)

  • hal_gpio.h: GPIO 驱动头文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

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

// GPIO 端口定义 (根据 STM32 具体型号修改)
typedef enum {
    GPIO_PORT_A,
    GPIO_PORT_B,
    GPIO_PORT_C,
    // ... 其他端口
    GPIO_PORT_MAX
} gpio_port_t;

// GPIO 引脚定义
typedef enum {
    GPIO_PIN_0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    // ... 其他引脚
    GPIO_PIN_MAX
} gpio_pin_t;

// GPIO 方向定义
typedef enum {
    GPIO_DIRECTION_INPUT,
    GPIO_DIRECTION_OUTPUT
} gpio_direction_t;

// GPIO 输出状态定义
typedef enum {
    GPIO_OUTPUT_LOW,
    GPIO_OUTPUT_HIGH
} gpio_output_state_t;

// 初始化 GPIO 引脚
void hal_gpio_init(gpio_port_t port, gpio_pin_t pin, gpio_direction_t direction);

// 设置 GPIO 输出状态
void hal_gpio_set_output(gpio_port_t port, gpio_pin_t pin, gpio_output_state_t state);

// 读取 GPIO 输入状态
bool hal_gpio_get_input(gpio_port_t port, gpio_pin_t pin);

#endif // HAL_GPIO_H
  • hal_gpio.c: GPIO 驱动源文件 (简化实现，实际需要根据 STM32 寄存器操作)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "hal_gpio.h"

void hal_gpio_init(gpio_port_t port, gpio_pin_t pin, gpio_direction_t direction) {
    //  根据 port 和 pin 选择 GPIO 寄存器组 (例如 STM32 GPIOA, GPIOB...)
    //  根据 direction 配置输入/输出模式
    //  这里简化实现，实际需要操作 STM32 的 GPIO 寄存器
    (void)port; // 避免编译警告
    (void)pin;
    (void)direction;
    // ...  配置 GPIO 寄存器的代码 ...
    // 例如： 使能 GPIO 时钟, 配置 MODER, OTYPER, PUPDR 等寄存器
}

void hal_gpio_set_output(gpio_port_t port, gpio_pin_t pin, gpio_output_state_t state) {
    //  根据 port 和 pin 选择 GPIO 寄存器组
    //  根据 state 设置输出高/低电平
    //  这里简化实现，实际需要操作 STM32 的 GPIO 寄存器
    (void)port;
    (void)pin;
    (void)state;
    // ... 设置 GPIO 输出寄存器的代码 ...
    // 例如： 操作 ODR 寄存器
}

bool hal_gpio_get_input(gpio_port_t port, gpio_pin_t pin) {
    //  根据 port 和 pin 选择 GPIO 寄存器组
    //  读取输入状态
    //  这里简化实现，实际需要操作 STM32 的 GPIO 寄存器
    (void)port;
    (void)pin;
    // ... 读取 GPIO 输入寄存器的代码 ...
    // 例如： 读取 IDR 寄存器
    return false; // 默认返回 false，实际需要读取 GPIO 输入
}
  • hal_timer.h: 定时器驱动头文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#ifndef HAL_TIMER_H
#define HAL_TIMER_H

#include <stdint.h>

// 定时器 ID 定义 (根据 STM32 具体型号修改)
typedef enum {
    TIMER_1,
    TIMER_2,
    // ... 其他定时器
    TIMER_MAX
} timer_id_t;

// 定时器模式定义
typedef enum {
    TIMER_MODE_ONE_SHOT,
    TIMER_MODE_PERIODIC
} timer_mode_t;

// 定时器回调函数类型
typedef void (*timer_callback_t)(void);

// 初始化定时器
void hal_timer_init(timer_id_t timer_id, timer_mode_t mode, uint32_t period_ms, timer_callback_t callback);

// 启动定时器
void hal_timer_start(timer_id_t timer_id);

// 停止定时器
void hal_timer_stop(timer_id_t timer_id);

#endif // HAL_TIMER_H
  • hal_timer.c: 定时器驱动源文件 (简化实现，实际需要根据 STM32 寄存器操作)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include "hal_timer.h"

void hal_timer_init(timer_id_t timer_id, timer_mode_t mode, uint32_t period_ms, timer_callback_t callback) {
    //  根据 timer_id 选择定时器寄存器组 (例如 STM32 TIM1, TIM2...)
    //  配置定时器模式 (单次触发/周期触发)
    //  计算并设置预分频器和计数器值，以实现 period_ms 的定时周期
    //  设置中断回调函数
    //  这里简化实现，实际需要操作 STM32 的定时器寄存器
    (void)timer_id;
    (void)mode;
    (void)period_ms;
    (void)callback;
    // ... 配置定时器寄存器的代码 ...
    // 例如： 使能定时器时钟, 配置 PSC, ARR, CR1 等寄存器, 使能中断
}

void hal_timer_start(timer_id_t timer_id) {
    //  启动定时器
    //  这里简化实现，实际需要操作 STM32 的定时器寄存器
    (void)timer_id;
    // ... 启动定时器的代码 ...
    // 例如： 设置 CR1 寄存器的 CEN 位
}

void hal_timer_stop(timer_id_t timer_id) {
    //  停止定时器
    //  这里简化实现，实际需要操作 STM32 的定时器寄存器
    (void)timer_id;
    // ... 停止定时器的代码 ...
    // 例如： 清除 CR1 寄存器的 CEN 位
}

// 定时器中断处理函数 (需要根据 STM32 中断向量表配置)
// void TIMx_IRQHandler(void) {
//     //  清除中断标志位
//     //  调用注册的回调函数
//     // ... 中断处理代码 ...
// }
  • hal_pwm.h: PWM 驱动头文件 (用于风速控制，可选)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef HAL_PWM_H
#define HAL_PWM_H

#include <stdint.h>

// PWM 通道 ID 定义 (根据 STM32 具体型号修改)
typedef enum {
    PWM_CHANNEL_1,
    PWM_CHANNEL_2,
    // ... 其他通道
    PWM_CHANNEL_MAX
} pwm_channel_t;

// 初始化 PWM 通道
void hal_pwm_init(pwm_channel_t channel, uint32_t frequency_hz);

// 设置 PWM 占空比 (0-100%)
void hal_pwm_set_duty_cycle(pwm_channel_t channel, uint8_t duty_cycle);

// 启动 PWM 输出
void hal_pwm_start(pwm_channel_t channel);

// 停止 PWM 输出
void hal_pwm_stop(pwm_channel_t channel);

#endif // HAL_PWM_H
  • hal_pwm.c: PWM 驱动源文件 (简化实现，实际需要根据 STM32 寄存器操作)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include "hal_pwm.h"

void hal_pwm_init(pwm_channel_t channel, uint32_t frequency_hz) {
    //  根据 channel 选择 PWM 通道 (例如 STM32 TIMx_CHx)
    //  配置 PWM 频率 (需要计算预分频器和计数器值)
    //  配置 PWM 输出模式
    //  这里简化实现，实际需要操作 STM32 的 PWM 寄存器
    (void)channel;
    (void)frequency_hz;
    // ... 配置 PWM 寄存器的代码 ...
    // 例如： 使能定时器时钟, 配置 PSC, ARR, CCMRx, CCER 等寄存器
}

void hal_pwm_set_duty_cycle(pwm_channel_t channel, uint8_t duty_cycle) {
    //  根据 channel 选择 PWM 通道
    //  根据 duty_cycle 计算并设置 PWM 占空比
    //  这里简化实现，实际需要操作 STM32 的 PWM 寄存器
    (void)channel;
    (void)duty_cycle;
    // ... 设置 PWM 占空比的代码 ...
    // 例如： 操作 CCRx 寄存器
}

void hal_pwm_start(pwm_channel_t channel) {
    //  启动 PWM 输出
    //  这里简化实现，实际需要操作 STM32 的 PWM 寄存器
    (void)channel;
    // ... 启动 PWM 输出的代码 ...
    // 例如： 设置 CCER 寄存器的 CCxE 位
}

void hal_pwm_stop(pwm_channel_t channel) {
    //  停止 PWM 输出
    //  这里简化实现，实际需要操作 STM32 的 PWM 寄存器
    (void)channel;
    // ... 停止 PWM 输出的代码 ...
    // 例如： 清除 CCER 寄存器的 CCxE 位
}

2. BSP 层 (Board Support Package)

  • bsp.h: BSP 头文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#ifndef BSP_H
#define BSP_H

#include "hal_gpio.h"
#include "hal_timer.h"
#include "hal_pwm.h"

//  定义硬件相关的引脚和外设 (根据实际硬件连接修改)

// 风扇控制引脚
#define FAN_GPIO_PORT         GPIO_PORT_A
#define FAN_GPIO_PIN          GPIO_PIN_0

// 按键引脚
#define BUTTON_GPIO_PORT      GPIO_PORT_A
#define BUTTON_GPIO_PIN       GPIO_PIN_1

// 指示灯引脚 (可选)
#define LED_GPIO_PORT         GPIO_PORT_A
#define LED_GPIO_PIN          GPIO_PIN_2

// PWM 通道 (用于风速控制，可选)
#define FAN_PWM_CHANNEL       PWM_CHANNEL_1

// 系统初始化函数
void bsp_init(void);

#endif // BSP_H
  • bsp.c: BSP 源文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "bsp.h"

void bsp_init(void) {
    //  初始化系统时钟 (如果需要，例如配置 HSE 外部晶振, PLL 等)
    //  ... 时钟初始化代码 ...

    //  初始化 GPIO
    hal_gpio_init(FAN_GPIO_PORT, FAN_GPIO_PIN, GPIO_DIRECTION_OUTPUT);
    hal_gpio_init(BUTTON_GPIO_PORT, BUTTON_GPIO_PIN, GPIO_DIRECTION_INPUT);
    // hal_gpio_init(LED_GPIO_PORT, LED_GPIO_PIN, GPIO_DIRECTION_OUTPUT); // 如果使用指示灯

    //  初始化 PWM (如果需要风速控制)
    // hal_pwm_init(FAN_PWM_CHANNEL, 25000); // 例如 25kHz PWM 频率

    //  ... 其他外设初始化 ...
}

3. 操作系统层 (OS Layer) - FreeRTOS

  • FreeRTOSConfig.h: FreeRTOS 配置文件 (需要根据具体硬件平台和需求进行配置)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* FreeRTOSConfig.h 示例配置 (需要根据实际情况修改) */

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H

#define configTICK_RATE_HZ              ( ( TickType_t ) 1000 )  // 1ms Tick 频率
#define configCPU_CLOCK_HZ              ( ( uint32_t ) 72000000UL ) // 假设 72MHz 系统时钟
#define configMAX_PRIORITIES            ( 5 )        // 最大任务优先级
#define configMINIMAL_STACK_SIZE        ( ( unsigned short ) 128 ) // 最小堆栈大小
#define configTOTAL_HEAP_SIZE           ( ( size_t ) ( 1024 * 5 ) ) // 堆大小 5KB

// ... 其他 FreeRTOS 配置选项 ...

#endif /* FREERTOS_CONFIG_H */
  • FreeRTOS 源码: 需要将 FreeRTOS 源码添加到工程中 (例如 FreeRTOS kernel 和 portable 目录)。 具体步骤请参考 FreeRTOS 官方文档和 STM32 的 FreeRTOS 移植指南。

4. 中间件层 (Middleware Layer) - 简化示例

  • log_module.h: 日志模块头文件 (简化示例)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef LOG_MODULE_H
#define LOG_MODULE_H

#include <stdio.h>
#include <stdarg.h>

// 初始化日志模块
void log_init(void);

// 打印日志信息
void log_info(const char *format, ...);
void log_warn(const char *format, ...);
void log_error(const char *format, ...);

#endif // LOG_MODULE_H
  • log_module.c: 日志模块源文件 (简化示例，使用串口输出)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "log_module.h"
#include <stdarg.h>

void log_init(void) {
    //  初始化串口 (用于日志输出，需要 HAL 层串口驱动支持)
    // ... 串口初始化代码 ...
}

void log_info(const char *format, ...) {
    va_list args;
    va_start(args, format);
    printf("[INFO] ");
    vprintf(format, args);
    printf("\r\n");
    va_end(args);
}

void log_warn(const char *format, ...) {
    va_list args;
    va_start(args, format);
    printf("[WARN] ");
    vprintf(format, args);
    printf("\r\n");
    va_end(args);
}

void log_error(const char *format, ...) {
    va_list args;
    va_start(args, format);
    printf("[ERROR] ");
    vprintf(format, args);
    printf("\r\n");
    va_end(args);
}

5. 应用层 (Application Layer)

  • fan_control_module.h: 风扇控制模块头文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef FAN_CONTROL_MODULE_H
#define FAN_CONTROL_MODULE_H

// 初始化风扇控制模块
void fan_control_init(void);

// 启动风扇
void fan_control_start(void);

// 停止风扇
void fan_control_stop(void);

// 设置风扇速度 (如果支持 PWM 调速)
void fan_control_set_speed(uint8_t speed_percent); // 0-100%

#endif // FAN_CONTROL_MODULE_H
  • fan_control_module.c: 风扇控制模块源文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include "fan_control_module.h"
#include "bsp.h"
#include "hal_gpio.h"
#include "hal_pwm.h"
#include "log_module.h"

#define FAN_SPEED_OFF      0
#define FAN_SPEED_LOW      30  // 假设低速 30% 占空比
#define FAN_SPEED_HIGH     100 // 假设高速 100% 占空比

static uint8_t current_fan_speed = FAN_SPEED_OFF;

void fan_control_init(void) {
    log_info("Fan Control Module Initialized");
    fan_control_stop(); // 初始状态停止风扇
}

void fan_control_start(void) {
    if (current_fan_speed == FAN_SPEED_OFF) {
        current_fan_speed = FAN_SPEED_HIGH; // 默认启动高速
        hal_gpio_set_output(FAN_GPIO_PORT, FAN_GPIO_PIN, GPIO_OUTPUT_HIGH); // 直接控制 GPIO 启动风扇 (简单 ON/OFF 控制)
        // hal_pwm_set_duty_cycle(FAN_PWM_CHANNEL, FAN_SPEED_HIGH); // 如果使用 PWM 调速
        // hal_pwm_start(FAN_PWM_CHANNEL);
        log_info("Fan Started (Speed: %d%%)", current_fan_speed);
    } else {
        log_warn("Fan already running");
    }
}

void fan_control_stop(void) {
    if (current_fan_speed != FAN_SPEED_OFF) {
        current_fan_speed = FAN_SPEED_OFF;
        hal_gpio_set_output(FAN_GPIO_PORT, FAN_GPIO_PIN, GPIO_OUTPUT_LOW); // 停止风扇
        // hal_pwm_stop(FAN_PWM_CHANNEL);
        log_info("Fan Stopped");
    } else {
        log_warn("Fan already stopped");
    }
}

void fan_control_set_speed(uint8_t speed_percent) {
    if (speed_percent >= 0 && speed_percent <= 100) {
        current_fan_speed = speed_percent;
        // hal_pwm_set_duty_cycle(FAN_PWM_CHANNEL, speed_percent); // 如果使用 PWM 调速
        log_info("Set Fan Speed to %d%%", speed_percent);
    } else {
        log_error("Invalid fan speed percentage: %d", speed_percent);
    }
}
  • button_module.h: 按键模块头文件
1
2
3
4
5
6
7
8
9
10
#ifndef BUTTON_MODULE_H
#define BUTTON_MODULE_H

// 初始化按键模块
void button_init(void);

// 获取按键状态 (按下/释放)
bool button_is_pressed(void);

#endif // BUTTON_MODULE_H
  • button_module.c: 按键模块源文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "button_module.h"
#include "bsp.h"
#include "hal_gpio.h"
#include "log_module.h"
#include "FreeRTOS.h"
#include "task.h"

#define BUTTON_DEBOUNCE_DELAY_MS  50 // 按键消抖延时

static bool last_button_state = false; // 上一次按键状态
static TickType_t last_debounce_time = 0;

void button_init(void) {
    log_info("Button Module Initialized");
}

bool button_is_pressed(void) {
    bool current_button_state = hal_gpio_get_input(BUTTON_GPIO_PORT, BUTTON_GPIO_PIN); // 读取按键输入

    if (current_button_state != last_button_state) {
        if (xTaskGetTickCount() - last_debounce_time > pdMS_TO_TICKS(BUTTON_DEBOUNCE_DELAY_MS)) {
            last_debounce_time = xTaskGetTickCount();
            if (current_button_state == false) { // 假设按键按下时为低电平
                log_info("Button Pressed");
                last_button_state = current_button_state;
                return true; // 返回 true 表示按键被按下
            }
        }
    }
    last_button_state = current_button_state;
    return false; // 默认返回 false，表示按键未被按下
}
  • led_module.h: 指示灯模块头文件 (可选)
1
2
3
4
5
6
7
8
9
10
#ifndef LED_MODULE_H
#define LED_MODULE_H

// 初始化指示灯模块
void led_init(void);

// 设置指示灯状态
void led_set_state(bool on);

#endif // LED_MODULE_H
  • led_module.c: 指示灯模块源文件 (可选)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "led_module.h"
#include "bsp.h"
#include "hal_gpio.h"
#include "log_module.h"

void led_init(void) {
    log_info("LED Module Initialized");
    led_set_state(false); // 初始状态关闭指示灯
}

void led_set_state(bool on) {
    if (on) {
        hal_gpio_set_output(LED_GPIO_PORT, LED_GPIO_PIN, GPIO_OUTPUT_HIGH);
        log_info("LED ON");
    } else {
        hal_gpio_set_output(LED_GPIO_PORT, LED_GPIO_PIN, GPIO_OUTPUT_LOW);
        log_info("LED OFF");
    }
}
  • app_main.c: 应用层主文件 (主任务和系统初始化)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include "bsp.h"
#include "log_module.h"
#include "fan_control_module.h"
#include "button_module.h"
#include "led_module.h" // 可选
#include "FreeRTOS.h"
#include "task.h"

// 应用主任务
void app_task_entry(void *pvParameters);

int main(void) {
    //  系统初始化 (BSP, 日志, 各个模块)
    bsp_init();
    log_init();
    fan_control_init();
    button_init();
    // led_init(); // 如果使用指示灯

    log_info("System Initialized");

    //  创建应用主任务
    BaseType_t xReturned;
    xReturned = xTaskCreate(
        app_task_entry,       /* 任务函数 */
        "AppTask",            /* 任务名称 */
        configMINIMAL_STACK_SIZE * 2, /* 任务堆栈大小 */
        NULL,                 /* 任务参数 */
        tskIDLE_PRIORITY + 2, /* 任务优先级 (高于 Idle 任务) */
        NULL                  /* 任务句柄 */
    );

    if (xReturned != pdPASS) {
        log_error("Failed to create App Task");
        while(1); // 任务创建失败，进入错误循环
    }

    //  启动 FreeRTOS 任务调度器
    vTaskStartScheduler();

    //  正常情况下不会执行到这里
    return 0;
}

void app_task_entry(void *pvParameters) {
    (void)pvParameters; // 避免编译警告

    bool fan_state = false; // 记录风扇当前状态

    while (1) {
        //  检测按键状态
        if (button_is_pressed()) {
            fan_state = !fan_state; // 切换风扇状态
            if (fan_state) {
                fan_control_start();
                // led_set_state(true); // 如果使用指示灯
            } else {
                fan_control_stop();
                // led_set_state(false); // 如果使用指示灯
            }
        }

        //  其他应用逻辑 (例如：灰尘传感器数据处理, 模式切换等) 可以添加到这里

        vTaskDelay(pdMS_TO_TICKS(50)); // 任务延时 50ms
    }
}

编译和运行

  1. 准备开发环境: 安装 STM32 开发工具链 (例如 Keil MDK, IAR EWARM, STM32CubeIDE) 和 FreeRTOS 源码。
  2. 创建工程: 创建一个 STM32 工程，选择合适的 STM32 型号。
  3. 添加代码: 将以上代码文件 ( .h 和 .c 文件) 添加到工程中。
  4. 配置工程:
    • 配置编译器和链接器选项。
    • 配置 FreeRTOS 相关的宏定义和选项 (在 FreeRTOSConfig.h 中)。
    • 配置启动文件和链接脚本 (根据 STM32 和开发工具链的要求)。
  5. 编译和下载: 编译工程，生成可执行文件，并将程序下载到 STM32 开发板上。
  6. 连接硬件: 将暴力风扇、按键、指示灯 (可选) 等硬件连接到 STM32 开发板的相应引脚。
  7. 测试: 上电运行程序，测试按键控制风扇的功能。

测试验证和维护升级

1. 测试验证:

  • 单元测试: 针对每个模块进行单元测试，例如测试 fan_control_module 的启动、停止、调速功能，button_module 的按键检测功能等。
  • 集成测试: 测试模块之间的集成，例如测试按键模块和风扇控制模块的协同工作。
  • 系统测试: 进行整体系统测试，验证系统是否满足所有需求，例如除尘效率、响应速度、稳定性等。
  • 性能测试: 测试系统的性能指标，例如功耗、实时性等。
  • 可靠性测试: 进行长时间运行测试，验证系统的可靠性和稳定性。

2. 维护升级:

  • 代码维护: 遵循良好的编码规范，编写清晰易懂的代码，添加必要的注释，方便后续维护和修改。
  • Bug 修复: 及时修复测试过程中发现的 bug。
  • 功能升级: 根据需求增加新功能，例如灰尘传感器智能控制、定时除尘、无线控制等。
  • 软件升级机制: 可以预留软件升级接口，例如通过串口或 OTA (Over-The-Air) 进行固件升级，方便后续功能更新和 bug 修复。
  • 版本控制: 使用版本控制工具 (例如 Git) 管理代码，方便代码的版本管理和团队协作。
  • 日志记录: 完善日志模块，记录系统运行日志，方便调试和故障排查。

代码扩展方向 (增加功能)

为了达到 3000+ 行代码的要求，并进一步完善系统功能，我们可以扩展以下方面：

  • 灰尘传感器集成:
    • 添加灰尘传感器驱动 (HAL 层)。
    • 在应用层添加 dust_sensor_module，负责读取和处理灰尘传感器数据。
    • 实现智能风速控制：根据灰尘浓度自动调节风扇速度。
  • 模式切换:
    • 添加模式管理模块，实现不同的除尘模式 (例如：低速模式、高速模式、智能模式)。
    • 通过按键或组合按键进行模式切换。
    • 通过指示灯显示当前模式。
  • 定时功能:
    • 添加定时器模块 (HAL 层和中间件层)。
    • 实现定时除尘功能，用户可以设定定时任务。
  • 无线控制 (蓝牙或 Wi-Fi):
    • 添加无线模块驱动 (HAL 层)。
    • 添加无线通信协议栈 (例如 Bluetooth Low Energy 或 TCP/IP)。
    • 开发手机 APP 或上位机软件，实现远程控制和数据监控。
  • 更完善的中间件模块:
    • 配置管理模块 (更完善的配置参数管理)。
    • 电源管理模块 (低功耗模式实现)。
    • 状态机管理模块 (更复杂的状态管理和转换)。
  • 更详细的 HAL 和 BSP 实现: 根据具体的 STM32 型号和外设，编写更详细、更完善的 HAL 层驱动和 BSP 代码 (例如 GPIO 的各种模式配置、定时器的各种模式和中断处理、PWM 的各种模式和参数配置、ADC 驱动、串口驱动等等)。
  • 错误处理机制: 完善代码的错误处理机制，例如硬件初始化错误、外设操作错误、内存分配错误等，增加错误日志记录和处理。
  • 更丰富的指示灯效果: 使用 RGB LED 或多个 LED，实现更丰富的指示灯效果，例如显示不同模式、错误状态、电量状态等。
  • 代码注释和文档: 为代码添加详细的注释，编写用户手册和开发文档，提高代码的可读性和可维护性。

通过以上扩展方向，可以逐步完善 DIY 除尘器的功能，并使代码量达到 3000+ 行的要求，同时也能更全面地展示一个嵌入式系统的开发流程和代码实现。

希望以上详细的架构设计和代码示例能够帮助你理解嵌入式系统开发流程，并为你 DIY 除尘器项目提供参考。 请记住，实际的嵌入式系统开发是一个复杂的过程，需要根据具体的需求和硬件平台进行灵活调整和优化。
Error executing command: Traceback (most recent call last):
File “/home/tong/bin/desc_img3.py”, line 73, in
for chunk in client.models.generate_content_stream(
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/models.py”, line 3722, in generate_content_stream
for response_dict in self.api_client.request_streamed(
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/_api_client.py”, line 344, in request_streamed
for chunk in session_response.segments():
File “/home/tong/.local/lib/python3.10/site-packages/google/genai/_api_client.py”, line 133, in segments
yield json.loads(str(chunk, ‘utf-8’))
File “/usr/lib/python3.10/json/init.py”, line 346, in loads
return _default_decoder.decode(s)
File “/usr/lib/python3.10/json/decoder.py”, line 337, in decode
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
File “/usr/lib/python3.10/json/decoder.py”, line 353, in raw_decode
obj, end = self.scan_once(s, idx)
json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

欢迎关注我的其它发布渠道