08 SPI通信

1 SPI介绍

SPI(serial peripheral interface）的基本概念参考博客：CSDN博客文章

相比于I2C通信，SPI通信讲究的就是简单粗暴，需要什么信号就加上一根线，连片信号都有专门的信号线负责，带来的好处也非常明显。由于信号是直接驱动而不是类似与I2C这种上拉信号线输出高电平来防止烧毁器件的，所以通信速率相比于I2C可以做的很高。本文档板子使用的RK3568在主机模式下最大理论速率可以达到50MHz，从机模式下达到33MHz。

2 SPI板卡接口

板子引出的SPI引脚为SPI3。

3 SPI使用---命令行方法

3-1 设备树解析

提示

下文的文件路径：out/kernel/src_tmp/linux-5.10/arch/arm64/boot/dts/rockchip/需要先编译码源。

同上一小节，我们先在 rk3568.dtsi 文件中，SPI3控制器的基础定义如下：

spi3: spi@fe640000 {
    compatible = "rockchip,rk3066-spi";
    reg = <0x0 0xfe640000 0x0 0x1000>;
    interrupts = <GIC_SPI 106 IRQ_TYPE_LEVEL_HIGH>;
    #address-cells = <1>;
    #size-cells = <0>;
    clocks = <&cru CLK_SPI3>, <&cru PCLK_SPI3>;
    clock-names = "spiclk", "apb_pclk";
    dmas = <&dmac0 26>, <&dmac0 27>;
    dma-names = "tx", "rx";
    pinctrl-names = "default", "high_speed";
    pinctrl-0 = <&spi3m0_cs0 &spi3m0_cs1 &spi3m0_pins>;
    pinctrl-1 = <&spi3m0_cs0 &spi3m0_cs1 &spi3m0_pins_hs>;
    status = "disabled";
};

关键属性解析：

• compatible : 指定SPI控制器兼容性为"rockchip,rk3066-spi"
• reg : SPI3控制器寄存器基地址为0xfe640000，大小为4KB
• interrupts : 中断号为106，高电平触发
• clocks : 配置SPI时钟和APB时钟
• dmas : DMA通道配置，支持发送和接收
• pinctrl-0 : 默认引脚复用配置（使用m0模式）
• status : 默认状态为"disabled"（禁用）

再查看pinctrl子系统中，查看SPI3的引脚复用配置，在 rk3568-pinctrl.dtsi 文件中：

SPI3 M1模式引脚配置（SDK代码中使用的模式）：

spi3m1_pins: spi3m1-pins {
    rockchip,pins =
        /* spi3_clkm1 */
        <4 RK_PC2 2 &pcfg_pull_none>,
        /* spi3_misom1 */
        <4 RK_PC5 2 &pcfg_pull_none>,
        /* spi3_mosim1 */
        <4 RK_PC3 2 &pcfg_pull_none>;
};

spi3m1_cs0: spi3m1-cs0 {
    rockchip,pins =
        /* spi3_cs0m1 */
        <4 RK_PC6 2 &pcfg_pull_none>;
};

spi3m1_pins_hs: spi3m1-pins {
    rockchip,pins =
        /* spi3_clkm1 */
        <4 RK_PC2 2 &pcfg_pull_up_drv_level_1>,
        /* spi3_misom1 */
        <4 RK_PC5 2 &pcfg_pull_up_drv_level_1>,
        /* spi3_mosim1 */
        <4 RK_PC3 2 &pcfg_pull_up_drv_level_1>;
};

引脚分配：

• CLK（时钟线） : GPIO4_PC2，功能复用模式2
• MISO（主入从出） : GPIO4_PC5，功能复用模式2
• MOSI（主出从入） : GPIO4_PC3，功能复用模式2
• CS0（片选0） : GPIO4_PC6，功能复用模式2

最后查看一下板级文件中对SPI3的具体配置情况：

&spi3 {
    status = "okay";
    pinctrl-0 = <&spi3m1_cs0  &spi3m1_pins>;
    pinctrl-1 = <&spi3m1_cs0  &spi3m1_pins_hs>;
    spidev:spidev@0 {
        compatible = "rockchip,spidev";
        reg = <0>;
        spi-max-frequency = <10000000>;
        status = "okay";
    };
};

对以上设备树进行一个简单的介绍：

引脚复用配置

• pinctrl-0 : 默认速度模式的引脚配置（使用m1模式）
• pinctrl-1 : 高速模式的引脚配置（增强驱动能力）

spidev设备配置

• compatible = "rockchip,spidev" : 使用Rockchip的通用SPI设备驱动
• reg = <0> : 设备地址为0（对应CS0片选）
• spi-max-frequency = <10000000> : 最大SPI时钟频率为10MHz

3-2 应用层操作SPI的方法

提供的SDK中，已经在rk3568平台写好了一个SPI测试程序 spi_selftest，主机发送"hello the world !"，短接MOSI和MISO，输入端接收数据查看是否正常。帮助开发者验证 SPI 控制器的驱动是否正常工作、硬件连接是否正确，只需要输入目标spi设备即可执行下列指令即可运行：

spi_selftest /dev/spidevxx

3-3 具体功能演示

现在通过上述指令对板子挂载的SPI3进行测试：

首先短接板子上的MOSI和MISO接口：

在终端输入：spi_selftest /dev/spidev3.0 测试数据收发是否正常：

成功接收到发送的字节：

将短接跳线帽拔掉，再输入 spi_selftest /dev/spidev3.0 指令进行测试：

此时接收值为乱码，符合预期。

4 SPI使用---NAPI方法

资料路径

hap包：\05-开发资料\01-OpenHarmory 开发资料\外设测试APP\HAP\SPI_TEST.hap

工程码源：\05-开发资料\01-OpenHarmory 开发资料\外设测试APP\SRC\SPI_TEST

同上小节命令行，我们使用的测试指令为 spi_selftest /dev/spidev3.0

4-1 测试环境准备

首先我们需要通过hdc工具连接到开发板，给要操作的系统节点加上可读写权限：

mount -o remount,rw /
chmod 777 /system/bin/spi_selftest
chmod 777 /dev/spidev3.0

由于 system 是系统文件，一般是只读，需要先把根目录 / 权限改为可读写以后，才能把测试命令所在的目录 /system/bin/spi_selftest 和SPI设备目录 /dev/spidev3.0 权限改为777。

4-2 SPI设备测试APP使用介绍

下面对使用NAPI创建的SPI设备测试APP进行介绍：

进入程序以后，有一个下拉框可以对SPI设备进行选择

（板卡只引出了 spidev3.0，所以这里使用选择 /dev/spidev3.0 进行测试）：

点击SPI测试按键：

如果将SPI的MOSI和MISO进行短接，下方会打印接收到的终端数据，发送和接收一致则打印SPI设备测试成功：

对应的，将SPI的MOSI和MISO进行跳线帽拔下，下方会打印接收到的终端数据，接收显示乱码，提示SPI设备测试不通过：

4-3 NAPI底层C函数介绍

考虑到大部分朋友可能没有很好的Linux系统编程基础，这里对实现NAPI的底层C函数进行一个简单的讲解，先附上源码：

// 执行SPI自测试命令
static napi_value SPI_Test(napi_env env, napi_callback_info info)
{
    size_t argc = 1;
    napi_value args[1];
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);

    if (argc < 1) {
        napi_throw_error(env, nullptr, "Expected 1 argument: SPI device path (e.g., /dev/spidev3.0)");
        return nullptr;
    }

    // 获取SPI设备路径参数
    size_t str_size;
    napi_get_value_string_utf8(env, args[0], nullptr, 0, &str_size);
    char* spi_device = (char*)malloc(str_size + 1);
    napi_get_value_string_utf8(env, args[0], spi_device, str_size + 1, &str_size);

    OH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, SPI_TAG,
                       "Starting SPI test for device: %{public}s", spi_device);

    // 创建管道用于读取命令输出
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, GLOBAL_RESMGR, SPI_TAG,
                           "Failed to create pipe: %{public}s", strerror(errno));
        free(spi_device);
        napi_throw_error(env, nullptr, "Failed to create pipe");
        return nullptr;
    }

    pid_t pid = fork();
    if (pid == -1) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, GLOBAL_RESMGR, SPI_TAG,
                           "Failed to fork process: %{public}s", strerror(errno));
        close(pipefd[0]);
        close(pipefd[1]);
        free(spi_device);
        napi_throw_error(env, nullptr, "Failed to fork process");
        return nullptr;
    }

    if (pid == 0) {
        // 子进程：执行spi_selftest命令
        close(pipefd[0]); // 关闭读端
        dup2(pipefd[1], STDOUT_FILENO); // 重定向stdout到管道（写入的数据传入标准输出（fd=1））
        dup2(pipefd[1], STDERR_FILENO); // 重定向stderr到管道（写入的数据传入标准错误（fd=2））
        close(pipefd[1]);

        // 执行spi_selftest命令.如果成功不会返回，失败了才会执行后续的操作
        execl("/system/bin/spi_selftest", "spi_selftest", spi_device, (char*)NULL);

        // 如果execl失败，输出错误信息
        fprintf(stderr, "Failed to execute spi_selftest: %s\n", strerror(errno));
        exit(1);
    } else {
        // 父进程：读取命令输出
        close(pipefd[1]); // 关闭写端

        // 读取输出
        char buffer[4096] = {0};
        ssize_t total_read = 0;
        ssize_t bytes_read;

        while ((bytes_read = read(pipefd[0], buffer + total_read, sizeof(buffer) - total_read - 1)) > 0) {
            total_read += bytes_read;
            if (total_read >= sizeof(buffer) - 1) {
                break;
            }
        }

        close(pipefd[0]);

        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);

        buffer[total_read] = '\0';

        OH_LOG_Print(LOG_APP, LOG_INFO, GLOBAL_RESMGR, SPI_TAG,
                           "SPI test output: %{public}s", buffer);

        free(spi_device);

        // 返回命令输出结果
        napi_value result;
        napi_create_string_utf8(env, buffer, NAPI_AUTO_LENGTH, &result);
        return result;
    }
}

