RT-Thread-rt-thread 移植 eRPC 系列（二）之演示RT-Thread问答社区

rt-thread 移植 eRPC 系列（二）之演示

发布于 2022-08-22 10:38:36 浏览：1488 订阅该版

[tocm]

## 前言

前一篇文章，我们简单介绍了 erpc 是何物，以及不同环境下怎么编译 erpc。今天，我们通过两个小 demo 开启 erpc 之旅。

> 注：以下均在 Linux 系统环境中操作。

### hello eRPC

#### 编辑 IDL 文件

打开终端，进入工作路径。

新建文本文件，重命名保存为 "hello.erpc"。编辑文件，添加内容：

```
program hello

enum lockErrors
{
    ERR_OK = 0,
    ERR_OUTMEM,
    ERR_MAX,
}

interface Hello {
    sayHello(binary txInput) -> binary
}
```

> 注：IDL 语法见下篇文章，这里定义了一个叫 "hello" 的应用程序，仅定义了一个 "sayHello" 远程调用 api

#### 生成应用代码

执行命令 `erpcgen hello.erpc` 。生成四个文件 "hello_client.cpp"、 "hello_.h"、 "hello_server.cpp"、 "hello_server.h"。

新建并编辑源码文件 "client.cpp"

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <erpc_client_setup.h>
#include <erpc_port.h>
#include "hello.h"

static void free_binary_t_struct(binary_t *data)
{
    if (data->data) {
        erpc_free(data->data);
    }
}

int main(int argc, char *argv[])
{
    erpc_transport_t transport = erpc_transport_tcp_init("127.0.0.1", 5555, false);
    erpc_mbf_t message_buffer_factory = erpc_mbf_dynamic_init();
    erpc_client_init(transport, message_buffer_factory);
    char *msg = "hello erpc!";
    binary_t b = {(uint8_t *)msg, (uint32_t)strlen(msg)};
    binary_t *resp = sayHello(&b);
    if (resp != NULL) {
        char *buf = (char *)malloc(resp->dataLength + 1);
        strncpy(buf, (const char *)resp->data, resp->dataLength);
        buf[resp->dataLength] = '\0';
        printf("respond: %s\n", buf);
        free_binary_t_struct(resp);
        free(buf);
    }

erpc_transport_tcp_close();

return 0;
}
```

客户端程序，首先初始化创建 erpc 客户端服务，然后调用 "sayHello" 远程函数，给远程传参是一个二进制数据结构（这里填充的字符串），最后打印函数执行响应结果。

新建并编辑源码文件 "server.cpp"

```
#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <erpc_server_setup.h>
#include "hello_server.h"

binary_t *sayHello(const binary_t *input)
{
    struct timeval t_val;
    struct tm* tm_l = NULL;
    time_t tim_t;
    size_t len = 0;
    char *buf;

printf("ServerHello called\n");

buf = (char *)malloc(input->dataLength + 21);

strncpy(buf, (const char *)input->data, input->dataLength);

gettimeofday(&t_val, NULL);
    tim_t = t_val.tv_sec;
    tm_l = localtime(&tim_t);
    len = strftime(&buf[input->dataLength], 21, "@%Y-%m-%d %H:%M:%S", tm_l);
    len = strlen(buf);
    printf("data: %lu; %s\n", len, buf);
    return new binary_t{(uint8_t*)buf, (uint32_t)len};
}

int main(int argc, char *argv[])
{
    erpc_transport_t transport = erpc_transport_tcp_init("127.0.0.1", 5555, true);
    erpc_mbf_t message_buffer_factory = erpc_mbf_dynamic_init();
    erpc_server_init(transport, message_buffer_factory);
    erpc_add_service_to_server(create_Hello_service());
    while(1){
        erpc_server_run();
    }
    erpc_transport_tcp_close();

return 0;
}
```

首先创建服务端 erpc 服务，然后调用 "erpc_server_run" 等待客户端的调用请求。当有客户端调用 "sayHello" 函数时，服务端将接收到的字符拼接本地时间，然后再返回给客户端。参数是客户端传输给服务端的，返回值是服务端生成返回给了客户端。

> 注：服务端应用程序必须实现 `sayHello` 。这里是 "hello.erpc" 文件中定义的 `sayHello` 函数的实现

#### 编译应用程序

分别执行下面的两条命令，生成服务端和客户端程序。

```
g++ -Wall -I. -I/usr/local/include/erpc -L/usr/local/lib hello_server.cpp server.cpp -lerpc -lpthread -o server

