NVIDIA Jetson Orin Nano Spidev 使用教程

devtools/2024/11/14 16:21:47/

系列文章目录

前言

该项目包含一个 python 模块，用于通过 spidev linux 内核驱动程序从用户空间连接 SPI 设备。

除非另有明确说明，否则所有代码均已获得 MIT 许可。

一、使用方法

import spidev
spi = spidev.SpiDev()
spi.open(bus, device)
to_send = [0x01, 0x02, 0x03]
spi.xfer(to_send)

二、设置

import spidev
spi = spidev.SpiDev()
spi.open(bus, device)# Settings (for example)
spi.max_speed_hz = 5000
spi.mode = 0b01...
参数

bits_per_word

cshigh

loop设置 "SPI_LOOP "标志以启用环回模式
no_cs设置 "SPI_NO_CS "标志，禁用片选（尽管驱动程序可能仍拥有 CS 引脚）。

lsbfirst

max_speed_hz

modeSPI 模式为时钟极性和相位 [CPOL|CPHA] 的两位模式，最小：0b00 = 0，最大：0b11 = 3： 0b11 = 3
threewire共享 SI/SO 信号
read0如果 cshigh == True，在向低 CS 传输后读取 0 字节

三、方法

open(bus, device)

 连接指定的 SPI 设备，打开 /dev/spidev<bus>.<device>

readbytes(n)

从 SPI 设备读取 n 个字节。

writebytes(list of values)

向 SPI 设备写入数值列表。

writebytes2(list of values)

        与 writebytes 类似，但可接受任意大的列表。如果列表大小超过缓冲区大小（从 /sys/module/spidev/parameters/bufsiz），数据将被分割成小块，并分多次发送。

        此外，writebytes2 还能理解缓冲区协议，因此它可以接受 numpy 字节数组，而无需先用 tolist() 进行转换。这样，在需要向 SPI 连接的显示器传输坐标系帧时，性能就会大大提高。

xfer(list of values[, speed_hz, delay_usec, bits_per_word])

执行 SPI 传输。在两个区块之间应释放并重新激活片选。延时（Delay）指定块与块之间的延时，单位为 usec。

xfer2(list of values[, speed_hz, delay_usec, bits_per_word])

执行 SPI 交易。芯片选择应在各块之间保持激活状态。

xfer3(list of values[, speed_hz, delay_usec, bits_per_word])

与 xfer2 类似，但可接受任意大的列表。如果列表大小超过缓冲区大小（从 /sys/module/spidev/parameters/bufsiz），数据将被分割成小块，并分多次发送。

close()

断开与 SPI 设备的连接。

四、实际使用

4.1 硬件连接

五、spidev-test

