编程技术分享

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

0%

简介：项目计划打造一款集成桌面多媒体终端，功能包含：

发表于 分类于 ， ，

好的，作为一名高级嵌入式软件开发工程师，我将为您详细阐述这款集成桌面多媒体终端的代码设计架构，并提供相应的C代码实现。本项目旨在打造一个可靠、高效、可扩展的嵌入式系统平台，实现桌面多媒体终端的功能，并融入无线充电站的特性。
关注微信公众号，提前获取相关推文

项目简介回顾：

本项目目标是开发一款集成桌面多媒体终端，具备以下核心功能：

  1. 多媒体播放： 支持音频和视频文件的本地播放，具备高保真 (HiFi) 音频输出能力。
  2. 无线充电站： 集成无线充电功能，为兼容设备提供无线充电。
  3. 桌面终端： 提供用户友好的图形界面，方便用户操作和管理多媒体内容和设备功能。

代码设计架构：分层架构

为了实现可靠、高效、可扩展的系统，并遵循实践验证的方法，我将采用经典的分层架构来设计这款嵌入式系统的软件。分层架构将系统划分为多个独立的层，每一层都有明确的职责，层与层之间通过定义清晰的接口进行通信。这种架构的优势在于：

  • 模块化： 每个层都是独立的模块，易于开发、测试和维护。
  • 可重用性： 底层模块可以被上层模块复用，提高代码效率。
  • 可扩展性： 可以方便地添加新的功能模块，而不会影响到现有系统的稳定性。
  • 易于理解和维护： 清晰的层次结构使得代码易于理解和维护。

本项目的分层架构设计如下：

  1. 硬件抽象层 (Hardware Abstraction Layer, HAL)：

    • 职责： 直接与硬件交互，封装底层硬件操作，向上层提供统一的硬件访问接口。
    • 包含模块：
      • 芯片驱动： 针对特定芯片的驱动程序，例如处理器、内存控制器、时钟系统、中断控制器等。
      • 外设驱动： 各种外围设备的驱动程序，例如显示屏驱动、音频编解码器驱动、扬声器驱动、无线充电模块驱动、存储设备驱动 (SD卡、Flash)、输入设备驱动 (触摸屏、按键)、网络接口驱动 (WiFi、以太网) 等。
      • 板级支持包 (BSP)： 针对具体硬件平台的初始化代码、配置信息等。
    • 技术选型： 根据具体的硬件平台选择相应的驱动程序和BSP，例如基于ARM Cortex-M/A系列的处理器，可以使用厂商提供的SDK或者开源的驱动库。驱动开发语言主要为C语言，部分底层汇编代码。

  2. 操作系统层 (Operating System Layer, OS)：

    • 职责： 提供操作系统的核心服务，例如任务调度、内存管理、进程间通信、同步机制等，为上层应用提供运行环境。
    • 技术选型： 根据系统复杂度和实时性要求，可以选择不同的操作系统。
      • 实时操作系统 (RTOS)： 例如 FreeRTOS、RT-Thread、UCOS等，适用于对实时性要求较高的系统。本项目多媒体播放功能对实时性有一定要求，可以考虑使用RTOS。
      • 嵌入式Linux： 适用于功能复杂、资源丰富的系统，例如需要运行复杂的应用程序或者使用Linux生态中的软件库。如果系统资源允许，嵌入式Linux也是一个强大的选择。
    • 操作系统接口： 操作系统层向上层提供标准的操作系统接口 (OS API)，例如任务创建、信号量、互斥锁、消息队列等。

  3. 中间件层 (Middleware Layer)：

    • 职责： 提供通用的软件服务和功能模块，构建在操作系统层之上，为应用层提供更高级的抽象和功能支持。
    • 包含模块：
      • 多媒体框架： 处理音频和视频的编解码、播放、渲染等功能。例如 GStreamer、FFmpeg (libavcodec, libavformat, libavutil, libswscale, libswresample) 等开源库。
      • 图形用户界面 (GUI) 框架： 提供图形界面的创建、显示和交互功能。例如 Qt for Embedded Systems、LittlevGL (LVGL)、Embedded Wizard 等。
      • 网络协议栈： 实现网络通信功能，例如 TCP/IP 协议栈、HTTP 协议、WiFi 协议栈等。例如 lwIP、uIP 等轻量级协议栈，或者更完整的 Linux 网络协议栈。
      • 文件系统： 管理存储设备上的文件，提供文件读写、目录操作等功能。例如 FatFS、LittleFS、YAFFS2 等。
      • 数据库 (可选)： 如果需要存储结构化数据，例如媒体库信息、用户配置等，可以集成轻量级数据库，例如 SQLite。
      • 电源管理： 管理系统的电源模式，控制无线充电模块，实现节能和充电功能。
      • 设备管理： 管理系统中各种硬件设备，例如音频设备、显示设备、无线充电设备等。
      • 日志系统： 记录系统运行日志，方便调试和维护。
      • 配置管理： 管理系统的配置信息，例如网络配置、显示配置、音频配置等。
    • 技术选型： 中间件层的选择需要根据具体的功能需求和系统资源进行权衡。开源库是常用的选择，可以降低开发成本和缩短开发周期。

  4. 应用层 (Application Layer)：

    • 职责： 实现具体的应用功能，例如多媒体播放器应用、无线充电控制应用、用户界面应用等。
    • 包含模块：
      • 多媒体播放器应用： 提供用户界面，控制多媒体文件的播放、暂停、停止、音量调节、进度控制等功能。
      • 无线充电控制应用： 控制无线充电模块的启动、停止、状态显示等功能。
      • 系统设置应用： 提供系统配置界面，例如网络设置、显示设置、音频设置等。
      • 主界面应用： 整合各个应用模块，提供统一的用户入口和操作界面。
    • 技术选型： 应用层开发可以使用C、C++等语言，结合GUI框架进行用户界面开发。应用层逻辑需要充分利用中间件层提供的服务和功能。

