board_periph_i2c_devices.c

Go to the documentation of this file.

 
#include <string.h>
 
#include "board_periph.h"
#include "board_periph_i2c_internal.h"

typedef enum : uint32_t {
  k_lsm6dso_addr_7b      = 0x6BU,   
  k_lsm6dso_reg_who_am_i = 0x0FU,   
  k_lsm6dso_who_am_i_val = 0x6CU,   
  k_lsm6dso_reg_outx_l_g = 0x22U,   
  k_lsm6dso_reg_outz_l_a = 0x2CU,   
  k_lsm6dso_reg_file     = 0x100U,  
  k_lsm6dso_seed_accel_z = 0x4000U, 
  k_lsm6dso_seed_gyro_x  = 0x0100U, 
} lsm6dso_const_t;

typedef enum : uint32_t {
  k_max17048_addr_7b      = 0x36U,   
  k_max17048_reg_vcell    = 0x02U,   
  k_max17048_reg_soc      = 0x04U,   
  k_max17048_reg_version  = 0x08U,   
  k_max17048_reg_crate    = 0x16U,   
  k_max17048_reg_file     = 0x100U,  
  k_battery_soc_default   = 72U,     
  k_battery_soc_max       = 100U,    
  k_battery_vcell_default = 0xBE00U, 
  k_battery_version_val   = 0x0012U, 
  k_battery_crate_mag     = 0x0018U, 
  k_battery_byte_shift    = 8U,      
  k_battery_byte_mask     = 0xFFU,   
} max17048_const_t;

typedef struct {
  uint8_t  regs[k_lsm6dso_reg_file]; 
  uint16_t reg_ptr;                  
  bool     ptr_set;                  
  uint32_t reads;                    
} lsm6dso_state_t;

typedef struct {
  uint8_t soc_pct;  
  bool    charging; 
} battery_state_t;

typedef struct {
  uint8_t  regs[k_max17048_reg_file]; 
  uint16_t reg_ptr;                   
  bool     ptr_set;                   
  uint32_t reads;                     
} max17048_state_t;
 
static lsm6dso_state_t s_lsm6dso;

static battery_state_t  s_battery = {.soc_pct = (uint8_t)k_battery_soc_default, .charging = false};
static max17048_state_t s_fuelgauge;

RA8_INTERNAL static void internal_lsm6dso_seed16(lsm6dso_state_t* s, uint8_t reg, uint16_t val)
{
  s->regs[reg]                 = (uint8_t)((uint32_t)val & (uint32_t)k_i3c_dev_byte_mask);
  s->regs[(uint8_t)(reg + 1U)] = (uint8_t)((uint32_t)val >> 8U);
}

RA8_INTERNAL static void internal_lsm6dso_reset_regs(lsm6dso_state_t* s)
{
  for (uint32_t i = 0U; i < (uint32_t)k_lsm6dso_reg_file; i++) {
    s->regs[i] = 0U;
  }
  s->regs[(uint8_t)k_lsm6dso_reg_who_am_i] = (uint8_t)k_lsm6dso_who_am_i_val;
  internal_lsm6dso_seed16(s, (uint8_t)k_lsm6dso_reg_outz_l_a, (uint16_t)k_lsm6dso_seed_accel_z);
  internal_lsm6dso_seed16(s, (uint8_t)k_lsm6dso_reg_outx_l_g, (uint16_t)k_lsm6dso_seed_gyro_x);
  s->reg_ptr = 0U;
  s->ptr_set = false;
  s->reads   = 0U;
}

RA8_INTERNAL static void internal_lsm6dso_write(void* ctx, uint8_t byte)
{
  lsm6dso_state_t* s = (lsm6dso_state_t*)ctx;
  if (!s->ptr_set) {
    s->reg_ptr = byte;
    s->ptr_set = true;
    return;
  }
  if (s->reg_ptr < (uint16_t)k_lsm6dso_reg_file) {
    s->regs[s->reg_ptr] = byte; /* CTRL config writes land harmlessly. */
  }
  s->reg_ptr = (uint16_t)(s->reg_ptr + 1U);
}

RA8_INTERNAL static uint32_t internal_lsm6dso_read(void* ctx, uint8_t* buf, uint32_t max)
{
  lsm6dso_state_t* s = (lsm6dso_state_t*)ctx;
  for (uint32_t i = 0U; i < max; i++) {
    buf[i]     = (s->reg_ptr < (uint16_t)k_lsm6dso_reg_file) ? s->regs[s->reg_ptr] : 0U;
    s->reg_ptr = (uint16_t)(s->reg_ptr + 1U);
  }
  s->reads++;
  return max;
}