// SPDX-License-Identifier: GPL-2.0-only
/** SPI testing utility (using spidev driver)** Copyright (c) 2007  MontaVista Software, Inc.* Copyright (c) 2007  Anton Vorontsov <avorontsov@ru.mvista.com>** Cross-compile with cross-gcc -I/path/to/cross-kernel/include*/#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <fcntl.h>
#include <time.h>
#include <sys/ioctl.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <linux/types.h>
#include <linux/spi/spidev.h>#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))static void pabort(const char *s)
{if (errno != 0)perror(s);elseprintf("%s\n", s);abort();
}static const char *device = "/dev/spidev1.1";
static uint32_t mode;
static uint8_t bits = 8;
static char *input_file;
static char *output_file;
static uint32_t speed = 500000;
static uint16_t delay;
static int verbose;
static int transfer_size;
static int iterations;
static int interval = 5; /* interval in seconds for showing transfer rate */static uint8_t default_tx[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0x40, 0x00, 0x00, 0x00, 0x00, 0x95,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,0xF0, 0x0D,
};static uint8_t default_rx[ARRAY_SIZE(default_tx)] = {0, };
static char *input_tx;static void hex_dump(const void *src, size_t length, size_t line_size,char *prefix)
{int i = 0;const unsigned char *address = src;const unsigned char *line = address;unsigned char c;printf("%s | ", prefix);while (length-- > 0) {printf("%02X ", *address++);if (!(++i % line_size) || (length == 0 && i % line_size)) {if (length == 0) {while (i++ % line_size)printf("__ ");}printf(" |");while (line < address) {c = *line++;printf("%c", (c < 32 || c > 126) ? '.' : c);}printf("|\n");if (length > 0)printf("%s | ", prefix);}}
}/**  Unescape - process hexadecimal escape character*      converts shell input "\x23" -> 0x23*/
static int unescape(char *_dst, char *_src, size_t len)
{int ret = 0;int match;char *src = _src;char *dst = _dst;unsigned int ch;while (*src) {if (*src == '\\' && *(src+1) == 'x') {match = sscanf(src + 2, "%2x", &ch);if (!match)pabort("malformed input string");src += 4;*dst++ = (unsigned char)ch;} else {*dst++ = *src++;}ret++;}return ret;
}static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len)
{int ret;int out_fd;struct spi_ioc_transfer tr = {.tx_buf = (unsigned long)tx,.rx_buf = (unsigned long)rx,.len = len,.delay_usecs = delay,.speed_hz = speed,.bits_per_word = bits,};if (mode & SPI_TX_OCTAL)tr.tx_nbits = 8;else if (mode & SPI_TX_QUAD)tr.tx_nbits = 4;else if (mode & SPI_TX_DUAL)tr.tx_nbits = 2;if (mode & SPI_RX_OCTAL)tr.rx_nbits = 8;else if (mode & SPI_RX_QUAD)tr.rx_nbits = 4;else if (mode & SPI_RX_DUAL)tr.rx_nbits = 2;if (!(mode & SPI_LOOP)) {if (mode & (SPI_TX_OCTAL | SPI_TX_QUAD | SPI_TX_DUAL))tr.rx_buf = 0;else if (mode & (SPI_RX_OCTAL | SPI_RX_QUAD | SPI_RX_DUAL))tr.tx_buf = 0;}ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);if (ret < 1)pabort("can't send spi message");if (verbose)hex_dump(tx, len, 32, "TX");if (output_file) {out_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC, 0666);if (out_fd < 0)pabort("could not open output file");ret = write(out_fd, rx, len);if (ret != len)pabort("not all bytes written to output file");close(out_fd);}if (verbose)hex_dump(rx, len, 32, "RX");
}static void print_usage(const char *prog)
{printf("Usage: %s [-2348CDFHILMNORSZbdilopsv]\n", prog);puts("general device settings:\n""  -D --device         device to use (default /dev/spidev1.1)\n""  -s --speed          max speed (Hz)\n""  -d --delay          delay (usec)\n""  -l --loop           loopback\n""spi mode:\n""  -H --cpha           clock phase\n""  -O --cpol           clock polarity\n""  -F --rx-cpha-flip   flip CPHA on Rx only xfer\n""number of wires for transmission:\n""  -2 --dual           dual transfer\n""  -4 --quad           quad transfer\n""  -8 --octal          octal transfer\n""  -3 --3wire          SI/SO signals shared\n""  -Z --3wire-hiz      high impedance turnaround\n""data:\n""  -i --input          input data from a file (e.g. \"test.bin\")\n""  -o --output         output data to a file (e.g. \"results.bin\")\n""  -p                  Send data (e.g. \"1234\\xde\\xad\")\n""  -S --size           transfer size\n""  -I --iter           iterations\n""additional parameters:\n""  -b --bpw            bits per word\n""  -L --lsb            least significant bit first\n""  -C --cs-high        chip select active high\n""  -N --no-cs          no chip select\n""  -R --ready          slave pulls low to pause\n""  -M --mosi-idle-low  leave mosi line low when idle\n""misc:\n""  -v --verbose        Verbose (show tx buffer)\n");exit(1);
}static void parse_opts(int argc, char *argv[])
{while (1) {static const struct option lopts[] = {{ "device",        1, 0, 'D' },{ "speed",         1, 0, 's' },{ "delay",         1, 0, 'd' },{ "loop",          0, 0, 'l' },{ "cpha",          0, 0, 'H' },{ "cpol",          0, 0, 'O' },{ "rx-cpha-flip",  0, 0, 'F' },{ "dual",          0, 0, '2' },{ "quad",          0, 0, '4' },{ "octal",         0, 0, '8' },{ "3wire",         0, 0, '3' },{ "3wire-hiz",     0, 0, 'Z' },{ "input",         1, 0, 'i' },{ "output",        1, 0, 'o' },{ "size",          1, 0, 'S' },{ "iter",          1, 0, 'I' },{ "bpw",           1, 0, 'b' },{ "lsb",           0, 0, 'L' },{ "cs-high",       0, 0, 'C' },{ "no-cs",         0, 0, 'N' },{ "ready",         0, 0, 'R' },{ "mosi-idle-low", 0, 0, 'M' },{ "verbose",       0, 0, 'v' },{ NULL, 0, 0, 0 },};int c;c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3ZFMNR248p:vS:I:",lopts, NULL);if (c == -1)break;switch (c) {case 'D':device = optarg;break;case 's':speed = atoi(optarg);break;case 'd':delay = atoi(optarg);break;case 'b':bits = atoi(optarg);break;case 'i':input_file = optarg;break;case 'o':output_file = optarg;break;case 'l':mode |= SPI_LOOP;break;case 'H':mode |= SPI_CPHA;break;case 'O':mode |= SPI_CPOL;break;case 'L':mode |= SPI_LSB_FIRST;break;case 'C':mode |= SPI_CS_HIGH;break;case '3':mode |= SPI_3WIRE;break;case 'Z':mode |= SPI_3WIRE_HIZ;break;case 'F':mode |= SPI_RX_CPHA_FLIP;break;case 'M':mode |= SPI_MOSI_IDLE_LOW;break;case 'N':mode |= SPI_NO_CS;break;case 'v':verbose = 1;break;case 'R':mode |= SPI_READY;break;case 'p':input_tx = optarg;break;case '2':mode |= SPI_TX_DUAL;break;case '4':mode |= SPI_TX_QUAD;break;case '8':mode |= SPI_TX_OCTAL;break;case 'S':transfer_size = atoi(optarg);break;case 'I':iterations = atoi(optarg);break;default:print_usage(argv[0]);}}if (mode & SPI_LOOP) {if (mode & SPI_TX_DUAL)mode |= SPI_RX_DUAL;if (mode & SPI_TX_QUAD)mode |= SPI_RX_QUAD;if (mode & SPI_TX_OCTAL)mode |= SPI_RX_OCTAL;}
}static void transfer_escaped_string(int fd, char *str)
{size_t size = strlen(str);uint8_t *tx;uint8_t *rx;tx = malloc(size);if (!tx)pabort("can't allocate tx buffer");rx = malloc(size);if (!rx)pabort("can't allocate rx buffer");size = unescape((char *)tx, str, size);transfer(fd, tx, rx, size);free(rx);free(tx);
}static void transfer_file(int fd, char *filename)
{ssize_t bytes;struct stat sb;int tx_fd;uint8_t *tx;uint8_t *rx;if (stat(filename, &sb) == -1)pabort("can't stat input file");tx_fd = open(filename, O_RDONLY);if (tx_fd < 0)pabort("can't open input file");tx = malloc(sb.st_size);if (!tx)pabort("can't allocate tx buffer");rx = malloc(sb.st_size);if (!rx)pabort("can't allocate rx buffer");bytes = read(tx_fd, tx, sb.st_size);if (bytes != sb.st_size)pabort("failed to read input file");transfer(fd, tx, rx, sb.st_size);free(rx);free(tx);close(tx_fd);
}static uint64_t _read_count;
static uint64_t _write_count;static void show_transfer_rate(void)
{static uint64_t prev_read_count, prev_write_count;double rx_rate, tx_rate;rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0);tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0);printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate);prev_read_count = _read_count;prev_write_count = _write_count;
}static void transfer_buf(int fd, int len)
{uint8_t *tx;uint8_t *rx;int i;tx = malloc(len);if (!tx)pabort("can't allocate tx buffer");for (i = 0; i < len; i++)tx[i] = random();rx = malloc(len);if (!rx)pabort("can't allocate rx buffer");transfer(fd, tx, rx, len);_write_count += len;_read_count += len;if (mode & SPI_LOOP) {if (memcmp(tx, rx, len)) {fprintf(stderr, "transfer error !\n");hex_dump(tx, len, 32, "TX");hex_dump(rx, len, 32, "RX");exit(1);}}free(rx);free(tx);
}int main(int argc, char *argv[])
{int ret = 0;int fd;uint32_t request;parse_opts(argc, argv);if (input_tx && input_file)pabort("only one of -p and --input may be selected");fd = open(device, O_RDWR);if (fd < 0)pabort("can't open device");/** spi mode*//* WR is make a request to assign 'mode' */request = mode;ret = ioctl(fd, SPI_IOC_WR_MODE32, &mode);if (ret == -1)pabort("can't set spi mode");/* RD is read what mode the device actually is in */ret = ioctl(fd, SPI_IOC_RD_MODE32, &mode);if (ret == -1)pabort("can't get spi mode");/* Drivers can reject some mode bits without returning an error.* Read the current value to identify what mode it is in, and if it* differs from the requested mode, warn the user.*/if (request != mode)printf("WARNING device does not support requested mode 0x%x\n",request);/** bits per word*/ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);if (ret == -1)pabort("can't set bits per word");ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);if (ret == -1)pabort("can't get bits per word");/** max speed hz*/ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);if (ret == -1)pabort("can't set max speed hz");ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);if (ret == -1)pabort("can't get max speed hz");printf("spi mode: 0x%x\n", mode);printf("bits per word: %u\n", bits);printf("max speed: %u Hz (%u kHz)\n", speed, speed/1000);if (input_tx)transfer_escaped_string(fd, input_tx);else if (input_file)transfer_file(fd, input_file);else if (transfer_size) {struct timespec last_stat;clock_gettime(CLOCK_MONOTONIC, &last_stat);while (iterations-- > 0) {struct timespec current;transfer_buf(fd, transfer_size);clock_gettime(CLOCK_MONOTONIC, &current);if (current.tv_sec - last_stat.tv_sec > interval) {show_transfer_rate();last_stat = current;}}printf("total: tx %.1fKB, rx %.1fKB\n",_write_count/1024.0, _read_count/1024.0);} elsetransfer(fd, default_tx, default_rx, sizeof(default_tx));close(fd);return ret;
}

