SpiDevice Class Reference

#include <bsp_spi.hpp>

Public Member Functions
	SpiDevice (const std::string &device, uint32_t speed, uint8_t mode)
	~SpiDevice ()
uint8_t	ReadRegister (Gpio *cs, uint8_t reg)
void	WriteRegister (Gpio *cs, uint8_t reg, uint8_t value)
void	ReadRegisters (Gpio *cs, uint8_t reg, uint8_t *buffer, size_t length)
int	Fd () const
uint32_t	Speed () const

Private Attributes
int	fd_
uint32_t	speed_

Detailed Description

SPI device interface for configuration and register operations.

Definition at line 20 of file bsp_spi.hpp.

Constructor & Destructor Documentation

SpiDevice()

SpiDevice::SpiDevice ( const std::string &  device, uint32_t  speed, uint8_t  mode  )

inline

Opens and configures the SPI device.

Parameters

device	SPI device file path (e.g., "/dev/spidev0.0")
speed	Transfer speed in Hz
mode	SPI mode (e.g., SPI_MODE_0)

Definition at line 29 of file bsp_spi.hpp.

      : fd_(open(device.c_str(), O_RDWR)), speed_(speed) {
    assert(!device.empty()); /* Ensure device string is valid */
 
    if (fd_ < 0) {
      std::perror("Failed to open SPI device");
    }
 
    if (ioctl(fd_, SPI_IOC_WR_MODE, &mode) < 0 ||
        ioctl(fd_, SPI_IOC_WR_MAX_SPEED_HZ, &speed_) < 0) {
      close(fd_);
      std::perror("Failed to configure SPI device");
    }
  }

~SpiDevice()

SpiDevice::~SpiDevice ( )

inline

Closes the SPI device.

Definition at line 45 of file bsp_spi.hpp.

               {
    if (fd_ >= 0) {
      close(fd_);
    }
  }

Member Function Documentation

Fd()

int SpiDevice::Fd ( ) const

inline

Definition at line 133 of file bsp_spi.hpp.

{ return fd_; }

ReadRegister()

uint8_t SpiDevice::ReadRegister ( Gpio *  cs, uint8_t  reg  )

inline

Reads a register via SPI.

Parameters

cs	GPIO chip select (active low)
reg	Register address (MSB set to 1 for read operation)

Returns

Read value

Definition at line 58 of file bsp_spi.hpp.

                                              {
    assert(cs); /* Ensure GPIO object is valid */
 
    std::array<uint8_t, 2> tx_buf = {{static_cast<uint8_t>(reg | 0x80), 0}};
    std::array<uint8_t, 2> rx_buf = {{0, 0}};
    struct spi_ioc_transfer transfer{};
    transfer.tx_buf = reinterpret_cast<uint64_t>(tx_buf.data());
    transfer.rx_buf = reinterpret_cast<uint64_t>(rx_buf.data());
    transfer.len = tx_buf.size();
    transfer.speed_hz = speed_;
    transfer.bits_per_word = 8;
 
    cs->Write(0);
    usleep(10);
    if (ioctl(fd_, SPI_IOC_MESSAGE(1), &transfer) < 0) {
      cs->Write(1);
      std::perror("SPI read failed");
    }
    cs->Write(1);
 
    return rx_buf[1];
  }

ReadRegisters()

void SpiDevice::ReadRegisters ( Gpio *  cs, uint8_t  reg, uint8_t *  buffer, size_t  length  )

inline

Definition at line 107 of file bsp_spi.hpp.

                                                                            {
    assert(cs);
    assert(buffer);
 
    std::vector<uint8_t> tx_buf(length + 1, 0);
    std::vector<uint8_t> rx_buf(length + 1, 0);
    tx_buf[0] = reg | 0x80;
 
    struct spi_ioc_transfer transfer{};
    transfer.tx_buf = reinterpret_cast<uint64_t>(tx_buf.data());
    transfer.rx_buf = reinterpret_cast<uint64_t>(rx_buf.data());
    transfer.len = tx_buf.size();
    transfer.speed_hz = speed_;
    transfer.bits_per_word = 8;
 
    cs->Write(0);
    usleep(10);
    if (ioctl(fd_, SPI_IOC_MESSAGE(1), &transfer) < 0) {
      cs->Write(1);
      std::perror("SPI multiple read failed");
    }
    cs->Write(1);
 
    std::memcpy(buffer, rx_buf.data() + 1, length);
  }

Speed()

uint32_t SpiDevice::Speed ( ) const

inline

Definition at line 135 of file bsp_spi.hpp.

{ return speed_; }

WriteRegister()

void SpiDevice::WriteRegister ( Gpio *  cs, uint8_t  reg, uint8_t  value  )

inline

Writes a value to a register via SPI.

Parameters

cs	GPIO chip select
reg	Register address
value	Value to write

Definition at line 88 of file bsp_spi.hpp.

                                                           {
    assert(cs); /* Ensure GPIO object is valid */
 
    std::array<uint8_t, 2> tx_buf = {{reg, value}};
    struct spi_ioc_transfer transfer{};
    transfer.tx_buf = reinterpret_cast<uint64_t>(tx_buf.data());
    transfer.len = tx_buf.size();
    transfer.speed_hz = speed_;
    transfer.bits_per_word = 8;
 
    cs->Write(0);
    usleep(10);
    if (ioctl(fd_, SPI_IOC_MESSAGE(1), &transfer) < 0) {
      cs->Write(1);
      std::perror("SPI write failed");
    }
    cs->Write(1);
  }

Field Documentation

fd_

int SpiDevice::fd_

private

Definition at line 138 of file bsp_spi.hpp.

speed_

uint32_t SpiDevice::speed_

private

Definition at line 139 of file bsp_spi.hpp.

---

The documentation for this class was generated from the following file:

• src/bsp/bsp_spi.hpp