本文主要是介绍NVIDIA Jetson Orin Nano Spidev 使用教程,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
系列文章目录
前言
该项目包含一个 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...
| |
---|---|
| |
loop | 设置 "SPI_LOOP "标志以启用环回模式 |
no_cs | 设置 "SPI_NO_CS "标志,禁用片选(尽管驱动程序可能仍拥有 CS 引脚)。 |
| |
| |
mode | SPI 模式为时钟极性和相位 [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, ¤t);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设备文件。
- 参数:
主函数流程
- 解析命令行参数。
- 打开SPI设备文件。
- 设置SPI模式、每字位数和最大速度。
- 根据命令行参数执行不同的操作:
- 如果指定了
-p
或--input
参数,则传输指定的十六进制转义字符串或文件。 - 如果指定了
-S
或--size
参数,则进行多次迭代传输,并显示平均传输速率。 - 否则,使用默认数据进行一次传输。
- 如果指定了
- 关闭SPI设备文件并返回。
这个程序可以用来测试SPI设备的功能,验证数据传输的正确性,并测量传输性能。
这篇关于NVIDIA Jetson Orin Nano Spidev 使用教程的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!