michaelh/zephyr
1
0
Fork 0
Code Releases Activity

sensor: add MAX17262 fuel gauge driver and sample application

Browse source 
The MAX17262 is an ultra-low power fuel-gauge IC which implements the
Maxim ModelGauge m5 algorithm. The IC monitors a single-cell battery
pack and supports internal current sensing for up to 3.1A pulse
current. The IC provides best performance for batteries with 100mAhr
to 6Ahr capacity.

Signed-off-by: Matija Tudan <mtudan@mobilisis.hr>
This commit is contained in:
Matija Tudan 2020-12-29 22:06:09 +01:00 • committed by Carles Cufí
commit d2c503f202
15 changed files with 678 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

7
drivers/sensor/max17262/CMakeLists.txt Normal file
View file

@ -0,0 +1,7 @@
# Copyright 2020 Matija Tudan
#
# SPDX-License-Identifier: Apache-2.0
zephyr_library()
zephyr_library_sources_ifdef(CONFIG_MAX17262 max17262.c)

11
drivers/sensor/max17262/Kconfig Normal file
View file

@ -0,0 +1,11 @@
# Copyright 2020 Matija Tudan
#
# SPDX-License-Identifier: Apache-2.0
config MAX17262
bool "MAX17262 Fuel Gauge"
depends on I2C
help
Enable I2C-based driver for MAX17262 Fuel Gauge. This driver supports
reading various sensor settings including voltage, current, temperature,
time to full/empty and remaining capacity in mAh.

343
drivers/sensor/max17262/max17262.c Normal file
View file

