ads7952_types.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstdint>
#include <type_traits>
 
namespace ads7952 {
 
// =============================================================================
// Operating Mode
// =============================================================================
enum class Mode : uint8_t {
  Manual,  
  Auto1,   
  Auto2,   
};
 
// =============================================================================
// Input Voltage Range
// =============================================================================
enum class Range : uint8_t {
  Vref,     
  TwoVref,  
};
 
// =============================================================================
// Power-Down Control
// =============================================================================
enum class PowerDown : uint8_t {
  Normal,    
  PowerDown, 
};
 
// =============================================================================
// Alarm Bound Selection
// =============================================================================
enum class AlarmBound : uint8_t {
  Low  = 0,  
  High = 1,  
};
 
// =============================================================================
// Error Codes
// =============================================================================
enum class Error : uint8_t {
  Ok = 0,            
  NotInitialized,    
  InvalidChannel,    
  SpiError,          
  ProgrammingFailed, 
  ModeChangeFailed,  
  Timeout,           
};
 
// =============================================================================
// GPIO 0/1 Alarm Assignment Modes
// =============================================================================
enum class GPIO01AlarmMode : uint8_t {
  GPIO                          = 0, 
  GPIO0_HighAndLowAlarm         = 1, 
  GPIO0_HighAlarm               = 2, 
  GPIO1_HighAlarm               = 4, 
  GPIO1_LowAlarm_GPIO0_HighAlarm = 6, 
};
 
// =============================================================================
// GPIO Pin Index Constants (usable with SetGPIOOutputs and GPIOConfig)
// =============================================================================
namespace gpio {
  inline constexpr uint8_t kGPIO0 = 0x01; 
  inline constexpr uint8_t kGPIO1 = 0x02; 
  inline constexpr uint8_t kGPIO2 = 0x04; 
  inline constexpr uint8_t kGPIO3 = 0x08; 
  inline constexpr uint8_t kAll   = 0x0F; 
  inline constexpr uint8_t kNone  = 0x00; 
} // namespace gpio
 
// =============================================================================
// GPIO Configuration Structure
// =============================================================================
struct GPIOConfig {
  GPIO01AlarmMode alarm_mode         = GPIO01AlarmMode::GPIO;
  bool gpio2_as_range_input          = false; 
  bool gpio3_as_powerdown_input      = false; 
 
  uint8_t direction_mask             = 0;
 
  bool reset_all_registers           = false; 
};
 
// =============================================================================
// Single-Channel Read Result
// =============================================================================
struct ReadResult {
  uint16_t count   = 0;        
  float    voltage = 0.0f;     
  uint8_t  channel = 0;        
  Error    error   = Error::Ok;
 
  bool ok() const noexcept { return error == Error::Ok; }
};
 
// =============================================================================
// Multi-Channel Readings Container
// =============================================================================
struct ChannelReadings {
  static constexpr uint8_t MAX_CHANNELS = 12;
 
  uint16_t count[MAX_CHANNELS]   = {};      
  float    voltage[MAX_CHANNELS] = {};      
 
  uint16_t valid_mask            = 0;
 
  Error    error                 = Error::Ok;
 
  bool ok() const noexcept { return error == Error::Ok; }
 
  bool hasChannel(uint8_t ch) const noexcept {
    return ch < MAX_CHANNELS && (valid_mask & (1U << ch));
  }
 
  uint8_t validChannelCount() const noexcept {
    uint16_t x = valid_mask;
    x = x - ((x >> 1) & 0x5555);
    x = (x & 0x3333) + ((x >> 2) & 0x3333);
    return static_cast<uint8_t>((((x + (x >> 4)) & 0x0F0F) * 0x0101) >> 8);
  }
};
 
// =============================================================================
// Channel Mask Helpers
// =============================================================================
template <typename... Channels>
constexpr uint16_t ChannelMask(Channels... channels) noexcept {
  static_assert((std::is_integral_v<Channels> && ...),
                "ChannelMask arguments must be integers");
  uint16_t mask = 0;
  ((mask |= static_cast<uint16_t>(1U << (static_cast<uint8_t>(channels) & 0x0F))), ...);
  return mask & 0x0FFF;
}
 
constexpr uint16_t ChannelRangeMask(uint8_t first, uint8_t last) noexcept {
  if (first > 11 || last > 11 || first > last) return 0;
  // (1 << (last+1)) - (1 << first) generates contiguous set bits
  return static_cast<uint16_t>(
      ((1U << (last + 1)) - (1U << first)) & 0x0FFF);
}
 
inline constexpr uint16_t kAllChannels  = 0x0FFF; 
inline constexpr uint16_t kEvenChannels = 0x0555; 
inline constexpr uint16_t kOddChannels  = 0x0AAA; 
inline constexpr uint16_t kFirstFour    = 0x000F; 
inline constexpr uint16_t kSecondFour   = 0x00F0; 
inline constexpr uint16_t kThirdFour    = 0x0F00; 
 
// =============================================================================
// Voltage-Count Conversion Helpers
// =============================================================================
constexpr uint16_t VoltageToCount(float voltage, float vref) noexcept {
  if (vref <= 0.0f || voltage <= 0.0f) return 0;
  float raw = (voltage / vref) * 4095.0f;
  if (raw > 4095.0f) return 4095;
  return static_cast<uint16_t>(raw);
}
 
} // namespace ads7952