这段代码是一个用于测试SPI (Serial Peripheral Interface) 设备的实用程序。它利用了Linux的spidev驱动来与SPI设备进行通信。以下是代码的主要功能和组成部分的详细解释：

文件头部信息

  • SPDX-License-Identifier: 指定使用的许可证为GPL-2.0-only。
  • 版权声明: 指出代码的版权信息和作者。
  • 交叉编译指令: 使用交叉编译器gcc和指定内核头文件路径来编译程序。

包含的头文件

  • <stdint.h>: 提供固定宽度整数类型的定义。
  • <unistd.h>: 提供标准的Unix系统调用。
  • <stdio.h>: 标准输入输出操作。
  • <stdlib.h>: 提供内存分配和字符串处理函数。
  • <string.h>: 字符串处理函数。
  • <errno.h>: 错误号和错误信息。
  • <getopt.h>: 命令行参数解析。
  • <fcntl.h>: 文件控制操作。
  • <time.h>: 时间相关函数。
  • <sys/ioctl.h>: 输入输出控制操作。
  • <linux/ioctl.h>: Linux特定的ioctl宏。
  • <sys/stat.h>: 文件状态和属性。
  • <linux/types.h>: Linux特定的数据类型。
  • <linux/spi/spidev.h>: SPI设备相关的ioctl命令和数据结构。

