linux上测试spi节点的小程序

终端测试方法 

# spidev_test -D /dev/spidev0.0 -w 10 

spidev_dest  app 代码程序

#include <stdint.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <getopt.h> 
#include <fcntl.h> 
#include <sys/ioctl.h> 
#include <linux/ioctl.h> 
#include <sys/stat.h> 
#include <linux/types.h> 
#include <linux/spi/spidev.h> 
#include <sys/timerfd.h> 
 

static void pabort(const char *s) 
{ 
perror(s); 
abort(); 
} 
 

static const char *device = "/dev/spidev0.0"; 
static uint32_t mode; 
static int verbose; 
static uint8_t bits = 8; 
static uint32_t words = 100; 
static uint32_t speed = 500000; 
 

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("\n\n"); 
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(" | ");  /* right close */ 
while (line < address) { 
c = *line++; 
} 
printf("\n"); 
if (length > 0) 
printf("%s | ", prefix); 
} 
} 
} 
 

static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, uint32_t speed, uint32_t bits, uint32_t len) 
{ 
int ret; 
struct spi_ioc_transfer tr = { 
.tx_buf = (unsigned long)tx, 
.rx_buf = (unsigned long)rx, 
.len = len, 
.delay_usecs = 0, 
.speed_hz = speed, 
.bits_per_word = bits, 
}; 
 

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 (verbose) 
hex_dump(rx, len, 32, "RX"); 
} 
 

static void print_usage(const char *prog) 
{ 
printf("Usage: %s [-DsblHOLC]\n", prog); 
puts("  -D --device   device to use (default /dev/spidev0.0)\n" 
     "  -s --speed    max speed (Hz)\n" 
     "  -b --bpw      bits per word\n" 
     "  -l --loop     loopback\n" 
     "  -H --cpha     clock phase\n" 
     "  -O --cpol     clock polarity\n" 
     "  -L --lsb      least significant bit first\n" 
     "  -C --cs-high  chip select active high\n" 
     "  -v --verbose  Verbose (show tx buffer)\n" 
     "  -w --numwds   numbers of words \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' }, 
{ "bpw",     1, 0, 'b' }, 
{ "numwds",  1, 0, 'w' }, 
{ "loop",    0, 0, 'l' }, 
{ "cpha",    0, 0, 'H' }, 
{ "cpol",    0, 0, 'O' }, 
{ "lsb",     0, 0, 'L' }, 
{ "cs-high", 0, 0, 'C' }, 
{ "verbose", 0, 0, 'v' }, 
{ NULL,      0, 0,  0  }, 
}; 
int c; 
 

c = getopt_long(argc, argv, "D:s:b:w:lHOLC:v", 
lopts, NULL); 
 

if (c == -1) 
break; 
 

switch (c) { 
case 'D': 
device = optarg; 
break; 
case 's': 
speed = atoi(optarg); 
break; 
case 'b': 
bits = atoi(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 'v': 
verbose = 1; 
break; 
case 'w': 
words = atoi(optarg); 
break; 
default: 
print_usage(argv[0]); 
break; 
} 
} 
} 
 

int main(int argc, char *argv[]) 
{ 
int i, ret = 0; 
int fd; 
uint8_t *tx, *rx; 
 

parse_opts(argc, argv); 
 

fd = open(device, O_RDWR); 
if (fd < 0) 
pabort("can't open device"); 
 

/* 
* spi mode 
*/ 
ret = ioctl(fd, SPI_IOC_WR_MODE, &mode); 
if (ret == -1) 
pabort("can't set spi mode"); 
 

ret = ioctl(fd, SPI_IOC_RD_MODE, &mode); 
if (ret == -1) 
pabort("can't get spi mode"); 
 

/* 
* 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: %d\n", bits); 
printf("words: %d ea\n", words); 
printf("speed: %d KHz\n", speed/1000); 
 

tx = (uint8_t*)malloc(words); 
rx = (uint8_t*)malloc(words); 
 

if ((NULL == tx) || (NULL == rx)){ 
printf("buffer memory allocate fail\n"); 
exit(1); 
} 
 

if (bits != 9) { 
for (i=0; i < words; i++) 
tx[i] = (i % 0xff); 
} else { 
for (i=0; i < words; i+=2) 
tx[i] = (i % 0xff); 
tx[i+1] = 0x00; 
} 
 

transfer(fd, tx, rx, speed, bits, words); 
 

if (bits == 9) { 
for (i=0; i < words; i+=2) { 
tx[i] = (i % 0xff); 
tx[i+1] = 0x01; 
} 
transfer(fd, tx, rx, speed, bits, words); 
} 
 

close(fd); 
 

return ret; 
}