代码实现 (C语言)：

由于篇幅限制，我无法提供完整的3000行代码，但我将分模块提供关键部分的代码示例，以展示上述分层架构在C语言中的具体实现。代码示例将涵盖HAL、OS、Middleware (部分) 和 Application 层的关键模块，并附带详细注释。

为了简化示例，我将选择以下技术栈：

  • 处理器： 假设为 ARM Cortex-M4 系列微控制器。
  • RTOS： FreeRTOS。
  • GUI： LittlevGL (LVGL)。
  • 音频编解码： 使用简单的 PCM 音频处理，不涉及复杂的编解码库 (在实际项目中需要使用成熟的编解码库，例如 libmad, FAAD2, FFmpeg 等)。
  • 无线充电： 假设使用简单的无线充电模块，通过 GPIO 控制。
  • 显示屏： 假设为 SPI 接口的 LCD 屏。

1. 硬件抽象层 (HAL)

  • 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
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

typedef enum {
    GPIO_PIN_0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    // ... 更多引脚定义
    GPIO_PIN_MAX
} gpio_pin_t;

typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT
} gpio_mode_t;

typedef enum {
    GPIO_LEVEL_LOW,
    GPIO_LEVEL_HIGH
} gpio_level_t;

void hal_gpio_init(gpio_pin_t pin, gpio_mode_t mode);
void hal_gpio_write(gpio_pin_t pin, gpio_level_t level);
gpio_level_t hal_gpio_read(gpio_pin_t pin);

#endif // HAL_GPIO_H
  • hal_gpio.c: 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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include "hal_gpio.h"
#include "stm32f4xx_hal.h" // 假设使用 STM32F4 系列 HAL 库，需要替换为实际硬件平台的 HAL 库

void hal_gpio_init(gpio_pin_t pin, gpio_mode_t mode) {
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_TypeDef* GPIOx;
    uint16_t GPIO_Pin;

    // 根据 pin 映射到具体的 GPIO 端口和引脚
    // ... (省略具体的 GPIO 端口和引脚映射代码，需要根据实际硬件连接配置)
    if (pin == GPIO_PIN_0) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_0;
    } else if (pin == GPIO_PIN_1) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_1;
    } // ... 更多引脚映射

    // 使能 GPIO 时钟 (需要根据实际硬件平台和时钟配置)
    __HAL_RCC_GPIOA_CLK_ENABLE(); // 示例，需要根据实际 GPIO 端口使能相应的时钟

    if (mode == GPIO_MODE_OUTPUT) {
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
    } else {
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;      // 输入模式
        GPIO_InitStruct.Pull = GPIO_NOPULL;          // 无上下拉
    }
    GPIO_InitStruct.Pin = GPIO_Pin;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; // 低速
    HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
}

void hal_gpio_write(gpio_pin_t pin, gpio_level_t level) {
    GPIO_TypeDef* GPIOx;
    uint16_t GPIO_Pin;

    // 根据 pin 映射到具体的 GPIO 端口和引脚 (同 hal_gpio_init)
    if (pin == GPIO_PIN_0) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_0;
    } else if (pin == GPIO_PIN_1) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_1;
    } // ... 更多引脚映射

    if (level == GPIO_LEVEL_HIGH) {
        HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_SET);
    } else {
        HAL_GPIO_WritePin(GPIOx, GPIO_Pin, GPIO_PIN_RESET);
    }
}