定义的宏和常量

  • ARRAY_SIZE(a): 计算数组的元素个数。

全局变量定义

  • device: 默认SPI设备文件路径。
  • mode: SPI模式配置。
  • bits: 每字的位数，默认为8位。
  • input_file: 输入文件路径。
  • output_file: 输出文件路径。
  • speed: SPI最大速度（赫兹）。
  • delay: SPI传输之间的延迟（微秒）。
  • verbose: 是否启用详细输出。
  • transfer_size: 单次传输的大小。
  • iterations: 迭代次数。
  • interval: 显示传输速率的时间间隔（秒）。
  • default_tx 和 default_rx: 默认发送和接收的数据缓冲区。
  • input_tx: 从命令行输入的十六进制转义字符串。

函数定义

  • pabort: 处理错误并终止程序。
    • 参数: const char *s - 错误信息。
    • 功能: 如果errno不为0，则使用perror打印错误信息；否则直接打印s。然后调用abort()终止程序。
  • hex_dump: 打印缓冲区的十六进制转储。
    • 参数: const void *src - 要转储的数据源地址。
    • 参数: size_t length - 数据长度。
    • 参数: size_t line_size - 每行显示的数据项数。
    • 参数: char *prefix - 行前缀字符串。
    • 功能: 打印数据的十六进制形式以及ASCII表示。
  • unescape: 解析十六进制转义序列。
    • 参数: _dst - 目标字符数组。
    • 参数: _src - 源字符数组。
    • 参数: len - 最大长度。
    • 功能: 将源字符串中的十六进制转义序列转换为目标数组中的实际值。
  • transfer: 发送SPI消息并接收响应。
    • 参数: fd - SPI设备文件描述符。
    • 参数: tx - 发送数据缓冲区。
    • 参数: rx - 接收数据缓冲区。
    • 参数: len - 数据长度。
    • 功能: 使用ioctl和struct spi_ioc_transfer结构体发送SPI消息，并根据配置调整传输模式。
  • print_usage: 打印帮助信息。
    • 参数: const char *prog - 程序名称。
    • 功能: 打印程序的使用方法和所有支持的命令行选项。
  • parse_opts: 解析命令行选项。
    • 参数: int argc - 命令行参数个数。
    • 参数: char *argv[] - 命令行参数数组。
    • 功能: 解析命令行选项，设置全局变量。
  • transfer_escaped_string: 传输十六进制转义字符串。
    • 参数: fd - SPI设备文件描述符。
    • 参数: char *str - 十六进制转义字符串。
    • 功能: 将十六进制转义字符串转换为二进制数据并发送。
  • transfer_file: 传输文件内容。
    • 参数: fd - SPI设备文件描述符。
    • 参数: char *filename - 文件名。
    • 功能: 读取文件内容并发送到SPI设备。
  • show_transfer_rate: 显示传输速率。
    • 功能: 显示当前的发送和接收速率。
  • transfer_buf: 生成随机数据并进行传输。
    • 参数: fd - SPI设备文件描述符。
    • 参数: int len - 数据长度。
    • 功能: 生成随机数据并发送到SPI设备，同时记录发送和接收的总字节数。
  • main: 主函数，程序入口。
    • 参数: int argc - 命令行参数个数。
    • 参数: char *argv[] - 命令行参数数组。
    • 功能: 解析命令行参数，打开SPI设备文件，设置SPI模式、每字位数和最大速度，执行不同的传输操作，并关闭SPI设备文件。

