嵌入式系统进程通信学习报告

幼儿园蛋小黄

300人浏览 · 2026-08-29 18:26:41

幼儿园蛋小黄 · 2026-08-29 18:26:41 发布

1. 引言

进程通信（Inter-Process Communication，IPC）是嵌入式系统开发中的核心基础能力之一。在嵌入式环境中，系统往往需要同时运行多个任务或进程，它们之间需要交换数据、同步状态、协调资源。与通用操作系统相比，嵌入式系统的资源受限、实时性要求高、硬件平台多样，因此进程通信机制的设计与选型显得尤为重要。

本报告围绕嵌入式系统中的进程通信展开，首先介绍进程通信的基本概念与常见机制，然后结合嵌入式环境的特点分析各机制的适用场景，最后通过一个实际案例说明如何在嵌入式项目中设计与实现进程通信。

2. 进程通信概述

2.1 什么是进程通信

进程通信是指多个进程（或线程、任务）之间交换数据与信息的机制。在嵌入式系统中，进程可以理解为独立运行的任务单元，它们共享 CPU、内存和外设资源，需要通过通信机制实现协作。

2.2 为什么需要进程通信

嵌入式系统通常由多个功能模块组成，例如传感器采集、数据处理、通信协议栈、用户界面等。这些模块往往以独立任务的形式运行，彼此之间需要：

传递采集到的数据；
通知事件的发生；
协调对共享资源的访问；
实现主从控制或流水线处理。

没有可靠的进程通信机制，多任务系统将无法协同工作。

2.3 嵌入式进程通信的特点

嵌入式环境下的进程通信与通用系统相比有以下显著特点：

资源受限：内存、CPU 和功耗有限，通信机制必须轻量高效；
实时性要求：许多嵌入式系统对响应时间有硬性要求，通信延迟必须可控；
硬件相关性：通信机制往往与具体硬件（如中断控制器、DMA、共享内存）紧密相关；
可靠性要求：在工业控制、汽车电子等领域，通信失败可能导致严重后果。

3. 常见进程通信机制

3.1 管道（Pipe）

管道是最基本的进程通信方式，提供单向数据流。在嵌入式 Linux 系统中，管道常用于父子进程之间的简单数据传递。

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

int main() {
    int fd[2];
    char buf[64];
    pipe(fd);

    if (fork() == 0) {
        // 子进程：写入数据
        close(fd[0]);
        write(fd[1], "hello from child", 16);
        close(fd[1]);
    } else {
        // 父进程：读取数据
        close(fd[1]);
        read(fd[0], buf, sizeof(buf));
        printf("parent received: %s\n", buf);
        close(fd[0]);
    }
    return 0;
}

特点：实现简单，但只能单向传输，且数据量有限。

3.2 消息队列（Message Queue）

消息队列允许进程以消息为单位交换数据，支持双向通信和优先级。嵌入式系统中常用 POSIX 消息队列或 System V 消息队列。

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

int main() {
    mqd_t mq;
    struct mq_attr attr;
    char msg[128] = "sensor data: 25.6C";

    attr.mq_maxmsg = 10;
    attr.mq_msgsize = 128;
    mq = mq_open("/sensor_queue", O_CREAT | O_WRONLY, 0644, &attr);
    mq_send(mq, msg, strlen(msg) + 1, 0);
    mq_close(mq);
    return 0;
}

特点：消息有边界，支持优先级，适合结构化数据传输。

3.3 共享内存（Shared Memory）

共享内存是最快的进程通信方式，多个进程直接映射同一块物理内存区域，无需内核拷贝。

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd = shm_open("/shared_buf", O_CREAT | O_RDWR, 0644);
    ftruncate(fd, 1024);
    char *ptr = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    strcpy(ptr, "shared data from process A");
    munmap(ptr, 1024);
    close(fd);
    return 0;
}

特点：传输效率最高，但需要额外的同步机制（如信号量）来避免竞争。

3.4 信号量（Semaphore）

信号量本身不传输数据，而是用于进程间的同步与互斥，常与共享内存配合使用。

#include <stdio.h>
#include <semaphore.h>
#include <fcntl.h>

int main() {
    sem_t *sem = sem_open("/my_sem", O_CREAT, 0644, 1);
    sem_wait(sem);   // P 操作：申请资源
    // 临界区代码
    sem_post(sem);   // V 操作：释放资源
    sem_close(sem);
    return 0;
}

特点：轻量、高效，是解决共享资源竞争的基础工具。

3.5 套接字（Socket）

套接字不仅支持本机进程通信，还支持跨网络通信，适用于分布式嵌入式系统。

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sock, (struct sockaddr *)&addr, sizeof(addr));
    listen(sock, 5);
    int client = accept(sock, NULL, NULL);
    char buf[128];
    recv(client, buf, sizeof(buf), 0);
    printf("received: %s\n", buf);
    close(client);
    close(sock);
    return 0;
}

特点：灵活通用，但开销较大，适合网络化嵌入式场景。

3.6 信号（Signal）

信号用于异步通知进程某个事件发生，适合处理中断类事件。

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

void handler(int sig) {
    printf("received signal %d\n", sig);
}

int main() {
    signal(SIGUSR1, handler);
    while (1) {
        sleep(1);
    }
    return 0;
}

特点：异步通知能力强，但携带信息量少，不适合大数据传输。

4. 嵌入式环境下的选型分析

通信机制	传输效率	实时性	实现复杂度	适用场景
管道	低	中	低	父子进程简单数据传递
消息队列	中	中	中	结构化消息、任务间解耦
共享内存	高	高	高	大数据量、高频数据交换
信号量	高	高	低	资源互斥、任务同步
套接字	中	中	高	网络通信、分布式系统
信号	低	高	低	异步事件通知

在资源受限的 MCU 裸机环境中，通常使用全局变量加中断保护或轻量级消息队列；在嵌入式 Linux 环境中，则可根据需求灵活组合共享内存、消息队列和信号量。

5. 综合案例：传感器数据采集与处理

下面设计一个典型的嵌入式数据采集系统，包含采集任务、处理任务和显示任务，通过消息队列与共享内存实现通信。

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

#define MSG_SIZE 64

// 采集任务：模拟读取传感器数据并发送到消息队列
void *collect_task(void *arg) {
    mqd_t mq = mq_open("/data_queue", O_CREAT | O_WRONLY, 0644, NULL);
    int count = 0;
    while (count < 5) {
        char msg[MSG_SIZE];
        snprintf(msg, MSG_SIZE, "sample %d: %.1f", count, 20.0 + count * 1.5);
        mq_send(mq, msg, strlen(msg) + 1, 0);
        printf("[collect] %s\n", msg);
        count++;
        usleep(500000);
    }
    mq_close(mq);
    return NULL;
}

// 处理任务：从消息队列读取数据并处理
void *process_task(void *arg) {
    mqd_t mq = mq_open("/data_queue", O_RDONLY);
    char buf[MSG_SIZE];
    int count = 0;
    while (count < 5) {
        mq_receive(mq, buf, MSG_SIZE, NULL);
        printf("[process] got: %s\n", buf);
        count++;
    }
    mq_close(mq);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, collect_task, NULL);
    pthread_create(&t2, NULL, process_task, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    mq_unlink("/data_queue");
    return 0;
}