gpio_level_t hal_gpio_read(gpio_pin_t pin) {
    GPIO_TypeDef* GPIOx;
    uint16_t GPIO_Pin;

    // 根据 pin 映射到具体的 GPIO 端口和引脚 (同 hal_gpio_init)
    if (pin == GPIO_PIN_0) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_0;
    } else if (pin == GPIO_PIN_1) {
        GPIOx = GPIOA;
        GPIO_Pin = GPIO_PIN_1;
    } // ... 更多引脚映射

    if (HAL_GPIO_ReadPin(GPIOx, GPIO_Pin) == GPIO_PIN_SET) {
        return GPIO_LEVEL_HIGH;
    } else {
        return GPIO_LEVEL_LOW;
    }
}
  • hal_spi.h: SPI 驱动头文件 (用于 LCD 屏)
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
#ifndef HAL_SPI_H
#define HAL_SPI_H

typedef enum {
    SPI_INSTANCE_1,
    SPI_INSTANCE_2,
    // ... 更多 SPI 实例
    SPI_INSTANCE_MAX
} spi_instance_t;

typedef enum {
    SPI_MODE_MASTER,
    SPI_MODE_SLAVE
} spi_mode_t;

typedef enum {
    SPI_BAUDRATE_DIV2,
    SPI_BAUDRATE_DIV4,
    // ... 更多波特率分频
    SPI_BAUDRATE_MAX
} spi_baudrate_t;

void hal_spi_init(spi_instance_t instance, spi_mode_t mode, spi_baudrate_t baudrate);
void hal_spi_transmit(spi_instance_t instance, const uint8_t *data, uint16_t size);
uint8_t hal_spi_receive_byte(spi_instance_t instance);

#endif // HAL_SPI_H
  • hal_spi.c: SPI 驱动实现文件 (示例)
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
#include "hal_spi.h"
#include "stm32f4xx_hal.h" // 假设使用 STM32F4 系列 HAL 库

void hal_spi_init(spi_instance_t instance, spi_mode_t mode, spi_baudrate_t baudrate) {
    SPI_HandleTypeDef hspi;
    SPI_TypeDef* SPIx;

    // 根据 instance 映射到具体的 SPI 实例
    if (instance == SPI_INSTANCE_1) {
        SPIx = SPI1;
        __HAL_RCC_SPI1_CLK_ENABLE(); // 使能 SPI1 时钟
        hspi.Instance = SPI1;
    } else if (instance == SPI_INSTANCE_2) {
        SPIx = SPI2;
        __HAL_RCC_SPI2_CLK_ENABLE(); // 使能 SPI2 时钟
        hspi.Instance = SPI2;
    } // ... 更多 SPI 实例

    hspi.Init.Mode = (mode == SPI_MODE_MASTER) ? SPI_MODE_MASTER : SPI_MODE_SLAVE;
    hspi.Init.Direction = SPI_DIRECTION_2LINES; // 双线全双工
    hspi.Init.DataSize = SPI_DATASIZE_8BIT;      // 8 位数据
    hspi.Init.CLKPolarity = SPI_POLARITY_LOW;   // 时钟极性
    hspi.Init.CLKPhase = SPI_PHASE_1EDGE;      // 时钟相位
    hspi.Init.NSS = SPI_NSS_SOFT;              // 软件 NSS 管理
    hspi.Init.BaudRatePrescaler = (baudrate == SPI_BAUDRATE_DIV2) ? SPI_BAUDRATEPRESCALER_2 : SPI_BAUDRATEPRESCALER_4; // 波特率分频
    hspi.Init.FirstBit = SPI_FIRSTBIT_MSB;      // MSB First
    hspi.Init.TIMode = SPI_TIMODE_DISABLE;       // TI 模式禁用
    hspi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; // CRC 校验禁用
    hspi.Init.CRCPolynomial = 10;
    HAL_SPI_Init(&hspi);
}

void hal_spi_transmit(spi_instance_t instance, const uint8_t *data, uint16_t size) {
    SPI_HandleTypeDef hspi;
    // 根据 instance 获取 SPI 句柄 (同 hal_spi_init)
    if (instance == SPI_INSTANCE_1) {
        hspi.Instance = SPI1;
    } else if (instance == SPI_INSTANCE_2) {
        hspi.Instance = SPI2;
    } // ... 更多 SPI 实例

    HAL_SPI_Transmit(&hspi, (uint8_t*)data, size, HAL_MAX_DELAY); // 阻塞发送
}