主函数流程

  1. 解析命令行参数。
  2. 打开SPI设备文件。
  3. 设置SPI模式、每字位数和最大速度。
  4. 根据命令行参数执行不同的操作：
    • 如果指定了-p或--input参数，则传输指定的十六进制转义字符串或文件。
    • 如果指定了-S或--size参数，则进行多次迭代传输，并显示平均传输速率。
    • 否则，使用默认数据进行一次传输。
  5. 关闭SPI设备文件并返回。

这个程序可以用来测试SPI设备的功能，验证数据传输的正确性，并测量传输性能。


http://www.ppmy.cn/devtools/100742.html

相关文章

波场交易刷量机器人：‌提升项目交易表现的高效工具‌

波场交易刷量机器人：‌提升项目交易表现的高效工具‌

在波场交易生态中&#xff0c;‌项目方为了吸引更多用户参与交易、‌增强市场流动性&#xff0c;‌常常会借助各种工具来优化其在交易平台上的表现。‌波场交易刷量机器人就是这样一款广受项目方欢迎的操作工具。‌它不仅能帮助项目方在波场交易平台上打造出吸引人的交易量趋势…
阅读更多...
数据预处理

数据预处理

步骤子步骤描述常用方法注意事项1. 数据收集-获取和收集数据集&#xff0c;用于后续分析和建模。数据库查询、API调用、手动收集确保数据来源可靠、数据质量高&#xff0c;数据量足够代表总体。2. 数据清洗缺失值处理处理数据中的缺失值&#xff0c;以防止模型误差。- 删除缺失…
阅读更多...
引擎切换pdf识别简历分析

