hueso/Sensor-Watch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

port ADC functions to gossamer

Browse Source
This commit is contained in:
joeycastillo
2024-09-18 16:10:12 -04:00
parent 9e32cbc523
commit 6706452353
5 changed files with 51 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
watch-library/hardware/watch/watch_adc.c
View File

@@ -23,152 +23,45 @@
*/
#include "watch_adc.h"
#include "driver_init.h"
static void _watch_sync_adc(void) {
while (ADC->SYNCBUSY.reg);
}
static uint16_t _watch_get_analog_value(uint16_t channel) {
if (ADC->INPUTCTRL.bit.MUXPOS != channel) {
ADC->INPUTCTRL.bit.MUXPOS = channel;
_watch_sync_adc();
}
ADC->SWTRIG.bit.START = 1;
while (!ADC->INTFLAG.bit.RESRDY); // wait for "result ready" flag
return ADC->RESULT.reg;
}
#include "adc.h"
void watch_enable_adc(void) {
MCLK->APBCMASK.reg |= MCLK_APBCMASK_ADC;
GCLK->PCHCTRL[ADC_GCLK_ID].reg = GCLK_PCHCTRL_GEN_GCLK0 | GCLK_PCHCTRL_CHEN;
adc_init();
adc_enable();
}
uint16_t calib_reg = 0;
calib_reg = ADC_CALIB_BIASREFBUF((*(uint32_t *)ADC_FUSES_BIASREFBUF_ADDR >> ADC_FUSES_BIASREFBUF_Pos)) |
ADC_CALIB_BIASCOMP((*(uint32_t *)ADC_FUSES_BIASCOMP_ADDR >> ADC_FUSES_BIASCOMP_Pos));
void watch_enable_analog_input(const uint16_t port_pin) {
uint8_t port = port_pin >> 8;
uint16_t pin = port_pin & 0xF;
if (!ADC->SYNCBUSY.bit.SWRST) {
if (ADC->CTRLA.bit.ENABLE) {
ADC->CTRLA.bit.ENABLE = 0;
_watch_sync_adc();
}
ADC->CTRLA.bit.SWRST = 1;
}
_watch_sync_adc();
if (USB->DEVICE.CTRLA.bit.ENABLE) {
// if USB is enabled, we are running an 8 MHz clock.
// divide by 16 for a 500kHz ADC clock.
ADC->CTRLB.bit.PRESCALER = ADC_CTRLB_PRESCALER_DIV16_Val;
PORT->Group[port].DIRCLR.reg = (1 << pin);
PORT->Group[port].PINCFG[pin].reg |= PORT_PINCFG_INEN;
PORT->Group[port].PINCFG[pin].reg &= ~PORT_PINCFG_PULLEN;
PORT->Group[port].PINCFG[pin].reg |= PORT_PINCFG_PMUXEN;
if (pin & 1) {
PORT->Group[port].PMUX[pin>>1].bit.PMUXO = HAL_GPIO_PMUX_ADC;
} else {
// otherwise it's 4 Mhz. divide by 8 for a 500kHz ADC clock.
ADC->CTRLB.bit.PRESCALER = ADC_CTRLB_PRESCALER_DIV8_Val;
}
ADC->CALIB.reg = calib_reg;
ADC->REFCTRL.bit.REFSEL = ADC_REFCTRL_REFSEL_INTVCC2_Val;
ADC->INPUTCTRL.bit.MUXNEG = ADC_INPUTCTRL_MUXNEG_GND_Val;
ADC->CTRLC.bit.RESSEL = ADC_CTRLC_RESSEL_16BIT_Val;
ADC->AVGCTRL.bit.SAMPLENUM = ADC_AVGCTRL_SAMPLENUM_16_Val;
ADC->SAMPCTRL.bit.SAMPLEN = 0;
ADC->INTENSET.reg = ADC_INTENSET_RESRDY;
ADC->CTRLA.bit.ENABLE = 1;
_watch_sync_adc();
// throw away one measurement after reference change (the channel doesn't matter).
_watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_SCALEDCOREVCC);
}
void watch_enable_analog_input(const uint8_t pin) {
gpio_set_pin_direction(pin, GPIO_DIRECTION_OFF);
switch (pin) {
case A0:
gpio_set_pin_function(pin, PINMUX_PB04B_ADC_AIN12);
break;
case A1:
gpio_set_pin_function(pin, PINMUX_PB01B_ADC_AIN9);
break;
case A2:
gpio_set_pin_function(pin, PINMUX_PB02B_ADC_AIN10);
break;
case A3:
gpio_set_pin_function(pin, PINMUX_PB03B_ADC_AIN11);
break;
case A4:
gpio_set_pin_function(pin, PINMUX_PB00B_ADC_AIN8);
break;
default:
return;
PORT->Group[port].PMUX[pin>>1].bit.PMUXE = HAL_GPIO_PMUX_ADC;
}
}
uint16_t watch_get_analog_pin_level(const uint8_t pin) {
switch (pin) {
case A0:
return _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_AIN12_Val);
case A1:
return _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_AIN9_Val);
case A2:
return _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_AIN10_Val);
case A3:
return _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_AIN11_Val);
case A4:
return _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_AIN8_Val);
default:
return 0;
}
uint16_t watch_get_analog_pin_level(const uint16_t pin) {
return adc_get_analog_value(pin);
}
void watch_set_analog_num_samples(uint16_t samples) {
// ignore any input that's not a power of 2 (i.e. only one bit set)
if (__builtin_popcount(samples) != 1) return;
// if only one bit is set, counting the trailing zeroes is equivalent to log2(samples)
uint8_t sample_val = __builtin_ctz(samples);
// make sure the desired value is within range and set it, if so.
if (sample_val <= ADC_AVGCTRL_SAMPLENUM_1024_Val) {
ADC->AVGCTRL.bit.SAMPLENUM = sample_val;
_watch_sync_adc();
}
}
void watch_set_analog_sampling_length(uint8_t cycles) {
// for clarity the API asks the user how many cycles they want the measurement to take.
// but the ADC always needs at least one cycle; it just wants to know how many *extra* cycles we want.
// so we subtract one from the user-provided value, and clamp to the maximum.
ADC->SAMPCTRL.bit.SAMPLEN = (cycles - 1) & 0x3F;
_watch_sync_adc();
}
static inline uint32_t _watch_adc_get_reference_voltage(const watch_adc_reference_voltage reference) {
switch (reference) {
case ADC_REFERENCE_INTREF:
return ADC_REFCTRL_REFSEL_INTREF_Val;
break;
case ADC_REFERENCE_VCC_DIV1POINT6:
return ADC_REFCTRL_REFSEL_INTVCC0_Val;
break;
case ADC_REFERENCE_VCC_DIV2:
return ADC_REFCTRL_REFSEL_INTVCC1_Val;
break;
case ADC_REFERENCE_VCC:
return ADC_REFCTRL_REFSEL_INTVCC2_Val;
break;
}
return 0;
}
void watch_set_analog_reference_voltage(watch_adc_reference_voltage reference) {
/// TODO: put reference voltage stuff into gossamer?
void _watch_set_analog_reference_voltage(uint8_t reference);
void _watch_set_analog_reference_voltage(uint8_t reference) {
ADC->CTRLA.bit.ENABLE = 0;
if (reference == ADC_REFERENCE_INTREF) SUPC->VREF.bit.VREFOE = 1;
if (reference == ADC_REFCTRL_REFSEL_INTREF_Val) SUPC->VREF.bit.VREFOE = 1;
else SUPC->VREF.bit.VREFOE = 0;
ADC->REFCTRL.bit.REFSEL = _watch_adc_get_reference_voltage(reference);
ADC->REFCTRL.bit.REFSEL = reference;
ADC->CTRLA.bit.ENABLE = 1;
_watch_sync_adc();
while (ADC->SYNCBUSY.reg);
// throw away one measurement after reference change (the channel doesn't matter).
_watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_SCALEDCOREVCC);
adc_get_analog_value_for_channel(ADC_INPUTCTRL_MUXPOS_SCALEDCOREVCC);
}
uint16_t watch_get_vcc_voltage(void) {
@@ -176,24 +69,26 @@ uint16_t watch_get_vcc_voltage(void) {
uint8_t oldref = ADC->REFCTRL.bit.REFSEL;
// if we weren't already using the internal reference voltage, select it now.
if (oldref != ADC_REFERENCE_INTREF) watch_set_analog_reference_voltage(ADC_REFERENCE_INTREF);
if (oldref != ADC_REFCTRL_REFSEL_INTREF_Val) _watch_set_analog_reference_voltage(ADC_REFCTRL_REFSEL_INTREF_Val);
// get the data
uint32_t raw_val = _watch_get_analog_value(ADC_INPUTCTRL_MUXPOS_SCALEDIOVCC_Val);
uint32_t raw_val = adc_get_analog_value_for_channel(ADC_INPUTCTRL_MUXPOS_SCALEDIOVCC_Val);
// restore the old reference, if needed.
if (oldref != ADC_REFERENCE_INTREF) watch_set_analog_reference_voltage(oldref);
if (oldref != ADC_REFCTRL_REFSEL_INTREF_Val) _watch_set_analog_reference_voltage(oldref);
return (uint16_t)((raw_val * 1000) / (1024 * 1 << ADC->AVGCTRL.bit.SAMPLENUM));
}
inline void watch_disable_analog_input(const uint8_t pin) {
gpio_set_pin_function(pin, GPIO_PIN_FUNCTION_OFF);
inline void watch_disable_analog_input(const uint16_t port_pin) {
uint8_t port = port_pin >> 8;
uint16_t pin = port_pin & 0xF;
PORT->Group[port].DIRSET.reg = (1 << pin); \
PORT->Group[port].PINCFG[pin].reg &= ~(PORT_PINCFG_PULLEN | PORT_PINCFG_INEN); \
PORT->Group[port].PINCFG[pin].reg &= ~PORT_PINCFG_PMUXEN; \
}
inline void watch_disable_adc(void) {
ADC->CTRLA.bit.ENABLE = 0;
_watch_sync_adc();
MCLK->APBCMASK.reg &= ~MCLK_APBCMASK_ADC;
adc_disable();
}