uint8_t hal_spi_receive_byte(spi_instance_t instance) {
    SPI_HandleTypeDef hspi;
    uint8_t rx_data;
    // 根据 instance 获取 SPI 句柄 (同 hal_spi_init)
    if (instance == SPI_INSTANCE_1) {
        hspi.Instance = SPI1;
    } else if (instance == SPI_INSTANCE_2) {
        hspi.Instance = SPI2;
    } // ... 更多 SPI 实例

    HAL_SPI_Receive(&hspi, &rx_data, 1, HAL_MAX_DELAY); // 阻塞接收一个字节
    return rx_data;
}
  • hal_audio.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
#ifndef HAL_AUDIO_H
#define HAL_AUDIO_H

typedef enum {
    AUDIO_SAMPLE_RATE_8K,
    AUDIO_SAMPLE_RATE_16K,
    // ... 更多采样率
    AUDIO_SAMPLE_RATE_MAX
} audio_sample_rate_t;

typedef enum {
    AUDIO_BITS_PER_SAMPLE_8,
    AUDIO_BITS_PER_SAMPLE_16,
    // ... 更多位深
    AUDIO_BITS_PER_SAMPLE_MAX
} audio_bits_per_sample_t;

void hal_audio_init(audio_sample_rate_t sample_rate, audio_bits_per_sample_t bits_per_sample);
void hal_audio_play_pcm(const uint8_t *data, uint32_t size); // 播放 PCM 数据
void hal_audio_set_volume(uint8_t volume); // 设置音量 (0-100)
void hal_audio_pause();
void hal_audio_resume();
void hal_audio_stop();

#endif // HAL_AUDIO_H
  • hal_audio.c: 音频驱动实现文件 (简化示例，使用 DAC 输出 PCM 数据)
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
#include "hal_audio.h"
#include "stm32f4xx_hal.h" // 假设使用 STM32F4 系列 HAL 库

// 假设使用 DAC1 通道 1 输出音频
#define AUDIO_DAC_INSTANCE DAC1
#define AUDIO_DAC_CHANNEL  DAC_CHANNEL_1

void hal_audio_init(audio_sample_rate_t sample_rate, audio_bits_per_sample_t bits_per_sample) {
    DAC_HandleTypeDef hdac;
    DAC_ChannelConfTypeDef sConfig = {0};

    __HAL_RCC_DAC_CLK_ENABLE(); // 使能 DAC 时钟

    hdac.Instance = AUDIO_DAC_INSTANCE;
    HAL_DAC_Init(&hdac);

    sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE; // 禁用输出缓冲
    HAL_DAC_ConfigChannel(&hdac, &sConfig, AUDIO_DAC_CHANNEL);

    // 可以根据 sample_rate 配置定时器，用于 DAC 定时触发 (DMA 方式播放需要)
    // ... (定时器配置代码省略)
}

void hal_audio_play_pcm(const uint8_t *data, uint32_t size) {
    // 简化示例：直接循环输出 PCM 数据到 DAC (实际项目需要使用 DMA 方式)
    for (uint32_t i = 0; i < size; i++) {
        HAL_DAC_SetValue(&hdac, AUDIO_DAC_CHANNEL, DAC_ALIGN_8B_R, data[i]);
        HAL_Delay(1); // 简单延时模拟采样间隔，实际需要根据采样率计算精确延时或使用定时器触发
    }
}

void hal_audio_set_volume(uint8_t volume) {
    // 简化示例：音量控制直接映射到 DAC 输出值范围 (实际项目需要更精细的音量控制算法)
    uint32_t dac_value = (volume * 4095) / 100; // 将 0-100 音量映射到 0-4095 DAC 值 (12位 DAC)
    // 注意：这种简单的音量控制可能会导致音质失真，实际项目需要更专业的音量控制方法
}

void hal_audio_pause() {
    // 暂停音频播放 (实际需要根据具体的播放方式实现暂停逻辑)
    // 例如：停止定时器触发，停止 DMA 传输等
}

void hal_audio_resume() {
    // 恢复音频播放 (实际需要根据具体的播放方式实现恢复逻辑)
    // 例如：启动定时器触发，启动 DMA 传输等
}

void hal_audio_stop() {
    // 停止音频播放 (实际需要根据具体的播放方式实现停止逻辑)
    // 例如：停止定时器触发，停止 DMA 传输，清空 DMA 缓冲区等
}
  • hal_wireless_charging.h: 无线充电驱动头文件 (简化示例)