引擎切换pdf识别简历分析

文章目录 1.EasyCode生成interview_history的crud1.在模板设置中手动指定逻辑删除的值2.生成代码&#xff0c;进行测试 2.PDF识别关键字1.引入依赖2.代码概览3.PDFUtil.java4.keyword1.EndType.java2.FlagIndex.java3.WordType.java4.KeyWordUtil.java 3.策略模式实现引擎切换&…
阅读更多...
Mysql的常考表操作指令

Mysql的常考表操作指令

自己整理了一些Mysql的表操作指令&#xff0c;包含了最常考的主键&#xff0c;非空&#xff0c;外键等。希望对大家有帮助&#xff0c;祝大家秋招顺利&#xff01; 首先我们要区分DDL和DML的区别&#xff1a; DDL主要操作的是表的对象和结构&#xff0c;比如添加删除修改字段&…
阅读更多...
计算机毕业设计选题推荐-猫眼电影数据可视化分析-Python爬虫-k-means算法

计算机毕业设计选题推荐-猫眼电影数据可视化分析-Python爬虫-k-means算法

✨作者主页&#xff1a;IT毕设梦工厂✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Py…
阅读更多...
【深度学习】OCR，TrOCR，transformer 端对端，论文

【深度学习】OCR，TrOCR，transformer 端对端，论文

TrOCR: 基于Transformer的光学字符识别，使用预训练模型 摘要 文本识别是文档数字化领域中的一个长期存在的研究问题。现有的方法通常基于用于图像理解的CNN和用于字符级文本生成的RNN。此外，通常还需要另一个语言模型作为后处理步骤来提高整体准确性。在本文中，我们提出了…
阅读更多...
批量归一化（Datawhale X 李宏毅苹果书 AI夏令营）

批量归一化（Datawhale X 李宏毅苹果书 AI夏令营）

批量归一化&#xff08;Batch Normalization, BN&#xff09;是一种在深度学习中常用的技术&#xff0c;其目的是提高模型训练的稳定性和效率。BN的基本概念是对每一层的输入进行标准化处理&#xff0c;使得每层的输入数据在训练过程中保持均值为零、方差为一。这种处理方式有助…
阅读更多...
【赵渝强老师】使用Docker Machine远程管理Docker

【赵渝强老师】使用Docker Machine远程管理Docker

Docker Machine是Docker官方提供的一个远程管理工具。通过使用Docker Machine&#xff0c;可以帮助开发人员在远程主机上安装Docker&#xff1b;或者在远程的虚拟主机上直接安装虚拟机并在虚拟机中安装Docker。Docker Machine还提供了相应的命令来管理这些远程的Docker环境和虚…
阅读更多...
最新文章

Copyright @ 2022~2023