使用spidev在Linux（Raspberry PI）上使用SPI

Question

I'm trying to use SPI on Raspberry PI using spidev and his test code as skeleton for my own. I have a problem with table size. My table has different size before I pass it to transfer function ie my table has 3 elements, inside function it has 4. Here is my code:

// spi.cpp : Defines the entry point for the console application.
//


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

#define ARRAY_SIZE(a)  (sizeof(a) / sizeof((a)[0]))

static const char *device = "/dev/spidev0.0";
static uint8_t mode;
static uint8_t bits = 8;
static uint32_t speed = 1000000;
static uint16_t delay;

//this function gives problems with diffrent size of array
static void transfer(int fd, uint8_t tx[])
{
        printf("transfer1");
        printf(" rozmiar tab=%d ", ARRAY_SIZE(tx));
        int ret;
        uint8_t rx[ARRAY_SIZE(tx)] = { 0, };
        struct spi_ioc_transfer tr = {
                .tx_buf = (unsigned long)tx,
                .rx_buf = (unsigned long)rx,
                .len = 3,
                .delay_usecs = delay,
                .speed_hz = speed,
                .bits_per_word = bits,
        };

        ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);

        for (ret = 0; ret < ARRAY_SIZE(tx); ret++) {
                if (!(ret % 6))
                        puts("");

                printf("%d. %.2X ", ret,rx[ret]);

        }
        puts("");
        }

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

        fd = open(device, O_RDWR);

        /*
        * spi mode
        */
        ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);

        ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);

        /*
        * bits per word
        */
        ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);

        ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);

        /*
        * max speed hz
        */
        ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);

        ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);

        printf("spi mode: %d\n", mode);
        printf("bits per word: %d\n", bits);
        printf("max speed: %d Hz (%d KHz)\n", speed, speed / 1000);

        uint8_t tx1[] = {
                0x0, 0x1b, 0xa5
        };
//here I'm passing table to function
        transfer(fd, tx1);
        uint8_t tx2[] = {
                0x0, 0x33, 0x30, 0x01, 0x02
        };
        printf(" %d. ", ARRAY_SIZE(tx2));
        transfer(fd, tx2);
        uint8_t tx3[] = {
                0x0, 0x52, 0x90
        };
        transfer(fd, tx3);
        uint8_t tx4[] = {
                0x80, 0x60
        };
        printf(" %d. ", ARRAY_SIZE(tx4));
        transfer(fd, tx4);

        close(fd);

        return ret;
}

Answer 1

An array sent as a parameter to a function is treated as a pointer. Your ARRAY_SIZE(a) is roughly expanded to (sizeof(uint8_t*) / sizeof(uint8_t)) , which equals 4 on 32-bit platform.

You should explicitly pass array size as a 3rd parameter:

void transfer(int fd, const uint8_t *tx, size_t size) { ... }

Then, you can use your macro to properly calculate array size:

transfer(fd, tx1, ARRAY_SIZE(tx1));

If tx is not being modified inside transfer() , it is a matter of good taste to make it const .