@ -0,0 +1,343 @@
/*
* Copyright 2021 Matija Tudan
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <drivers/i2c.h>
#include <drivers/sensor.h>
#include <logging/log.h>
LOG_MODULE_REGISTER(max17262, CONFIG_SENSOR_LOG_LEVEL);
#include "max17262.h"
#define DT_DRV_COMPAT maxim_max17262
/**
* @brief Read a register value
*
* Registers have an address and a 16-bit value
*
* @param dev MAX17262 device to access
* @param reg_addr Register address to read
* @param valp Place to put the value on success
* @return 0 if successful, or negative error code from I2C API
*/
static int max17262_reg_read(const struct device *dev, uint8_t reg_addr,
int16_t *valp)
{
const struct max17262_config *cfg = dev->config;
uint8_t i2c_data[2];
int rc;
rc = i2c_burst_read(cfg->i2c, cfg->i2c_addr, reg_addr,
i2c_data, 2);
if (rc < 0) {
LOG_ERR("Unable to read register");
return rc;
}
*valp = ((int16_t)i2c_data[1] << 8) | i2c_data[0];
return 0;
}
/**
* @brief Write a register value
*
* Registers have an address and a 16-bit value
*
* @param dev MAX17262 device to access
* @param reg_addr Register address to write to
* @param val Register value to write
* @return 0 if successful, or negative error code from I2C API
*/
static int max17262_reg_write(const struct device *dev, uint8_t reg_addr,
int16_t val)
{
const struct max17262_config *cfg = dev->config;
uint8_t i2c_data[3] = {reg_addr, val & 0xFF, (uint16_t)val >> 8};
return i2c_write(cfg->i2c, i2c_data, sizeof(i2c_data),
cfg->i2c_addr);
}
/**
* @brief Convert sensor value from millis
*
* @param val Where to store converted value in sensor_value format
* @param val_millis Value in millis
*/
static void convert_millis(struct sensor_value *val, int32_t val_millis)
{
val->val1 = val_millis / 1000;
val->val2 = (val_millis % 1000) * 1000;
}
/**
* @brief Convert raw register values for specific channel
*
* @param dev MAX17262 device to access
* @param chan Channel number to read
* @param valp Returns the sensor value read on success
* @return 0 if successful
* @return -ENOTSUP for unsupported channels
*/
static int max17262_channel_get(const struct device *dev,
enum sensor_channel chan,
struct sensor_value *valp)
{
const struct max17262_config *const config = dev->config;
struct max17262_data *const data = dev->data;
int32_t tmp;
switch (chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
/* Get voltage in uV */
tmp = data->voltage * VOLTAGE_MULTIPLIER_UV;
/* Convert to V */
valp->val1 = tmp / 1000000;
valp->val2 = tmp % 1000000;
break;
case SENSOR_CHAN_GAUGE_AVG_CURRENT: {
int current;
/* Get avg current in nA */
current = data->avg_current * CURRENT_MULTIPLIER_NA;
/* Convert to mA */
valp->val1 = current / 1000000;
valp->val2 = current % 1000000;
break;
}
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
valp->val1 = data->state_of_charge / 256;
valp->val2 = data->state_of_charge % 256 * 1000000 / 256;
break;
case SENSOR_CHAN_GAUGE_TEMP:
valp->val1 = data->internal_temp / 256;
valp->val2 = data->internal_temp % 256 * 1000000 / 256;
break;
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
convert_millis(valp, data->full_cap);
break;
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
convert_millis(valp, data->remaining_cap);
break;
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
/* Get time in ms */
if (data->time_to_empty == 0xffff) {
valp->val1 = 0;
valp->val2 = 0;
} else {
tmp = data->time_to_empty * TIME_MULTIPLIER_MS;
convert_millis(valp, tmp);
}
break;
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
/* Get time in ms */
if (data->time_to_full == 0xffff) {
valp->val1 = 0;
valp->val2 = 0;
} else {
tmp = data->time_to_full * TIME_MULTIPLIER_MS;
convert_millis(valp, tmp);
}
break;
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
valp->val1 = data->cycle_count / 100;
valp->val2 = data->cycle_count % 100 * 10000;
break;
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
convert_millis(valp, data->design_cap);
break;
case SENSOR_CHAN_GAUGE_DESIGN_VOLTAGE:
convert_millis(valp, config->design_voltage);
break;
case SENSOR_CHAN_GAUGE_DESIRED_VOLTAGE:
convert_millis(valp, config->desired_voltage);
break;
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
valp->val1 = data->ichg_term;
valp->val2 = 0;
break;
case MAX17262_COULOMB_COUNTER:
/* Get spent capacity in mAh */
data->coulomb_counter = 0xffff - data->coulomb_counter;
valp->val1 = data->coulomb_counter / 2;
valp->val2 = data->coulomb_counter % 2 * 10 / 2;
break;
default:
LOG_ERR("Unsupported channel!");
return -ENOTSUP;
}
return 0;
}
/**
* @brief Read register values for supported channels
*
* @param dev MAX17262 device to access
* @return 0 if successful, or negative error code from I2C API
*/
static int max17262_sample_fetch(const struct device *dev,
enum sensor_channel chan)
{
struct max17262_data *data = dev->data;
struct {
int reg_addr;
int16_t *dest;
} regs[] = {
{ VCELL, &data->voltage },
{ AVG_CURRENT, &data->avg_current },
{ ICHG_TERM, &data->ichg_term },
{ REP_SOC, &data->state_of_charge },
{ INT_TEMP, &data->internal_temp },
{ REP_CAP, &data->remaining_cap },
{ FULL_CAP_REP, &data->full_cap },
{ TTE, &data->time_to_empty },
{ TTF, &data->time_to_full },
{ CYCLES, &data->cycle_count },
{ DESIGN_CAP, &data->design_cap },
{ COULOMB_COUNTER, &data->coulomb_counter },
};
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
for (size_t i = 0; i < ARRAY_SIZE(regs); i++) {
int rc;
rc = max17262_reg_read(dev, regs[i].reg_addr, regs[i].dest);
if (rc != 0) {
LOG_ERR("Failed to read channel %d", chan);
return rc;
}
}
return 0;
}
/**
* @brief Initialise the fuel gauge
*
* @param dev MAX17262 device to access
* @return 0 for success
* @return -EINVAL if the I2C controller could not be found
*/
static int max17262_gauge_init(const struct device *dev)
{
const struct max17262_config *const config = dev->config;
int16_t tmp, hibcfg;
if (!device_is_ready(config->i2c)) {
LOG_ERR("Could not get pointer to %s device", config->i2c->name);
return -EINVAL;
}
/* Read Status register */
max17262_reg_read(dev, STATUS, &tmp);
if (!(tmp & STATUS_POR)) {
/*
* Status.POR bit is set to 1 when MAX17262 detects that
* a software or hardware POR event has occurred and
* therefore a custom configuration needs to be set...
* If POR event did not happen (Status.POR == 0), skip
* init and continue with measurements.
*/
LOG_DBG("No POR event detected - skip device configuration");
return 0;
}
LOG_DBG("POR detected, setting custom device configuration...");
/** STEP 1 */
max17262_reg_read(dev, FSTAT, &tmp);
/* Do not continue until FSTAT.DNR bit is cleared */
while (tmp & FSTAT_DNR) {
k_sleep(K_MSEC(10));
max17262_reg_read(dev, FSTAT, &tmp);
}
/** STEP 2 */
/* Store original HibCFG value */
max17262_reg_read(dev, HIBCFG, &hibcfg);
/* Exit Hibernate Mode step 1 */
max17262_reg_write(dev, SOFT_WAKEUP, 0x0090);
/* Exit Hibernate Mode step 2 */
max17262_reg_write(dev, HIBCFG, 0x0000);
/* Exit Hibernate Mode step 3 */
max17262_reg_write(dev, SOFT_WAKEUP, 0x0000);
/** STEP 2.1 --> OPTION 1 EZ Config (No INI file is needed) */
/* Write DesignCap */
max17262_reg_write(dev, DESIGN_CAP, config->design_cap);
/* Write IChgTerm */
max17262_reg_write(dev, ICHG_TERM, config->desired_charging_current);
/* Write VEmpty */
max17262_reg_write(dev, VEMPTY, ((config->empty_voltage / 10) << 7) |
((config->recovery_voltage / 40) & 0x7F));
/* Write ModelCFG */
if (config->charge_voltage > 4275) {
max17262_reg_write(dev, MODELCFG, 0x8400);
} else {
max17262_reg_write(dev, MODELCFG, 0x8000);
}
/*
* Read ModelCFG.Refresh (highest bit),
* proceed to Step 3 when ModelCFG.Refresh == 0
*/
max17262_reg_read(dev, MODELCFG, &tmp);
/* Do not continue until ModelCFG.Refresh == 0 */
while (tmp & MODELCFG_REFRESH) {
k_sleep(K_MSEC(10));
max17262_reg_read(dev, MODELCFG, &tmp);
}
/* Restore Original HibCFG value */
max17262_reg_write(dev, HIBCFG, hibcfg);
/** STEP 3 */
/* Read Status register */
max17262_reg_read(dev, STATUS, &tmp);
/* Clear PowerOnReset bit */
tmp &= ~STATUS_POR;
max17262_reg_write(dev, STATUS, tmp);
return 0;
}
static const struct sensor_driver_api max17262_battery_driver_api = {
.sample_fetch = max17262_sample_fetch,
.channel_get = max17262_channel_get,
};
#define MAX17262_INIT(n) \
static struct max17262_data max17262_data_##n; \
\
static const struct max17262_config max17262_config_##n = { \
.i2c = DEVICE_DT_GET(DT_BUS(DT_DRV_INST(n))), \
.i2c_addr = DT_INST_REG_ADDR(n), \
.design_voltage = DT_INST_PROP(n, design_voltage), \
.desired_voltage = DT_INST_PROP(n, desired_voltage), \
.desired_charging_current = \
DT_INST_PROP(n, desired_charging_current), \
.design_cap = DT_INST_PROP(n, design_cap), \
.empty_voltage = DT_INST_PROP(n, empty_voltage), \
.recovery_voltage = DT_INST_PROP(n, recovery_voltage), \
.charge_voltage = DT_INST_PROP(n, charge_voltage), \
}; \
\
DEVICE_DT_INST_DEFINE(n, &max17262_gauge_init, \
device_pm_control_nop, \
&max17262_data_##n, \
&max17262_config_##n, POST_KERNEL, \
CONFIG_SENSOR_INIT_PRIORITY, \
&max17262_battery_driver_api);
DT_INST_FOREACH_STATUS_OKAY(MAX17262_INIT)

