1
// 嵌入式必备技能：指针操作
2
#include <stdint.h>
3

4
// 寄存器操作示例 (STM32)
5
#define RCC_BASE        0x40021000
6
#define RCC_APB2ENR     (*(volatile uint32_t *)(RCC_BASE + 0x18))
7

8
// 开启GPIOA时钟
9
RCC_APB2ENR |= (1 << 2);
10

11
// 内存管理示例
12
void *malloc(size_t size) {
13
    // 实现简单的内存分配
14
}
15

16
// 回调函数指针
17
typedef void (*callback_t)(int);
18
void register_callback(callback_t cb) {
19
    // 注册回调
20
}

1
// 链表节点定义
2
typedef struct Node {
3
    int data;
4
    struct Node *next;
5
} Node;
6

7
// 链表插入操作
8
Node* insert(Node *head, int value) {
9
    Node *newNode = malloc(sizeof(Node));
10
    newNode->data = value;
11
    newNode->next = head;
12
    return newNode;
13
}

1
// GPIO 配置示例 (STM32 HAL)
2
void GPIO_Init(void) {
3
    // LED - 输出模式
4
    GPIO_InitTypeDef GPIO_InitStruct = {0};
5
    GPIO_InitStruct.Pin = LED_PIN;
6
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
7
    GPIO_InitStruct.Pull = GPIO_NOPULL;
8
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
9
    HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);
10
}
11

12
// USART 配置
13
void UART_Init(void) {
14
    huart1.Instance = USART1;
15
    huart1.Init.BaudRate = 115200;
16
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
17
    huart1.Init.StopBits = UART_STOPBITS_1;
18
    huart1.Init.Parity = UART_PARITY_NONE;
19
    HAL_UART_Init(&huart1);
20
}
21

22
// I2C 读取传感器
23
HAL_StatusTypeDef Sensor_Read(uint8_t reg, uint8_t *data) {
24
    return HAL_I2C_Mem_Read(&hi2c1, SENSOR_ADDR, reg,
25
                           I2C_MEMADD_SIZE_8BIT, data, 1, 1000);
26
}

1
#include "FreeRTOS.h"
2
#include "task.h"
3

4
// 任务句柄
5
TaskHandle_t xTask1Handle = NULL;
6

7
// 任务1 - 高优先级
8
void vTask1(void *pvParameters) {
9
    while(1) {
10
        printf("Task 1 running\n");
11
        vTaskDelay(pdMS_TO_TICKS(100));
12
    }
13
}
14

15
// 任务2 - 低优先级
16
void vTask2(void *pvParameters) {
17
    TickType_t xLastWakeTime = xTaskGetTickCount();
18
    while(1) {
19
        printf("Task 2 running\n");
20
        vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(200));
21
    }
22
}
23

24
// 创建任务
25
void CreateTasks(void) {
26
    xTaskCreate(vTask1, "Task1", configMINIMAL_STACK_SIZE,
27
                NULL, 1, &xTask1Handle);
28
    xTaskCreate(vTask2, "Task2", configMINIMAL_STACK_SIZE,
29
                NULL, 1, NULL);
30
}

1
// 队列句柄
2
QueueHandle_t xQueue;
3

4
// 发送数据
5
void SenderTask(void *pvParameters) {
6
    int32_t value = 0;
7
    while(1) {
8
        value++;
9
        if(xQueueSend(xQueue, &value, pdMS_TO_TICKS(100)) == pdPASS) {
10
            printf("Sent: %ld\n", value);
11
        }
12
    }
13
}
14

15
// 接收数据
16
void ReceiverTask(void *pvParameters) {
17
    int32_t value;
18
    while(1) {
19
        if(xQueueReceive(xQueue, &value, portMAX_DELAY) == pdPASS) {
20
            printf("Received: %ld\n", value);
21
        }
22
    }
23
}

1
// 字符设备驱动示例
2
#include <linux/module.h>
3
#include <linux/kernel.h>
4
#include <linux/fs.h>
5
#include <linux/cdev.h>
6
#include <linux/device.h>
7

8
#define DEVICE_NAME "my_device"
9
#define CLASS_NAME "my_class"
10

11
static int major_number;
12
static struct class *device_class = NULL;
13
static struct device *device_struct = NULL;
14

15
static int dev_open(struct inode *inode, struct file *file) {
16
    printk(KERN_INFO "Device opened\n");
17
    return 0;
18
}
19

20
static int dev_release(struct inode *inode, struct file *file) {
21
    printk(KERN_INFO "Device closed\n");
22
    return 0;
23
}
24

25
static ssize_t dev_read(struct file *file, char __user *user_buffer,
26
                        size_t len, loff_t *offset) {
27
    printk(KERN_INFO "Read called\n");
28
    return 0;
29
}
30

31
static ssize_t dev_write(struct file *file, const char __user *user_buffer,
32
                         size_t len, loff_t *offset) {
33
    printk(KERN_INFO "Write called\n");
34
    return len;
35
}
36

37
static struct file_operations fops = {
38
    .owner = THIS_MODULE,
39
    .open = dev_open,
40
    .release = dev_release,
41
    .read = dev_read,
42
    .write = dev_write,
43
};
44

45
static int __init my_driver_init(void) {
46
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
47
    device_class = class_create(CLASS_NAME);
48
    device_struct = device_create(device_class, NULL,
49
                                  MKDEV(major_number, 0),
50
                                  NULL, DEVICE_NAME);
51
    printk(KERN_INFO "Driver loaded\n");
52
    return 0;
53
}
54

55
static void __exit my_driver_exit(void) {
56
    device_destroy(device_class, MKDEV(major_number, 0));
57
    class_destroy(device_class);
58
    unregister_chrdev(major_number, DEVICE_NAME);
59
    printk(KERN_INFO "Driver unloaded\n");
60
}
61

62
module_init(my_driver_init);
63
module_exit(my_driver_exit);
64
MODULE_LICENSE("GPL");
65
MODULE_AUTHOR("Embedded Engineer");
66
MODULE_DESCRIPTION("Simple Character Device Driver");

1
// ❌ 不好：硬编码魔法数字
2
if (status == 0x12) {
3
    // 做一些事情
4
}
5

6
// ✅ 好：使用有意义的常量
7
#define SENSOR_READY    0x12
8
if (status == SENSOR_READY) {
9
    // 传感器就绪，执行操作
10
}