Чтение блока данных из определенного регистра (fifo) с использованием c / c ++ и i2c в Raspberry Pi

Question

Мне нужно прочитать 4 байта данных из чипа MAX30100, используя c / c ++ и I2C на Raspberry Pi.Я пытался сделать это с Python.И это сработало.Но проблема заключалась в том, что скорость передачи данных была слишком медленной, мне нужно обновлять данные как минимум 250 раз в секунду, что означает, что частота чтения> 250 Гц.Итак, я переключил чтение с python на c / c ++.

Нет проблем при чтении или записи одного байта с помощью wiringPi.Однако мне нужно прочитать 4 байта из fifo (адрес fifo равен 0x04), wiringPi не предоставляет функцию для чтения данных блока.Есть только функции чтения байтов / слов.

Затем я попытался использовать SMBus для чтения блока, который можно найти здесь: https://github.com/leon-anavi/rpi-examples/blob/master/BMP180/c/smbus.c

Но, как только я вызываюi2c_smbus_read_block_data (), мой Raspberry Pi полностью зависает.

Вот данные блока чтения, которые я добавил в wiringPiI2C.c:

void i2c_smbus_read_block_data(int fd, int command, uint8_t *values, int length)
{
    union i2c_smbus_data data;
    int i, err;

    err = i2c_smbus_access(fd, I2C_SMBUS_READ, command,
                   I2C_SMBUS_BLOCK_DATA, &data);
    if (err < 0)
        return;
    printf("test1");
    for (i = 1; i <= length; i++)
        values[i-1] = data.block[i];
}

wiringPiI2C.c можно найти здесь: https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPiI2C.c

Кто-нибудь знает, что там происходит?Или есть лучшее решение?

Answer 1

Для людей, которые все еще заинтересованы. Вот рабочее решение для меня, которое я протестировал лишь кратко. (C ++)

#include <unistd.h>        //Needed for I2C port
#include <fcntl.h>          //Needed for I2C port
#include <sys/ioctl.h>      //Needed for I2C port
#include <linux/i2c-dev.h>  //Needed for I2C port
#include <linux/i2c.h>      //Needed for I2C port

#include <iostream>
#include <iomanip>
#include <string>
#include <cerrno>
#include <cstdint>
#include <cstring>

const std::string i2c_filename = "/dev/i2c-1";
const int i2c_addr = 0x5b;          //<<<<<The I2C address of the slave

static inline int i2c_rdwr_block(int fd, uint8_t reg, uint8_t read_write, uint8_t length, unsigned char* buffer)
{
    struct i2c_smbus_ioctl_data ioctl_data;
    union i2c_smbus_data smbus_data;

    int rv; 

    if(length > I2C_SMBUS_BLOCK_MAX) 
    {
        std::cerr << "Requested Length is greater than the maximum specified" << std::endl;
        return -1;
    }

    // First byte is always the size to write and to receive 
    // https://github.com/torvalds/linux/blob/master/drivers/i2c/i2c-core-smbus.c  
    // (See i2c_smbus_xfer_emulated CASE:I2C_SMBUS_I2C_BLOCK_DATA)
    smbus_data.block[0] = length;

    if ( read_write != I2C_SMBUS_READ )
    {
        for(int i = 0; i < length; i++)
        {
            smbus_data.block[i + 1] = buffer[i];
        }
    }


    ioctl_data.read_write = read_write;
    ioctl_data.command = reg;
    ioctl_data.size = I2C_SMBUS_I2C_BLOCK_DATA;
    ioctl_data.data = &smbus_data;

    rv = ioctl (fd, I2C_SMBUS, &ioctl_data);
    if (rv < 0)
    {
        std::cerr << "Accessing I2C Read/Write failed! Error is: " << strerror(errno) << std::endl;
        return rv;
    }

    if (read_write == I2C_SMBUS_READ)
    {
        for(int i = 0; i < length; i++)
        {
            // Skip the first byte, which is the length of the rest of the block.
            buffer[i] = smbus_data.block[i+1];
        }
    }

    return rv;
}

static int setup_i2c(std::string filename)
{
    //----- OPEN THE I2C BUS -----

    int fd;
    int rv;

    if ((fd = open(filename.c_str(), O_RDWR)) < 0)
    {
        //ERROR HANDLING: you can check errno to see what went wrong
        std::cout << "Failed to open the i2c bus. Error code: " << fd << std::endl;
        return fd;
    }

    if ((rv = ioctl(fd, I2C_SLAVE, i2c_addr)) < 0)
    {
        std::cout << "Failed to acquire bus access and/or talk to slave. Error code: " << rv << std::endl;
        //ERROR HANDLING; you can check errno to see what went wrong
        return rv;
    }

    return fd;
}

int main()
{
    int fd_i2c = setup_i2c(i2c_filename);
    int i2c_data_length = 3;
    int rv;
    unsigned char buffer[i2c_data_length + 1] = {0};

    if (fd_i2c < 0)
    {
        std::cerr << "Set UP I2C Bus Error. Exit now!" << std::endl;
        return -1;
    }

    //std::cout << "File Descriptor: " << fd_i2c << std::endl;

    //rv = read_i2c(fd_i2c, buffer, i2c_data_length);
    rv = i2c_rdwr_block(fd_i2c, 0x22, I2C_SMBUS_READ, i2c_data_length, buffer);

    if (rv < 0)
    {
        std::cerr << "Reading I2C Bus Error..." << std::endl;
        return -1;
    }

    std::cout << "Buffer Value: " ;

    for (int i = 0; i < i2c_data_length; i++)
    {
        std::cout << "0x" << std::setfill('0') << std::setw(2) << std::hex << (int) buffer[i] << " " ;
    }

    std::cout << std::endl;

    unsigned char values[i2c_data_length] = {0};
    values[0] = 0x01;
    values[1] = 0x02;
    values[2] = 0x03;

    //rv = write_i2c(fd_i2c, values, i2c_data_length);
    rv = i2c_rdwr_block(fd_i2c, 0x22, I2C_SMBUS_WRITE, i2c_data_length, values);

    if (rv < 0)
    {
        std::cerr << "Writing I2C Bus Error..." << std::endl;
        return -1;
    }

    return 0;
}

Ключом для этого блока кода является опция I2C_SMBUS_I2C_BLOCK_DATA (которая определена в "linux / i2c-dev.h", также см. "Linux / i2c.h"). Это преобразует данные вашего блока SMBus в данные блока I2C. В частности, данные блока SMBus - это «команда, размер_блока, данные», а данные блока I2C - «команда, данные» и используют двухпроводную синхронизацию для определения сигнала STOP.

Пожалуйста, обратитесь к исходному коду ядра Linux Linux / драйверы / i2c / i2c-ядро-smbus.c И функция,

static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
                   unsigned short flags,
                   char read_write, u8 command, int size,
                 union i2c_smbus_data *data)

(i2c_smbus_xfer является первой вызванной функцией и возвращается к i2c_smbus_xfer_emulated - у адаптера нет встроенной поддержки SMBus. Поэтому эти две функции должны реализовывать одно и то же.)

Посмотрите на

case I2C_SMBUS_I2C_BLOCK_DATA:

внимательно показывает, как осуществляется перевод с шины SMBus на шину I2C.

Также сравните

case I2C_SMBUS_BLOCK_DATA:

И посмотри как не переводит. (Отправить данные SMBus напрямую)

Более подробную информацию можно найти в документации ядра Linux на интерфейсе устройства i2c , а также на драйвере i2c исходный код