RA8_INTERNAL static void internal_lsm6dso_stop(void* ctx)
{
  lsm6dso_state_t* s = (lsm6dso_state_t*)ctx;
  s->ptr_set         = false;
}

RA8_INTERNAL static void internal_fuelgauge_put16(max17048_state_t* s, uint8_t reg, uint16_t val)
{
  s->regs[reg]                 = (uint8_t)(val >> (uint16_t)k_battery_byte_shift);
  s->regs[(uint8_t)(reg + 1U)] = (uint8_t)(val & (uint16_t)k_battery_byte_mask);
}

RA8_INTERNAL static void internal_fuelgauge_seed(max17048_state_t* s)
{
  for (uint32_t i = 0U; i < (uint32_t)k_max17048_reg_file; i++) {
    s->regs[i] = 0U;
  }
  internal_fuelgauge_put16(s, (uint8_t)k_max17048_reg_vcell, (uint16_t)k_battery_vcell_default);
  /* SOC: high byte is the integer percent, low byte the 1/256 fraction (0). */
  internal_fuelgauge_put16(
    s,
    (uint8_t)k_max17048_reg_soc,
    (uint16_t)((uint16_t)s_battery.soc_pct << (uint16_t)k_battery_byte_shift));
  internal_fuelgauge_put16(s, (uint8_t)k_max17048_reg_version, (uint16_t)k_battery_version_val);
  /* CRATE is signed: positive while charging, negative while discharging. */
  const int32_t crate =
    s_battery.charging ? (int32_t)k_battery_crate_mag : -(int32_t)k_battery_crate_mag;
  internal_fuelgauge_put16(s, (uint8_t)k_max17048_reg_crate, (uint16_t)(int16_t)crate);
}

RA8_INTERNAL static void internal_fuelgauge_write(void* ctx, uint8_t byte)
{
  max17048_state_t* s = (max17048_state_t*)ctx;
  if (!s->ptr_set) {
    s->reg_ptr = byte;
    s->ptr_set = true;
    return;
  }
  if (s->reg_ptr < (uint16_t)k_max17048_reg_file) {
    s->regs[s->reg_ptr] = byte;
  }
  s->reg_ptr = (uint16_t)(s->reg_ptr + 1U);
}

RA8_INTERNAL static uint32_t internal_fuelgauge_read(void* ctx, uint8_t* buf, uint32_t max)
{
  max17048_state_t* s = (max17048_state_t*)ctx;
  for (uint32_t i = 0U; i < max; i++) {
    buf[i]     = (s->reg_ptr < (uint16_t)k_max17048_reg_file) ? s->regs[s->reg_ptr] : 0U;
    s->reg_ptr = (uint16_t)(s->reg_ptr + 1U);
  }
  s->reads++;
  return max;
}

RA8_INTERNAL static void internal_fuelgauge_stop(void* ctx)
{
  max17048_state_t* s = (max17048_state_t*)ctx;
  s->ptr_set          = false;
}
 
void board_periph_battery_set(uint8_t soc_pct, bool charging)
{
  s_battery.soc_pct = (soc_pct > (uint8_t)k_battery_soc_max) ? (uint8_t)k_battery_soc_max : soc_pct;
  s_battery.charging = charging;
  internal_fuelgauge_seed(&s_fuelgauge);
}
 
void board_periph_battery_get(uint8_t* out_soc, bool* out_charging)
{
  if (out_soc != nullptr) {
    *out_soc = s_battery.soc_pct;
  }
  if (out_charging != nullptr) {
    *out_charging = s_battery.charging;
  }
}

void priv_board_i2c_imu_fuel_reset(void)
{
  internal_lsm6dso_reset_regs(&s_lsm6dso);
  s_fuelgauge = (max17048_state_t){};
  internal_fuelgauge_seed(&s_fuelgauge); /* lay the register file from s_battery (CLI-set) */
}

void priv_board_i2c_imu_fuel_register(void)
{
  priv_i2c_device_register((uint8_t)k_lsm6dso_addr_7b,
                           internal_lsm6dso_write,
                           internal_lsm6dso_read,
                           internal_lsm6dso_stop,
                           &s_lsm6dso);
  /* MAX17048-class fuel gauge at 0x36: exposes the battery state-of-charge +
   * charge direction so a battery monitor reads a real % over I2C. */
  priv_i2c_device_register((uint8_t)k_max17048_addr_7b,
                           internal_fuelgauge_write,
                           internal_fuelgauge_read,
                           internal_fuelgauge_stop,
                           &s_fuelgauge);
}

uint32_t priv_board_i2c_imu_reads(void)
{
  return s_lsm6dso.reads;
}