1
2
3
4
5
6
7
8
9
#ifndef HAL_WIRELESS_CHARGING_H
#define HAL_WIRELESS_CHARGING_H

void hal_wireless_charging_init();
void hal_wireless_charging_start();
void hal_wireless_charging_stop();
uint8_t hal_wireless_charging_get_status(); // 返回充电状态 (0: 空闲, 1: 充电中, 2: 充满, ...)

#endif // HAL_WIRELESS_CHARGING_H
  • hal_wireless_charging.c: 无线充电驱动实现文件 (简化示例，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
#include "hal_wireless_charging.h"
#include "hal_gpio.h"

#define WIRELESS_CHARGE_EN_PIN GPIO_PIN_2 // 假设无线充电使能引脚为 GPIO_PIN_2
#define WIRELESS_CHARGE_STATUS_PIN GPIO_PIN_3 // 假设无线充电状态引脚为 GPIO_PIN_3

void hal_wireless_charging_init() {
    hal_gpio_init(WIRELESS_CHARGE_EN_PIN, GPIO_MODE_OUTPUT);
    hal_gpio_init(WIRELESS_CHARGE_STATUS_PIN, GPIO_MODE_INPUT);
    hal_wireless_charging_stop(); // 默认停止充电
}

void hal_wireless_charging_start() {
    hal_gpio_write(WIRELESS_CHARGE_EN_PIN, GPIO_LEVEL_HIGH); // 使能无线充电模块
}

void hal_wireless_charging_stop() {
    hal_gpio_write(WIRELESS_CHARGE_EN_PIN, GPIO_LEVEL_LOW);  // 禁用无线充电模块
}

uint8_t hal_wireless_charging_get_status() {
    if (hal_gpio_read(WIRELESS_CHARGE_STATUS_PIN) == GPIO_LEVEL_HIGH) {
        return 1; // 假设高电平表示充电中
    } else {
        return 0; // 假设低电平表示空闲或其他状态
    }
}

2. 操作系统层 (OS) - FreeRTOS 示例

  • osal_task.h: 任务管理抽象层头文件 (简化示例)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef OSAL_TASK_H
#define OSAL_TASK_H

#include <stdint.h>

typedef void (*task_func_t)(void *pvParameters);

typedef struct {
    char const *pcName;
    uint16_t usStackDepth;
    UBaseType_t uxPriority;
    task_func_t pvTaskCode;
    void *pvParameters;
    TaskHandle_t *pxCreatedTask;
} osal_task_config_t;

typedef void *osal_task_handle_t; // 使用 void* 抽象任务句柄

osal_task_handle_t osal_task_create(const osal_task_config_t *config);
void osal_task_delete(osal_task_handle_t task_handle);
void osal_task_delay(uint32_t ms);

#endif // OSAL_TASK_H
  • osal_task.c: 任务管理抽象层实现文件 (FreeRTOS 封装)
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
#include "osal_task.h"
#include "FreeRTOS.h"
#include "task.h"

osal_task_handle_t osal_task_create(const osal_task_config_t *config) {
    TaskHandle_t task_handle;
    if (xTaskCreate(config->pvTaskCode,
                    config->pcName,
                    config->usStackDepth,
                    config->pvParameters,
                    config->uxPriority,
                    &task_handle) == pdPASS) {
        return (osal_task_handle_t)task_handle;
    } else {
        return NULL; // 任务创建失败
    }
}

void osal_task_delete(osal_task_handle_t task_handle) {
    vTaskDelete((TaskHandle_t)task_handle);
}

void osal_task_delay(uint32_t ms) {
    vTaskDelay(pdMS_TO_TICKS(ms));
}

3. 中间件层 (Middleware) - 部分示例

  • audio_player.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
33
34
35
36
37
#ifndef AUDIO_PLAYER_H
#define AUDIO_PLAYER_H

#include <stdint.h>

typedef enum {
    AUDIO_FORMAT_PCM,
    // ... 更多音频格式 (MP3, AAC, FLAC 等，实际项目需要支持更多格式)
    AUDIO_FORMAT_MAX
} audio_format_t;

typedef enum {
    AUDIO_PLAYER_STATE_STOPPED,
    AUDIO_PLAYER_STATE_PLAYING,
    AUDIO_PLAYER_STATE_PAUSED
} audio_player_state_t;

typedef struct {
    audio_format_t format;
    uint8_t *data;
    uint32_t data_size;
    audio_sample_rate_t sample_rate;
    audio_bits_per_sample_t bits_per_sample;
} audio_source_t;

typedef void (*audio_player_callback_t)(audio_player_state_t state); // 播放状态回调

void audio_player_init();
void audio_player_set_source(const audio_source_t *source);
void audio_player_play();
void audio_player_pause();
void audio_player_stop();
void audio_player_set_volume(uint8_t volume);
audio_player_state_t audio_player_get_state();
void audio_player_register_callback(audio_player_callback_t callback);

#endif // AUDIO_PLAYER_H
  • audio_player.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
#include "audio_player.h"
#include "hal_audio.h"
#include "osal_task.h"
#include <string.h> // memset

static audio_source_t current_source;
static audio_player_state_t player_state = AUDIO_PLAYER_STATE_STOPPED;
static audio_player_callback_t player_callback = NULL;

void audio_player_init() {
    memset(&current_source, 0, sizeof(audio_source_t));
    hal_audio_init(AUDIO_SAMPLE_RATE_16K, AUDIO_BITS_PER_SAMPLE_16); // 默认初始化参数
}

void audio_player_set_source(const audio_source_t *source) {
    memcpy(&current_source, source, sizeof(audio_source_t));
}

void audio_player_play() {
    if (player_state != AUDIO_PLAYER_STATE_PLAYING && current_source.data != NULL) {
        player_state = AUDIO_PLAYER_STATE_PLAYING;
        hal_audio_resume(); // 恢复音频硬件
        hal_audio_play_pcm(current_source.data, current_source.data_size); // 播放 PCM 数据 (简化示例)
        audio_player_stop(); // 播放完成后停止 (简化示例)
        if (player_callback != NULL) {
            player_callback(player_state); // 调用回调函数
        }
    }
}

void audio_player_pause() {
    if (player_state == AUDIO_PLAYER_STATE_PLAYING) {
        player_state = AUDIO_PLAYER_STATE_PAUSED;
        hal_audio_pause();
        if (player_callback != NULL) {
            player_callback(player_state);
        }
    }
}

void audio_player_stop() {
    if (player_state != AUDIO_PLAYER_STATE_STOPPED) {
        player_state = AUDIO_PLAYER_STATE_STOPPED;
        hal_audio_stop();
        if (player_callback != NULL) {
            player_callback(player_state);
        }
    }
}

void audio_player_set_volume(uint8_t volume) {
    hal_audio_set_volume(volume);
}

audio_player_state_t audio_player_get_state() {
    return player_state;
}

void audio_player_register_callback(audio_player_callback_t callback) {
    player_callback = callback;
}
  • gui_manager.h: GUI 管理器中间件头文件 (使用 LittlevGL 示例)
1
2
3
4
5
6
7
8
9
10
11
12
#ifndef GUI_MANAGER_H
#define GUI_MANAGER_H

#include "lvgl.h"

void gui_init();
void gui_task_handler(); // GUI 任务处理函数，需要周期性调用
lv_obj_t* gui_create_label(lv_obj_t *parent, const char *text);
lv_obj_t* gui_create_button(lv_obj_t *parent, const char *text, lv_event_cb_t event_cb);
// ... 更多 GUI 组件创建函数

#endif // GUI_MANAGER_H
  • gui_manager.c: GUI 管理器中间件实现文件 (使用 LittlevGL 示例)
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
#include "gui_manager.h"
#include "lvgl/lvgl.h"
#include "hal_display.h" // 假设有显示屏 HAL 驱动

void gui_init() {
    lv_init(); // LVGL 初始化

    // 初始化显示屏驱动接口 (需要根据具体的显示屏驱动实现)
    lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);
    disp_drv.hor_res = 240; // 假设屏幕水平分辨率
    disp_drv.ver_res = 320; // 假设屏幕垂直分辨率
    disp_drv.flush_cb = hal_display_flush; // 假设显示屏 HAL 驱动提供 flush 函数
    lv_disp_drv_register(&disp_drv);

    // 初始化输入设备驱动接口 (触摸屏或按键，这里省略输入设备驱动示例)
    // ...

    // 创建默认主题
    lv_theme_default_init(NULL, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED), LV_THEME_DARK);
}

