有用Linux下c 读写spi从机，该如何操作，我下面是spi 主机模式，我想知道从机模式怎么写，谢谢了

2004v2004 2023-02-17 20:50:42


#include <stdio.h>
#include <stdint.h>

#include <sys/types.h>
#include <time.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <string.h>

#include <time.h>
#include <stdio.h>

#include <unistd.h>
#include <linux/spi/spidev.h>

static const char *device = "/dev/spidev0.0";
static uint32_t mode = 0;                 //用于保存 SPI 工作模式
static uint8_t bits = 8;                  // 接收、发送数据位数
static uint32_t speed = 10 * 1000 * 1000; /* 设置12M传输速度 */
static int g_SPI_Fd = 0;
int pabort(const char *s)
{
    perror(s);
    abort();
    return -1;
}

/*
* 初始化SPI ,初始化OLED 使用到的命令、数据控制引脚
*/
int spi_init1(void)
{
    int ret = 0;

    /*打开 SPI 设备*/
    g_SPI_Fd = open(device, O_RDWR);
    if (g_SPI_Fd < 0)
    {
        // return pabort("can't open /dev/spidev0.0 ");
        printf("can't open %s error: g_SPI_Fd=%d\n", device, g_SPI_Fd);
        return -1;
        // exit(-1);
    }

    /*
        * spi mode 设置SPI 工作模式
    */
    ret = ioctl(g_SPI_Fd, SPI_IOC_WR_MODE32, &mode);
    if (ret == -1)
        pabort("can't set spi mode");

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

    /*
        * bits per word  设置一个字节的位数
    */
    ret = ioctl(g_SPI_Fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
    if (ret == -1)
        pabort("can't set bits per word");

    ret = ioctl(g_SPI_Fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
    if (ret == -1)
        pabort("can't get bits per word");

    /*
        *max speed hz  设置SPI 最高工作频率
    */
     ret = ioctl(g_SPI_Fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
     if (ret == -1)
         pabort("can't set max speed hz");

     ret = ioctl(g_SPI_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("max speed: %d Hz (%d KHz)\n", speed, speed / 1000);

    return g_SPI_Fd;
}

void transfer1(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,
    };

    ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
    if (ret < 1)
    {
        pabort("can't send spi message");
    }
    // else
    // {
    //     printf("can send spi messagen ok\n");
    // }
}

/**
* 功 能：关闭SPI模块
*/
int SPI_Close1(void)
{
    if (g_SPI_Fd == 0) /* SPI是否已经打开*/
        return 0;
    close(g_SPI_Fd);
    g_SPI_Fd = 0;
    return 0;
}



u_int16_t CRCSPI(u_int8_t *p_Buf, int i_Buf)
{
    int i = 0;
    int j = 0;
    u_int16_t w_Temp;
    u_int16_t w_CRC = 0x55aa;
    for (i = 0; i < i_Buf; i++)
    {
        w_CRC ^= (*p_Buf++ << 8);
        for (j = 0; j < 8; j++)
        {
            w_Temp = w_CRC & 0x8000;
            w_CRC <<= 1;
            if (w_Temp)
                w_CRC ^= 0x8005;
        }
    }
    return w_CRC;
}

// 获取毫秒级时间格式
void get_format_time_ms(char *str_time)
{
    struct tm *tm_t;
    struct timeval time;
    gettimeofday(&time, NULL);
    tm_t = localtime(&time.tv_sec);
    if (NULL != tm_t)
    {
        sprintf(str_time, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
                tm_t->tm_year + 1900,
                tm_t->tm_mon + 1,
                tm_t->tm_mday,
                tm_t->tm_hour,
                tm_t->tm_min,
                tm_t->tm_sec,
                time.tv_usec / 1000);
    }

    return;
}
// typedef unsigned char u8;
int main(int argc, char **argv)
{

    int i = 0;
    char _Time_S_M[25];
    int ret = 0;
  
    // u8 tx[6] = {0x00, 0x84, 0x00, 0x10, 0x00, 0x00};
    // u8 rx[512] = {0};

    unsigned char tx_buffer[1024];
    unsigned char rx_buffer[1024];
    memset(_Time_S_M, 0, sizeof(_Time_S_M));
    memset(tx_buffer, 0, sizeof(tx_buffer));
    memset(rx_buffer, 0, sizeof(rx_buffer));

    tx_buffer[0] = 0x01;
    tx_buffer[1] = 0x02;
    tx_buffer[2] = 0x03;
    tx_buffer[3] = 0x04;
    tx_buffer[4] = 0x05;
    tx_buffer[5] = 0x06;
    tx_buffer[6] = 0x07;
    tx_buffer[7] = 0x08;
    tx_buffer[8] = 0x09;

    u_int16_t w_Crc12 = CRCSPI((tx_buffer + 4), 5);
    memcpy((tx_buffer + 9), &w_Crc12, 2);

    int i_File = spi_init1();

    while (1)
    {
        // usleep(9 * 1000);
        usleep(4 * 1000);
        get_format_time_ms(_Time_S_M);
        printf("tx_buffer:发送给spi 操作信息帧 数据");
        for (i = 0; i < 15; i++)
            printf("%.2X ", tx_buffer[i]);
        printf("\n");

        /*执行发送*/
        transfer1(i_File, tx_buffer, rx_buffer, sizeof(tx_buffer));
        printf("rx_buffer:接收到spi数据_Time_S_M[%s],[%d]\n", _Time_S_M, sizeof(rx_buffer));
        for (i = 0; i < sizeof(rx_buffer); i++)
            printf("%.2X ", rx_buffer[i]);
        printf("\n");

        fflush(stdout);
    }

    SPI_Close1();
    return -1;
}