ads1115.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <thread>
 
#include "bsp_gpio.hpp"
#include "bsp_i2c.hpp"
 
template <int CHANNEL_NUM>
class Ads1115 {
 public:
  static constexpr uint8_t DEFAULT_I2C_ADDR = 0x48;
  static constexpr uint8_t POINTER_CONVERSION = 0x00;
  static constexpr uint8_t POINTER_CONFIG = 0x01;
 
  Ads1115(I2cDevice& i2c, Gpio& drdy, uint8_t address = DEFAULT_I2C_ADDR)
      : i2c_(i2c), drdy_gpio_(drdy), i2c_addr_(address) {
    EnableReadyInterruptMode();
    StartScan();
  }
 
  void StartScan() {
    scanning_ = true;
    current_channel_ = 0;
    ConfigureChannel(current_channel_);
 
    drdy_gpio_.EnableInterruptRisingEdgeWithCallback(
        [this]() { OnDataReady(); });
  }
 
  void Stop() { scanning_ = false; }
 
  float GetVoltage(int channel) const {
    if (channel < 0 || channel >= CHANNEL_NUM) {
      return 0.0f;
    }
    return voltages_[channel];
  }
 
  void EnableReadyInterruptMode() {
    // Set Lo_thresh = 0x0000 (MSB = 0)
    uint8_t lo_thresh[3] = {0x02, 0x00, 0x00};
    i2c_.WriteRaw(lo_thresh, 3);
 
    // Set Hi_thresh = 0x8000 (MSB = 1)
    uint8_t hi_thresh[3] = {0x03, 0x80, 0x00};
    i2c_.WriteRaw(hi_thresh, 3);
  }
 
  void Display() const {
    for (int i = 0; i < CHANNEL_NUM; ++i) {
      std::cout << "Channel " << i << ": " << voltages_[i] << " V  ";
    }
    std::cout << '\n';
  }
 
  void RegisterChannelCallback(int channel, std::function<void(float)> cb) {
    if (channel >= 0 && channel < CHANNEL_NUM) {
      callbacks_[channel] = cb;
    }
  }
 
 private:
  // NOLINTNEXTLINE
  I2cDevice& i2c_;
  // NOLINTNEXTLINE
  Gpio& drdy_gpio_;
  uint8_t i2c_addr_;
  std::function<void(float)> callbacks_[CHANNEL_NUM];
 
  std::atomic<bool> scanning_{false};
  int current_channel_ = 0;
  float voltages_[CHANNEL_NUM] = {0.0f};
 
  void OnDataReady() {
    if (!scanning_) {
      return;
    }
 
    // Read and convert voltage
    int16_t raw = ReadConversion();
    voltages_[current_channel_] =
        static_cast<float>(raw) * 0.000125f;  // 125 µV/LSB
 
    // Invoke user callback
    if (callbacks_[current_channel_]) {
      callbacks_[current_channel_](voltages_[current_channel_]);
    }
 
    // Switch to next channel
    current_channel_ = (current_channel_ + 1) % CHANNEL_NUM;
    ConfigureChannel(current_channel_);
  }
 
  void ConfigureChannel(int channel) {
    if (channel < 0 || channel > 3) {
      return;
    }
 
    uint16_t config = 0;
    config |= (0x04 + channel) << 12;  // MUX: AINx vs GND
    config |= (1 << 9);                // PGA ±4.096V
    config |= (0 << 8);                // Mode: Continuous
    config |= (0b111 << 5);            // Data Rate: 860 SPS
 
    uint8_t data[3] = {
        POINTER_CONFIG,
        static_cast<uint8_t>((config >> 8) & 0xFF),
        static_cast<uint8_t>(config & 0xFF),
    };
 
    i2c_.WriteRaw(data, 3);
 
    // Wait for config to take effect; discard first reading
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    ReadConversion();
  }
 
  int16_t ReadConversion() {
    uint8_t pointer = POINTER_CONVERSION;
    i2c_.WriteRaw(&pointer, 1);
 
    uint8_t buf[2] = {};
    i2c_.ReadRegisters(POINTER_CONVERSION, buf, 2);
 
    return static_cast<int16_t>((buf[0] << 8) | buf[1]);
  }
};