void gui_task_handler() {
    lv_task_handler(); // LVGL 任务处理
}

lv_obj_t* gui_create_label(lv_obj_t *parent, const char *text) {
    lv_obj_t *label = lv_label_create(parent);
    lv_label_set_text(label, text);
    return label;
}

lv_obj_t* gui_create_button(lv_obj_t *parent, const char *text, lv_event_cb_t event_cb) {
    lv_obj_t *btn = lv_btn_create(parent);
    lv_obj_t *label = gui_create_label(btn, text);
    lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
    lv_obj_add_event_cb(btn, event_cb, LV_EVENT_CLICKED, NULL);
    return btn;
}

// ... 更多 GUI 组件创建函数

4. 应用层 (Application) - 部分示例

  • 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include "osal_task.h"
#include "gui_manager.h"
#include "audio_player.h"
#include "hal_wireless_charging.h"
#include "stdio.h" // printf

// 定义任务堆栈大小和优先级
#define TASK_GUI_STACK_SIZE      2048
#define TASK_GUI_PRIORITY        2
#define TASK_AUDIO_PLAYER_STACK_SIZE 1024
#define TASK_AUDIO_PLAYER_PRIORITY   3

// GUI 任务函数
void gui_task(void *pvParameters);
// 音频播放器任务函数
void audio_player_task(void *pvParameters);

