Browse Source

Refactor driver to use Sensor API

xmkb
Nick 4 years ago
parent
commit
3082455aec
  1. 8
      app/boards/arm/bluemicro840/bluemicro840_v1.dts
  2. 1
      app/boards/arm/nice_nano/nice_nano.dts
  3. 8
      app/boards/arm/nrfmicro/nrfmicro_13.dts
  4. 179
      app/drivers/zephyr/battery_voltage_divider.c
  5. 5
      app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml

8
app/boards/arm/bluemicro840/bluemicro840_v1.dts

@ -29,6 +29,14 @@
}; };
}; };
vbatt {
compatible = "zmk,battery-voltage-divider";
label = "VOLTAGE_DIVIDER";
io-channels = <&adc 7>;
output-ohms = <2000000>;
full-ohms = <(2000000 + 806000)>;
};
}; };
&gpio0 { &gpio0 {

1
app/boards/arm/nice_nano/nice_nano.dts

@ -31,6 +31,7 @@
vbatt { vbatt {
compatible = "zmk,battery-voltage-divider"; compatible = "zmk,battery-voltage-divider";
label = "VOLTAGE_DIVIDER";
io-channels = <&adc 2>; io-channels = <&adc 2>;
output-ohms = <2000000>; output-ohms = <2000000>;
full-ohms = <(2000000 + 806000)>; full-ohms = <(2000000 + 806000)>;

8
app/boards/arm/nrfmicro/nrfmicro_13.dts

@ -26,6 +26,14 @@
}; };
}; };
vbatt {
compatible = "zmk,battery-voltage-divider";
label = "VOLTAGE_DIVIDER";
io-channels = <&adc 2>;
output-ohms = <2000000>;
full-ohms = <(2000000 + 820000)>;
};
}; };
&gpio0 { &gpio0 {

179
app/drivers/zephyr/battery_voltage_divider.c

@ -16,97 +16,190 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) struct io_channel_config {
const char *label;
uint8_t channel;
};
#define VBATT DT_PATH(vbatt) struct gpio_channel_config {
const char *label;
uint8_t pin;
uint8_t flags;
};
struct battery_config { struct bvd_config {
struct io_channel_config io_channel;
struct gpio_channel_config power_gpios;
uint32_t output_ohm;
uint32_t full_ohm;
};
struct bvd_data {
struct device *adc; struct device *adc;
struct device *gpio;
struct adc_channel_cfg acc; struct adc_channel_cfg acc;
struct adc_sequence as; struct adc_sequence as;
int16_t adc_raw; uint16_t adc_raw;
uint16_t voltage;
uint8_t state_of_charge;
}; };
static struct battery_config battery_config; static uint8_t lithium_ion_mv_to_pct(int16_t bat_mv) {
static int lithium_ion_mv_to_pct(int16_t bat_mv) {
// Magic function that maps mV to this discharge graph from adafruit: // Magic function that maps mV to this discharge graph from adafruit:
// https://learn.adafruit.com/li-ion-and-lipoly-batteries/voltages // https://learn.adafruit.com/li-ion-and-lipoly-batteries/voltages
return round(106.818 + return round(106.818 +
(-0.032685 - 106.818) / pow(1 + pow(bat_mv / 3679.35, 58.979), 0.347386)); (-0.032685 - 106.818) / pow(1 + pow(bat_mv / 3679.35, 58.979), 0.347386));
} }
static void battery_read(struct k_work *workd) { static int bvd_sample_fetch(struct device *dev, enum sensor_channel chan) {
struct battery_config *cfg = &battery_config; struct bvd_data *drv_data = dev->driver_data;
struct adc_sequence *as = &cfg->as; const struct bvd_config *drv_cfg = dev->config_info;
struct adc_sequence *as = &drv_data->as;
int rc = 0;
// Enable power GPIO if present
if (drv_data->gpio) {
rc = gpio_pin_set(drv_data->gpio, drv_cfg->power_gpios.pin, 1);
if (rc != 0) {
LOG_DBG("Failed to enable ADC power GPIO: %d", rc);
return rc;
}
}
int rc = adc_read(cfg->adc, as); // Read ADC
rc = adc_read(drv_data->adc, as);
as->calibrate = false; as->calibrate = false;
if (rc == 0) { if (rc == 0) {
int32_t val = cfg->adc_raw; int32_t val = drv_data->adc_raw;
adc_raw_to_millivolts(adc_ref_internal(cfg->adc), cfg->acc.gain, as->resolution, &val); adc_raw_to_millivolts(adc_ref_internal(drv_data->adc), drv_data->acc.gain, as->resolution, &val);
rc = val * (uint64_t)DT_PROP(VBATT, full_ohms) / DT_PROP(VBATT, output_ohms); uint16_t millivolts = val * (uint64_t)drv_cfg->full_ohm / drv_cfg->output_ohm;
LOG_DBG("ADC raw %d ~ %d mV => %d mV\n", cfg->adc_raw, val, rc); LOG_DBG("ADC raw %d ~ %d mV => %d mV\n", drv_data->adc_raw, val, millivolts);
int percent = lithium_ion_mv_to_pct(rc); uint8_t percent = lithium_ion_mv_to_pct(millivolts);
LOG_DBG("Percent: %d", percent); LOG_DBG("Percent: %d", percent);
drv_data->voltage = millivolts;
drv_data->state_of_charge = percent;
} else { } else {
LOG_DBG("Failed to read ADC: %d", rc); LOG_DBG("Failed to read ADC: %d", rc);
} }
// Disable power GPIO if present
if (drv_data->gpio) {
rc = gpio_pin_set(drv_data->gpio, drv_cfg->power_gpios.pin, 0);
if (rc != 0) {
LOG_DBG("Failed to disable ADC power GPIO: %d", rc);
}
}
return rc;
} }
K_WORK_DEFINE(battery_work, battery_read); static int bvd_channel_get(struct device *dev, enum sensor_channel chan,
struct sensor_value *val) {
struct bvd_data *drv_data = dev->driver_data;
static void battery_handler(struct k_timer *timer) { k_work_submit(&battery_work); } switch(chan) {
case SENSOR_CHAN_GAUGE_VOLTAGE:
val->val1 = drv_data->voltage / 1000;
val->val2 = (drv_data->voltage % 1000) * 1000U;
break;
K_TIMER_DEFINE(battery_tick, battery_handler, NULL); case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
val->val1 = drv_data->state_of_charge;
val->val2 = 0;
break;
static int battery_setup(struct device *_arg) { default:
struct battery_config *cfg = &battery_config; return -ENOTSUP;
struct adc_sequence *as = &cfg->as; }
struct adc_channel_cfg *acc = &cfg->acc;
cfg->adc = device_get_binding(DT_IO_CHANNELS_LABEL(VBATT)); return 0;
}
static const struct sensor_driver_api bvd_api = {
.sample_fetch = bvd_sample_fetch,
.channel_get = bvd_channel_get,
};
static int bvd_init(struct device *dev) {
struct bvd_data *drv_data = dev->driver_data;
const struct bvd_config *drv_cfg = dev->config_info;
drv_data->adc = device_get_binding(drv_cfg->io_channel.label);
if (drv_data->adc == NULL) {
LOG_ERR("ADC %s failed to retrieve", drv_cfg->io_channel.label);
return -ENOENT;
}
if (cfg->adc == NULL) { int rc = 0;
LOG_ERR("ADC %s failed to retrieve", DT_IO_CHANNELS_LABEL(VBATT));
if (drv_cfg->power_gpios.label) {
drv_data->gpio = device_get_binding(drv_cfg->power_gpios.label);
if (drv_data->gpio == NULL) {
LOG_ERR("Failed to get GPIO %s", drv_cfg->power_gpios.label);
return -ENOENT; return -ENOENT;
} }
rc = gpio_pin_configure(drv_data->gpio, drv_cfg->power_gpios.pin,
GPIO_OUTPUT_INACTIVE | drv_cfg->power_gpios.flags);
if (rc != 0) {
LOG_ERR("Failed to control feed %s.%u: %d",
drv_cfg->power_gpios.label, drv_cfg->power_gpios.pin, rc);
return rc;
}
}
*as = (struct adc_sequence){ drv_data->as = (struct adc_sequence){
.channels = BIT(0), .channels = BIT(0),
.buffer = &cfg->adc_raw, .buffer = &drv_data->adc_raw,
.buffer_size = sizeof(cfg->adc_raw), .buffer_size = sizeof(drv_data->adc_raw),
.oversampling = 4, .oversampling = 4,
.calibrate = true, .calibrate = true,
}; };
#ifdef CONFIG_ADC_NRFX_SAADC #ifdef CONFIG_ADC_NRFX_SAADC
*acc = (struct adc_channel_cfg){ drv_data->acc = (struct adc_channel_cfg){
.gain = ADC_GAIN_1_5, .gain = ADC_GAIN_1_5,
.reference = ADC_REF_INTERNAL, .reference = ADC_REF_INTERNAL,
.acquisition_time = ADC_ACQ_TIME(ADC_ACQ_TIME_MICROSECONDS, 40), .acquisition_time = ADC_ACQ_TIME(ADC_ACQ_TIME_MICROSECONDS, 40),
.input_positive = SAADC_CH_PSELP_PSELP_AnalogInput0 + DT_IO_CHANNELS_INPUT(VBATT), .input_positive = SAADC_CH_PSELP_PSELP_AnalogInput0 + drv_cfg->io_channel.channel,
}; };
as->resolution = 12; drv_data->as.resolution = 12;
#else #else
#error Unsupported ADC #error Unsupported ADC
#endif #endif
int adc_rc = adc_channel_setup(cfg->adc, acc); rc = adc_channel_setup(drv_data->adc, &drv_data->acc);
LOG_DBG("AIN%u setup returned %d", DT_IO_CHANNELS_INPUT(VBATT), adc_rc); LOG_DBG("AIN%u setup returned %d", drv_cfg->io_channel.channel, rc);
if (adc_rc != 0) {
return adc_rc;
}
k_timer_start(&battery_tick, K_NO_WAIT, K_SECONDS(5)); return rc;
return 0;
} }
SYS_INIT(battery_setup, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY); static struct bvd_data bvd_data;
static const struct bvd_config bvd_cfg = {
.io_channel = {
DT_INST_IO_CHANNELS_LABEL(0),
DT_INST_IO_CHANNELS_INPUT(0),
},
#if DT_INST_NODE_HAS_PROP(0, power_gpios)
.power_gpios = {
DT_INST_GPIO_LABEL(0, power_gpios),
DT_INST_PIN(0, power_gpios),
DT_INST_FLAGS(0, power_gpios),
},
#endif
.output_ohm = DT_INST_PROP(0, output_ohms),
.full_ohm = DT_INST_PROP(0, full_ohms),
};
#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */ DEVICE_AND_API_INIT(bvd_dev, DT_INST_LABEL(0), &bvd_init,
&bvd_data, &bvd_cfg, POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY,
&bvd_api);

5
app/drivers/zephyr/dts/bindings/zmk,battery-voltage-divider.yaml

@ -7,3 +7,8 @@ compatible: "zmk,battery-voltage-divider"
include: voltage-divider.yaml include: voltage-divider.yaml
properties:
label:
required: true
type: string
Loading…
Cancel
Save