ads1219.c

Go to the documentation of this file.

 
#include "ads1219.h"
 
#include <libtock-sync/services/alarm.h>
#include <libtock/peripherals/i2c_master.h>
#include <libtock/tock.h>
 
#include "../proto/sensor.h"
 
// Generic calibration values that give rough estimate
static const double voltage_calibration_m = -0.00039326;
static const double voltage_calibration_b = 4.92916378e-05;
static const double current_calibration_m = -1.18693164e-10;
static const double current_calibration_b = 4.14518594e-05;
 
static const uint8_t addr = 0x40;
static uint8_t addrls = addr << 1;
 
typedef enum {
  cmd_reset = 0x06,
  cmd_start = 0x08,
  cmd_powerdown = 0x02,
  cmd_rdata = 0x10,
  // prev 0x80
  cmd_rreg = 0x20,
  cmd_wreg = 0x40
} ads1219_cmd_t;
 
typedef union {
  uint8_t value;
  struct {
    uint8_t vref : 1;
    uint8_t mode : 1;
    uint8_t dr : 2;
    uint8_t gain : 1;
    uint8_t mux : 3;
  } bits;
} ConfigReg;
 
// const GPIO_TypeDef *data_ready_port = GPIOC;
 
// const uint16_t data_ready_pin = GPIO_PIN_0;
 
void power_on(void);
 
void power_off(void);
 
int measure(uint32_t* meas);
 
int configure(const ConfigReg reg_data);
 
int ads1219_reset(void) {
  int ret = RETURNCODE_SUCCESS;
 
  // Send the reset code
  uint8_t write_buf[1] = {cmd_reset};
  ret = i2c_master_write_sync(addrls, write_buf, 1);
  if (ret != RETURNCODE_SUCCESS) {
    return ADS1219_ERROR;
  }
 
  // wait minimum 500 us to reach steady state
  libtocksync_alarm_delay_ms(1);
 
  return ADS1219_SUCCESS;
}
 
int configure(const ConfigReg reg_data) {
  int ret = RETURNCODE_SUCCESS;
  uint8_t i2c_data[2] = {cmd_wreg, reg_data.value};
  ret = i2c_master_write_sync(addrls, (uint8_t*)i2c_data, sizeof(i2c_data));
  if (ret != RETURNCODE_SUCCESS) {
    return ADS1219_CONFIGURE;
  }
 
  return ADS1219_SUCCESS;
}
 
int ads1219_voltage_raw(uint32_t* voltage) {
  int ret = ADS1219_SUCCESS;
 
  ConfigReg reg_data = {0};
  reg_data.bits.vref = 1;
 
  // 0x21 is single shot and 0x23 is continuos
  // configure to read voltage
  ret = configure(reg_data);
  if (ret != ADS1219_SUCCESS) {
    return ret;
  }
 
  ret = measure(voltage);
  if (ret != ADS1219_SUCCESS) {
    return ret;
  }
 
  return ret;
}
 
int ads1219_voltage(double* voltage) {
  int ret = ADS1219_SUCCESS;
 
  uint32_t raw = 0;
  ret = ads1219_voltage_raw(&raw);
 
  *voltage = (voltage_calibration_m * (double)raw) + voltage_calibration_b;
  *voltage /= 1000;
 
  return ret;
}
 
int ads1219_current_raw(uint32_t* current) {
  int ret = ADS1219_SUCCESS;
  double meas = 0.0;
 
  ConfigReg reg_data = {0};
  reg_data.bits.mux = 0b001;
  reg_data.bits.vref = 1;
 
  // 0x21 is single shot and 0x23 is continuos
  // configure to read voltage
  ret = configure(reg_data);
  if (ret != ADS1219_SUCCESS) {
    return -1;
  }
 
  ret = measure(current);
  if (ret != ADS1219_SUCCESS) {
    return -1;
  }
 
  return meas;
}
 
int ads1219_current(double* current) {
  int ret = ADS1219_SUCCESS;
 
  uint32_t raw = 0;
  ret = ads1219_current_raw(&raw);
 
  *current = (current_calibration_m * (double)raw) + current_calibration_b;
  return ret;
}
 
void power_on(void) {
  // HAL_GPIO_WritePin(POWERDOWN_GPIO_Port, POWERDOWN_Pin, GPIO_PIN_SET);
  // HAL_Delay(1);
}
 
void power_off(void) {
  // HAL_GPIO_WritePin(POWERDOWN_GPIO_Port, POWERDOWN_Pin, GPIO_PIN_RESET);
}
 
int measure(uint32_t* meas) {
  int ret = RETURNCODE_SUCCESS;
 
  uint8_t rx_data[3] = {0x00, 0x00, 0x00};
 
  power_on();
 
  // start conversion
  uint8_t buf[1] = {cmd_start};
  ret = i2c_master_write_sync(addrls, buf, 1);
  if (ret != RETURNCODE_SUCCESS) {
    return ADS1219_CONVERSION;
  }
 
  // constant delay
  libtocksync_alarm_delay_ms(100);
 
  // TODO(jmadden173) implement data ready pin wait
  // Wait for the DRDY pin on the ADS12 to go low, this means data is ready
  // while (HAL_GPIO_ReadPin(data_ready_port, data_ready_pin)) {}
 
  // send read data command
  buf[0] = cmd_rdata;
  ret = i2c_master_write_sync(addrls, buf, 1);
  if (ret != RETURNCODE_SUCCESS) {
    return ADS1219_MEASURE;
  }
 
  // read 3 bytes of data
  ret = i2c_master_read_sync(addrls, rx_data, 3);
  if (ret != RETURNCODE_SUCCESS) {
    return ADS1219_MEASURE;
  }
 
  power_off();
 
  // Combine the 3 bytes into a 24-bit value
  *meas = ((int32_t)rx_data[0] << 16) | ((int32_t)rx_data[1] << 8) |
          ((int32_t)rx_data[2]);
  // Check if the sign bit (24th bit) is set
  if (*meas & 0x800000) {
    // Extend the sign to 32 bits
    *meas |= 0xFF000000;
  }
 
  return ADS1219_SUCCESS;
}
 
uint8_t ads1219_sensor_voltage(uint8_t* data, Metadata meta, uint32_t idx) {
  (void)idx;
 
  double voltage = 0.;
  ads1219_voltage(&voltage);
 
  // meta.logger_id = cfg->logger_id;
  // meta.cell_id = cfg->cell_id;
 
  size_t data_len = 0;
 
  SensorStatus status = SENSOR_OK;
  status = EncodeDoubleMeasurement(meta, voltage, SensorType_POWER_VOLTAGE,
                                   data, &data_len);
  if (status != SENSOR_OK) {
    return -1;
  }
 
  return data_len;
}
 
uint8_t ads1219_sensor_current(uint8_t* data, Metadata meta, uint32_t idx) {
  (void)idx;
 
  double current = 0.;
  ads1219_current(&current);
 
  size_t data_len = 0;
 
  SensorStatus status = SENSOR_OK;
  status = EncodeDoubleMeasurement(meta, current, SensorType_POWER_CURRENT,
                                   data, &data_len);
  if (status != SENSOR_OK) {
    return -1;
  }
 
  return data_len;
}