// 按钮点击事件回调函数
void btn_play_event_handler(lv_event_t *e);
void btn_pause_event_handler(lv_event_t *e);
void btn_stop_event_handler(lv_event_t *e);
void btn_charge_start_event_handler(lv_event_t *e);
void btn_charge_stop_event_handler(lv_event_t *e);

// 音频播放状态回调函数
void audio_player_state_callback(audio_player_state_t state);

int main() {
    // HAL 初始化 (省略，需要根据具体硬件平台进行初始化，例如时钟、外设等)
    // ...

    gui_init(); // GUI 初始化
    audio_player_init(); // 音频播放器初始化
    hal_wireless_charging_init(); // 无线充电初始化

    // 注册音频播放状态回调
    audio_player_register_callback(audio_player_state_callback);

    // 创建 GUI 任务
    osal_task_config_t gui_task_config = {
        .pcName = "GUI Task",
        .usStackDepth = TASK_GUI_STACK_SIZE,
        .uxPriority = TASK_GUI_PRIORITY,
        .pvTaskCode = gui_task,
        .pvParameters = NULL,
        .pxCreatedTask = NULL
    };
    osal_task_create(&gui_task_config);

    // 创建音频播放器任务
    osal_task_config_t audio_player_task_config = {
        .pcName = "Audio Player Task",
        .usStackDepth = TASK_AUDIO_PLAYER_STACK_SIZE,
        .uxPriority = TASK_AUDIO_PLAYER_PRIORITY,
        .pvTaskCode = audio_player_task,
        .pvParameters = NULL,
        .pxCreatedTask = NULL
    };
    osal_task_create(&audio_player_task_config);

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

    // 理论上不应该执行到这里
    return 0;
}

// GUI 任务函数
void gui_task(void *pvParameters) {
    lv_obj_t *screen = lv_scr_act(); // 获取当前屏幕

    // 创建播放控制按钮
    lv_obj_t *btn_play = gui_create_button(screen, "Play", btn_play_event_handler);
    lv_obj_align(btn_play, LV_ALIGN_TOP_LEFT, 10, 10);
    lv_obj_t *btn_pause = gui_create_button(screen, "Pause", btn_pause_event_handler);
    lv_obj_align_below_to_left(btn_pause, btn_play, 10, 0);
    lv_obj_t *btn_stop = gui_create_button(screen, "Stop", btn_stop_event_handler);
    lv_obj_align_below_to_left(btn_stop, btn_pause, 10, 0);

    // 创建无线充电控制按钮
    lv_obj_t *btn_charge_start = gui_create_button(screen, "Charge Start", btn_charge_start_event_handler);
    lv_obj_align(btn_charge_start, LV_ALIGN_TOP_RIGHT, -10, 10);
    lv_obj_t *btn_charge_stop = gui_create_button(screen, "Charge Stop", btn_charge_stop_event_handler);
    lv_obj_align_below_to_right(btn_charge_stop, btn_charge_start, 10, 0);

    // 创建状态标签
    lv_obj_t *state_label = gui_create_label(screen, "Stopped");
    lv_obj_align(state_label, LV_ALIGN_CENTER, 0, 0);
    lv_obj_add_flag(state_label, LV_OBJ_FLAG_HIDDEN); // 初始隐藏状态标签

    while (1) {
        gui_task_handler(); // 处理 GUI 任务
        osal_task_delay(10); // 10ms 延时
    }
}

