bsp_i2c.hpp

#pragma once
 
#include <fcntl.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
#include <cassert>
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <string>
#include <vector>
 
class I2cDevice {
 public:
  I2cDevice(const std::string& device, uint8_t addr)
      : fd_(open(device.c_str(), O_RDWR)), addr_(addr) {
    assert(!device.empty()); /* Ensure device string is valid */
 
    if (fd_ < 0) {
      std::perror("Failed to open I2C device");
    }
 
    if (ioctl(fd_, I2C_SLAVE, addr_) < 0) {
      close(fd_);
      std::perror("Failed to configure I2C address");
    }
  }
 
  ~I2cDevice() {
    if (fd_ >= 0) {
      close(fd_);
    }
  }
 
  uint8_t ReadRegister(uint8_t reg) {
    if (write(fd_, &reg, 1) != 1) {
      std::perror("I2C write (set register) failed");
    }
 
    uint8_t value = 0;
    if (read(fd_, &value, 1) != 1) {
      std::perror("I2C read failed");
    }
 
    return value;
  }
 
  void WriteRegister(uint8_t reg, uint8_t value) {
    uint8_t buf[2] = {reg, value};
    if (write(fd_, buf, 2) != 2) {
      std::perror("I2C write failed");
    }
  }
 
  void ReadRegisters(uint8_t reg, uint8_t* buffer, size_t length) {
    assert(buffer);
 
    if (write(fd_, &reg, 1) != 1) {
      std::perror("I2C write (set start register) failed");
    }
 
    if (read(fd_, buffer, length) != static_cast<ssize_t>(length)) {
      std::perror("I2C multi-byte read failed");
    }
  }
 
  void WriteRaw(const uint8_t* data, size_t length) {
    assert(data);
 
    if (write(fd_, data, length) != static_cast<ssize_t>(length)) {
      std::perror("I2C raw write failed");
    }
  }
 
  int Fd() const { return fd_; }
 
  uint8_t Address() const { return addr_; }
 
 private:
  int fd_;       /* I2C file descriptor */
  uint8_t addr_; /* I2C device address */
};