96
drivers/sensor/max17262/max17262.h Normal file
View file

@ -0,0 +1,96 @@
/*
* Copyright 2021 Matija Tudan
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_DRIVERS_SENSOR_BATTERY_MAX17262_H_
#define ZEPHYR_DRIVERS_SENSOR_BATTERY_MAX17262_H_
#define VOLTAGE_MULTIPLIER_UV 1250 / 16
#define CURRENT_MULTIPLIER_NA 156250
#define TIME_MULTIPLIER_MS 5625
/* Register addresses */
enum {
STATUS = 0x00,
REP_CAP = 0x05,
REP_SOC = 0x06,
INT_TEMP = 0x08,
VCELL = 0x09,
AVG_CURRENT = 0x0b,
FULL_CAP_REP = 0x10,
TTE = 0x11,
CYCLES = 0x17,
DESIGN_CAP = 0x18,
ICHG_TERM = 0x1E,
TTF = 0x20,
VEMPTY = 0x3A,
FSTAT = 0x3D,
COULOMB_COUNTER = 0x4D,
SOFT_WAKEUP = 0x60,
HIBCFG = 0xBA,
MODELCFG = 0xDB,
};
/* Masks */
enum {
FSTAT_DNR = 0x01,
STATUS_POR = 0x02,
MODELCFG_REFRESH = 0x8000,
};
/* MAX17262 specific channels */
enum max17262_channel {
MAX17262_COULOMB_COUNTER,
};
struct max17262_data {
/* Current cell voltage in units of 1.25/16mV */
uint16_t voltage;
/* Average current in units of 156.25uA */
int16_t avg_current;
/* Desired charging current in mA */
uint16_t ichg_term;
/* Remaining capacity as a %age */
uint16_t state_of_charge;
/* Internal temperature in units of 1/256 degrees C */
int16_t internal_temp;
/* Full charge capacity in mAh */
uint16_t full_cap;
/* Remaining capacity in mAh */
uint16_t remaining_cap;
/* Time to empty in seconds */
uint16_t time_to_empty;
/* Time to full in seconds */
uint16_t time_to_full;
/* Cycle count in 1/100ths (number of charge/discharge cycles) */
uint16_t cycle_count;
/* Battery capacity in mAh */
uint16_t design_cap;
/* Spent capacity in mAh */
uint16_t coulomb_counter;
};
struct max17262_config {
const struct device *i2c;
uint16_t i2c_addr;
/* Value of Rsense resistor in milliohms (typicallly 5 or 10) */
uint16_t rsense_mohms;
/* Design voltage of cell in mV */
uint16_t design_voltage;
/* Desired voltage of cell in mV */
uint16_t desired_voltage;
/* Desired charging current in mA */
uint16_t desired_charging_current;
/* Battery capacity in mAh */
uint16_t design_cap;
/* Empty voltage detection in mV */
uint16_t empty_voltage;
/* Recovery voltage detection in mV */
uint16_t recovery_voltage;
/* Defined charge voltage value in mV */
uint16_t charge_voltage;
};
#endif