// 音频播放器任务函数
void audio_player_task(void *pvParameters) {
    // 准备音频数据 (示例，实际项目需要从文件或网络读取音频数据)
    static uint8_t pcm_data[] = {
        // 简单的正弦波 PCM 数据示例 (8位, 16kHz)
        0x80, 0x88, 0x90, 0x98, 0xA0, 0xA8, 0xB0, 0xB8, 0xC0, 0xC8, 0xD0, 0xD8, 0xE0, 0xE8, 0xF0, 0xF8,
        0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38, 0x40, 0x48, 0x50, 0x58, 0x60, 0x68, 0x70, 0x78,
        // ... 更多 PCM 数据
    };
    audio_source_t audio_source = {
        .format = AUDIO_FORMAT_PCM,
        .data = pcm_data,
        .data_size = sizeof(pcm_data),
        .sample_rate = AUDIO_SAMPLE_RATE_16K,
        .bits_per_sample = AUDIO_BITS_PER_SAMPLE_8
    };
    audio_player_set_source(&audio_source);

    while (1) {
        // 音频播放任务逻辑 (简化示例，实际项目需要更复杂的播放控制逻辑)
        osal_task_delay(100); // 100ms 延时
    }
}

// 按钮点击事件回调函数
void btn_play_event_handler(lv_event_t *e) {
    audio_player_play();
}

void btn_pause_event_handler(lv_event_t *e) {
    audio_player_pause();
}

void btn_stop_event_handler(lv_event_t *e) {
    audio_player_stop();
}

void btn_charge_start_event_handler(lv_event_t *e) {
    hal_wireless_charging_start();
    printf("Wireless charging started\n"); // 打印调试信息
}

void btn_charge_stop_event_handler(lv_event_t *e) {
    hal_wireless_charging_stop();
    printf("Wireless charging stopped\n"); // 打印调试信息
}

// 音频播放状态回调函数
void audio_player_state_callback(audio_player_state_t state) {
    lv_obj_t *state_label = lv_obj_get_child(lv_scr_act(), 4); // 获取状态标签 (假设是第5个子对象，需要根据实际情况调整)
    if (state_label != NULL) {
        if (state == AUDIO_PLAYER_STATE_PLAYING) {
            lv_label_set_text(state_label, "Playing");
            lv_obj_clear_flag(state_label, LV_OBJ_FLAG_HIDDEN); // 显示状态标签
        } else if (state == AUDIO_PLAYER_STATE_PAUSED) {
            lv_label_set_text(state_label, "Paused");
            lv_obj_clear_flag(state_label, LV_OBJ_FLAG_HIDDEN); // 显示状态标签
        } else if (state == AUDIO_PLAYER_STATE_STOPPED) {
            lv_label_set_text(state_label, "Stopped");
            lv_obj_clear_flag(state_label, LV_OBJ_FLAG_HIDDEN); // 显示状态标签
        }
    }
    printf("Audio player state changed: %d\n", state); // 打印调试信息
}

测试验证和维护升级

  • 测试验证：
    • 单元测试： 针对HAL层和中间件层的各个模块进行单元测试，例如 GPIO 驱动、SPI 驱动、音频播放器等，验证模块功能的正确性。
    • 集成测试： 将各个模块集成起来进行测试，例如 HAL 层和中间件层的集成测试，验证层与层之间接口的正确性。
    • 系统测试： 对整个系统进行功能测试、性能测试、稳定性测试、兼容性测试等，验证系统是否满足需求。
    • 用户测试： 邀请用户进行体验测试，收集用户反馈，改进系统。
  • 维护升级：
    • 模块化设计： 分层架构的模块化设计使得系统易于维护和升级。
    • 版本控制： 使用版本控制系统 (例如 Git) 管理代码，方便代码的维护和版本迭代。
    • OTA 升级： 支持 Over-The-Air (OTA) 升级，方便用户远程升级系统固件。
    • 日志系统： 完善的日志系统可以帮助开发人员快速定位和解决问题。
    • 清晰的接口文档： 提供清晰的接口文档，方便后续维护和二次开发。

总结

上述代码示例展示了基于分层架构的嵌入式桌面多媒体终端的软件设计框架。实际项目开发中，需要根据具体的需求和硬件平台，选择合适的技术栈，完善各个模块的功能，并进行充分的测试验证。分层架构能够有效地组织代码，提高代码的可维护性和可扩展性，是构建复杂嵌入式系统的有效方法。

请注意，以上代码示例为了演示架构和关键功能，进行了大幅简化，例如音频编解码、文件系统、网络功能、更完善的 GUI 界面等功能都没有完整实现。在实际项目中，需要根据具体需求进行详细设计和完整实现。同时，为了达到3000行代码的要求，需要进一步扩展各个模块的功能实现，例如完善音频编解码器的集成、文件系统的支持、网络协议栈的接入、更丰富的 GUI 组件和交互逻辑、电源管理模块的详细实现、更全面的错误处理和异常情况处理等等。 希望这个详细的架构设计和代码示例能够帮助您理解嵌入式系统开发流程和代码架构设计。

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