g++ -Wall -I. -I/usr/local/include/erpc -L/usr/local/lib hello_client.cpp client.cpp -lerpc -lpthread -o client
```

> 注：其中的 erpc 库编译见上篇文章。

#### 执行程序

在一个终端里执行 `./server`， 另外一个终端里执行 `./client`。正常运行服务端打印

```
ServerHello called
data: 31; hello erpc!@2022-08-17 14:26:16
```

客户端响应

```
respond: hello erpc!@2022-08-17 14:26:16
```

运行结果符合预期。

![erpc_hello.gif](https://oss-club.rt-thread.org/uploads/20220822/79405eb3ca0811c3c363f4988e2faf51.gif "erpc_hello.gif")

### Matrix 乘法运算

#### 编辑 IDL 文件

matrix.erpc
```
program matrix;

const int32 matrix_size = 5;

type Matrix = int32[matrix_size][matrix_size];

interface MatrixServer
{
    matrixMultiply(in Matrix matrix1, in Matrix matrix2, out Matrix result) -> void
}
```

执行命令 `erpcgen matrix.erpc`。

#### 客户端应用程序源码

```
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <erpc_client_setup.h>
#include <erpc_port.h>
#include "matrix.h"

Matrix matrix1, matrix2, result = {{0}};
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            matrix1[i][j] = j+1;
            matrix2[i][j] = j+1;
        }
    }
printf("===== Matrix #1 =====\n");
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            printf("%08d  ", matrix1[i][j]);
        }
        printf(";\n");
    }
printf("===== Matrix #2 =====\n");
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            printf("%08d  ", matrix2[i][j]);
        }
        printf(";\n");
    }

// Call remote function matrixMultiply
    matrixMultiply(matrix1, matrix2, result);
printf("===== Result Matrix =====\n");
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            printf("%08d  ", result[i][j]);
        }
        printf(";\n");
    }

erpc_transport_tcp_close();

return 0;
}
```

客户端初始化了两个 5x5 的矩阵，并把这俩矩阵值打印输出。调用 "matrixMultiply" 后把计算结果矩阵的值打印输出。

#### 服务端程序源码

```
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <erpc_server_setup.h>
#include "matrix_server.h"

void matrixMultiply(Matrix matrix1, Matrix matrix2, Matrix result)
{
    int i, j, k;
printf("===== Matrix #1 =====\n");
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            printf("%08d  ", matrix1[i][j]);
        }
        printf(";\n");
    }
printf("===== Matrix #2 =====\n");
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            printf("%08d  ", matrix2[i][j]);
        }
        printf(";\n");
    }
    memset(result, 0, sizeof(Matrix));
    for (i = 0; i < 5; i++) {
        for (j = 0; j < 5; j++) {
            for (k = 0; k < 5; k++) {
                result[i][j] += matrix1[i][k] * matrix2[k][j];
            }
        }
    }
}

int main(int argc, char *argv[])
{
    erpc_transport_t transport = erpc_transport_tcp_init("127.0.0.1", 5555, true);
    erpc_mbf_t message_buffer_factory = erpc_mbf_dynamic_init();
    erpc_server_init(transport, message_buffer_factory);
    erpc_add_service_to_server(create_MatrixServer_service());
    while(1){
        erpc_server_run();
    }
    erpc_transport_tcp_close();

return 0;
}
```

"matrixMultiply" 函数远程端实现，计算结果放到 result 里。

> 注：服务端应用程序必须实现 `matrixMultiply` 。这里是 "matrix.erpc" 文件中定义的 `matrixMultiply` 函数的实现

#### 编译并运行

客户端有打印信息输出

```
$ ./client.exe
===== Matrix #1 =====
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
===== Matrix #2 =====
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
00000001  00000002  00000003  00000004  00000005  ;
===== Result Matrix =====
00000015  00000030  00000045  00000060  00000075  ;
00000015  00000030  00000045  00000060  00000075  ;
00000015  00000030  00000045  00000060  00000075  ;
00000015  00000030  00000045  00000060  00000075  ;
00000015  00000030  00000045  00000060  00000075  ;
```

改变 #1 #2 两个矩阵值，响应的矩阵乘结果也会变。

![erpc_matrix.gif](https://oss-club.rt-thread.org/uploads/20220822/82990c37ee88effec124593680d57251.gif "erpc_matrix.gif")

## 结束语

本篇文章旨在通过这两个小 demo 演示 eRPC 的使用操作。

首先编辑 eRPC 的 IDL 语言脚本文件；然后生成代码；最后编写客户端和服务端两边的代码。

当我们调用 `sayHello` 或者 `matrixMultiply` 函数时，就像是调用本地的函数一样，但是函数执行过程可能是本机的另外一个进程或者网络内其它计算机上运行的程序。

本文没有讲解 IDL 语法。下一篇，笔者尽可能多的讲讲 eRPC 中使用的 IDL 语法格式。

*** 相关文章 ***

[rt-thread 移植 eRPC 系列（一） 之 简介](https://club.rt-thread.org/ask/article/3acf471c19f2595f.html)