为了成功捕获完整的输出，我们这里设计了一个子进程用于执行测试命令，另一个进程（父进程）只需要负责读取子进程的输出，提高系统的实时性也防止一个进程"自发自收"导致数据丢失或程序异常。

程序详解

下面对程序进行详解：

1. 首先调用函数 napi_get_cb_info 获取JavaScript端传入的参数，也就是设备路径
2. 使用2次函数 napi_get_value_string_utf8 获取到接收字符串的长度后转为C字符串
3. int pipefd[2]; 创建的是父子进程之间通信的管道，pipefd[0] 用于读取，pipefd[1] 用于写入
4. 使用 fork() 创建子进程，子进程 pid==0，父进程 pid>0
5. 子进程函数负责写指令，通过 dup2 把需要写入的数据分别重定向传输到标准输出 STDOUT_FILENO（fd==1）和标准错误 STDERR_FILENO（fd==2）；再使用函数 execl("/system/bin/spi_selftest", "spi_selftest", spi_device, (char*)NULL); 在指定路径下执行SPI测试命令，需要了解的是，这个函数执行时，会再开一个进程专门跑这个任务，成功后就不会返回了！
6. 父进程循环读取数据并把内容保存到缓冲区中，read() 会返回读取的字节数，如果大于0表示成功读取了数据，当子进程关闭写端后，read() 会返回0，循环结束
7. 等待子程序结束后把读取的数据转成JavaScript字符串返回

其余部分代码大家可以参考提供的源码！