Software Enhancements Ready for Merge - Taken From v1.53m

Hello,

I'm an embedded developer in Calgary, Alberta, Canada. I found your project after buying an 2578AY-AT with ST7735 color kit and assembling it. I enjoyed working in your code base. My work is entirely non-commercial.

I would like to offer what I think are some significant improvements based upon the V1.53m base. My only condition is keeping the Copyright on the new files that I created intact (and I agree with the License agreement).

Primary enhancements:
(1) New module stateADCvectISR.c and modified ADC.c to support continuous sampling (13.5 ADC clocks/2 ADC S/H period)
(a) By default, supports Interrupts on ADC, however, also supports "spin-wait" for timing-critical code (such as SmallResistor())
(b) Adds ADC_INLINE_DELAY() and ADC_INLINE_DELAYus() to support ADC-based timing in addition to wait()
(c) Utilizes SLEEP_MODE_ADC during conversions for ADC noise reduction and power saving.
(2) Uses less power with combination of SLEEP_MODE_ADC plus disabling power to TIMERS when not in use.
(3) Used "inline" subroutines in cap.c to make code easier to read and analyze (refactored existing code).
(4) Created reusable subroutine from existing SmallCap(), RefCap(), MeasureInductor()
(a) StartTimer1AnalogComparison() performs the TIMER1 operation (refactored existing code)
(5) Improvements to External Reference operation:
(a) Firmware embeds the ASCII version of reference values in flash for fine-tuning without recompile (just use intel .hex editor)
(b) A new option allows the External Reference to be used in place of INTERNAL BANDGAP
(c) External Reference allows extended range i.e. 1245 mVolt to 2900 mVolt (e.g. I use lm4041c12)
(6) New support routines added for code clarity dealing with ADC_DDR/_PORT, R_DDR, R_PORT operations.
(7) Improved implementation of MilliSleep() - better code handling of timing calculations.

I am just finishing testing and debugging. If you would like, I can send the changes to you to review. If you decide, I can leave the code to you to commit or I can be added as a contributor; you can decide.

I look forward to hearing what you think and if/how you would like to proceed.

Ken

Hi Ken!

Any contribution is welcome! Please email me your improvements (for address see README) and I'll check it out (might take a while since I'm quite busy at the moment).

Cheers,
Markus

Hi Markus: Thank you for your invite earlier. I have been hard at work finalizing the code with bug fixes and also verifying that things still work under various config settings. I have attached my changes in two files: - the source code to build the proposed version 1.54m - the difference in source code from where I started 1.53m There are several changes and improvements. I plan to compile a spreadsheet with the detailed changelog later. I know you are busy, however, I wanted to get the code to you asap so that you had a change for initial impressions and maybe a chance to compile and try the changes yourself. The first thing that you will notice is the new support for pre-compiled headers and parallel make. For example, if you have 12 cores on your linux machine, you can "make -j 12" and you will find the compilation very fast. Overall, I am happy with my results and I am glad that you gave me this opportunity to contribute to open source. I look forward to your comments and an eventual release 1.54m when you have the time. If there is anything you need/desire from me, please let me know. Ken Sent with [Proton Mail](https://proton.me/mail/home) secure email.

On Wednesday, October 30th, 2024 at 10:54 AM, madires ***@***.***> wrote: Hi Ken! Any contribution is welcome! Please email me your improvements (for address see README) and I'll check it out (might take a while since I'm quite busy at the moment). Cheers, Markus — Reply to this email directly, [view it on GitHub](#11 (comment)), or [unsubscribe](https://github.com/notifications/unsubscribe-auth/BMRCKUCHA2PFRXOUOQPGNWLZ6EFM7AVCNFSM6AAAAABQ3LVJYSVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZDINBXHAYDCMZRGE). You are receiving this because you authored the thread.Message ID: ***@***.***>

diff -Naur ComponentTester-1.53m/ADC.c ComponentTester-1.54m/ADC.c --- ComponentTester-1.53m/ADC.c 2024-11-08 16:51:05.000000000 -0700 +++ ComponentTester-1.54m/ADC.c 2024-11-08 09:41:51.384579140 -0700 @@ -2,7 +2,7 @@ * * ADC functions * - * (c) 2012-2023 by Markus Reschke + * (c) 2012-2024 by Markus Reschke * based on code from Markus Frejek and Karl-Heinz Kübbeler * * ************************************************************************ */ @@ -12,171 +12,633 @@ * local constants */ -/* source management */ -#define ADC_C - - /* * include header files */ /* local includes */ -#include "config.h" /* global configuration */ -#include "common.h" /* common header file */ -#include "variables.h" /* global variables */ -#include "functions.h" /* external functions */ +#include "projectHeaders.h" +/* source management */ +#define ADC_C -/* ************************************************************************ - * ADC - * ************************************************************************ */ - +/* Define the required in-line functions... */ +#define SCALECHANGE32U16U -/* - * read ADC channel and return voltage in mV - * - use Vcc as reference by default - * - switch to bandgap reference for low voltages (< 1.0V) to improve - * ADC resolution - * - with a 125kHz ADC clock a single conversion needs about 0.1ms - * with 25 samples we end up with about 2.6ms - * - * requires: - * - Channel: ADC MUX input channel - * - ATmega328: register bits corresponding with MUX0-3 - * - ATmega324/644/1284: register bits corresponding with MUX0-4 - * - ATmega640/1280/2560: register bits corresponding with MUX0-4 - * (todo: add MUX5 to support also ADC8-15) - */ +#include "projectInlines.h"

…

-uint16_t ReadU(uint8_t Channel) +#if !defined(ADC_READU_LVL) +#error "Compiler option missing (ADC_READU_LVL); check config_<MPU>.h" +#endif + +#if defined(HW_REF25) +#error "Old HW_REF code no longer supported - please change config.h to use HW_EXTREF" +#endif + +/************************************************************************* +** +** Local definitions. +*/ + +/************************************************************************* +** +** Local types. +*/ + +/************************************************************************* +** Local variables. +***************************************************************************/ +#define MY_APPEND_STR(MYUREF) #MYUREF +#define MY_APPEND(MYSTR) MY_APPEND_STR(MYSTR) +/**************************************************************************** +** Note: The values of the ADC References are stored in flash so that +** they can be customized without recompiling the image. +*/ +#if defined(HW_EXTREF) +const uint8_t ADCextReference[] PROGMEM = { +/* 0123456789012345 */ + "ADCextRef: " + MY_APPEND(UEXTREF) +}; +#endif +const uint8_t ADCvccReference[] PROGMEM = { +/* 0123456789012345 */ + "ADCvccRef: " MY_APPEND(UREF_VCC) +}; +static uint8_t ADCRef = ADC_REF_INVALID; /* last used ref. */ + +/* The non-ADC Interrupt code using RefInfo is in this file. */ +#if (ADC_READU_LVL == 0) +/* Define the reference over-range limits - any value higher is over-range. */ +static ADCScale_Type RefInfo = { + (((uint32_t)(UREF_11 - 1) * (AUTOPRESAMPLES * 1024UL) + (UREF_VCC)/2) / UREF_VCC)/* Internal reference Over-range. */ +#if defined(HW_ADCREF_EXTREF) + , (((uint32_t)(UEXTREF - 1) * (AUTOPRESAMPLES * 1024UL) + (UREF_VCC)/2) / UREF_VCC)/* External reference Over-range. */ +#endif +}; +#endif + +#if defined(HW_ADCREF_EXTREF) +/* Actual measurements of the External Reference made at startup. +** Note: initialized to zero to indicate that a measurement is required. +*/ +static uint16_t ADCExtRef = 0; +#endif +/* END: defined(HW_ADCREF_EXTREF) */ + +/************************************************************************** +** ADC +***************************************************************************/ + +/**************************************************************************** +** +** ChangeADCRefLocal() +** - Helper function to keep track when pauses are required because of +** changes to ADC Reference and/or ADC Enable (ADEN). +** +** Allow time for settling after changing the ADC reference source. +** +** Written such that interrupt-driven ADC conversions or spin-wait +** conversions are both allowed afterward. +** - To use interrupts: Call ReadU() and/or ADC_INLINE_DELAY(). +** - To use spin-wait: Call ADC_FORCE_INTERRUPTS_OFF() and then +** use ReadUSingleSample() exclusively. +** +** Notes & Restrictions: +** The selected reference range can be determined from the following +** Cfg.ADCref: the reference range in mV. +** Interrupts are expected to be disabled before calling this helper. +** The datasheet suggests a settling time delay for either change +** of ADC Enable or MUX reference. +** Do not attempt to change ADMUX outside this module as it would +** circumvent the desired functionality. +*/ +static void ChangeADCRefLocal( + uint8_t Channel +#if (ADC_READU_LVL == 1) + , uint16_t MyADCclock +#endif + ) { - uint16_t U; /* return value (mV) */ - uint8_t Counter; /* loop counter */ - uint8_t Ref; /* voltage reference register bits */ - uint32_t Value; /* ADC value */ +uint8_t TempByte; +uint8_t SRA_NormalMode; +uint8_t MySRA; +uint8_t MyRef; + + MyRef = Channel & ADC_REF_MASK; /* Get reference bits */ + + /* Over-ride the ADC_REF_BANDGAP reference if a better + ** reference is available. + */ +#if defined(HW_ADCREF_EXTREF) + if ( (Cfg.OP_Mode & (OP_EXT_REF)) ) /* Valid reference */ + { + if ( (MyRef == ADC_REF_BANDGAP) ) + { + Channel &= ~(ADC_REF_MASK);/* Clear Reference bits */ + MyRef = ADC_REF_EXTERNAL; + } + /* ...else DEFAULT: Channel |= ADC_REF_EXTERNAL; select external reference */ + } +#endif - /* AREF pin is connected to external buffer cap (1nF) */ + /* Set the ADC multiplexer and separate out the Reference source. */ + ADMUX = Channel; /* set input channel and U reference */ - #if 0 - /* manage channels ADC8-15 (ATmega640/1280/2560) */ - if (Channel & 0b00100000) /* bit 6 set: ADC8-15 */ - { - ADCSRB |= (1 << MUX5); /* set MUX5 */ - } - else /* bit 6 not set: ADC0-7 */ - { - ADCSRB &= ~(1 << MUX5); /* clear MUX5 */ - } - #endif + MySRA = ADCSRA; - /* prepare bitfield for register: start with AVcc as voltage reference */ - Channel &= ADC_CHAN_MASK; /* filter reg bits for MUX channel */ - Channel |= ADC_REF_VCC; /* add bits for voltage reference: AVcc */ - -sample: - - ADMUX = Channel; /* set input channel and U reference */ - - /* - * change of voltage reference - * - voltage needs some time to stabilize at buffer cap - * - run a dummy conversion after change (recommended by datasheet) - * - It seems that we have to run a dummy conversion also after the - * ADC hasn't run for a while. So let's do one anyway. - */ - - Ref = Channel & ADC_REF_MASK; /* get register bits for voltage reference */ - if (Ref != Cfg.Ref) /* reference source has changed */ - { - /* wait some time for voltage stabilization */ - #ifndef ADC_LARGE_BUFFER_CAP - /* buffer cap: 1nF or none at all */ - wait100us(); /* 100µs */ - #else - /* buffer cap: 100nF */ - wait10ms(); /* 10ms */ - #endif +#if defined(SAVE_POWER) + TempByte = Cfg.SleepMode; /* Get current mode */ +#endif - #if 0 - /* dummy conversion */ - ADCSRA |= (1 << ADSC); /* start conversion */ - while (ADCSRA & (1 << ADSC)); /* wait until conversion is done */ - #endif + if ( (MySRA & (1 << ADEN)) && (ADCRef == MyRef) ) + { + return; /* No change to neither Reference nor ADEN */ + } + + /************************************************************************/ + + /* ...else either the reference source or the enable has changed */ + +#if (ADC_READU_LVL == 1) + /* ADC continuous operation. */ + if ( /* Check to see if interrupts are enabled by user */ +#if defined(SAVE_POWER) + (TempByte == SLEEP_MODE_ADC) /* ADC Conversions already ON. */ +#endif + && (MySRA & (1 << ADEN)) + ) + { + sei(); /* Enable interrupts For the delay */ + /* wait some time for voltage stabilization */ +#if defined(ADC_LARGE_BUFFER_CAP) + /* buffer cap: 100nF */ + ADCautoscanDelay(MyADCclock, CONVERT_USEC_TO_ADC_TICKS(10000));/* 10ms */ +#else + /* buffer cap: 1nF or none at all */ + ADCautoscanDelay(MyADCclock, CONVERT_USEC_TO_ADC_TICKS(100));/* 100µs */ +#endif + } +#endif - Cfg.Ref = Ref; /* update reference source */ - } + /* Perform ADC ENable initiation for basic (no interrupt) operation. */ + if ( !(MySRA & (1 << ADEN)) ) + { + /* Force the ADC enabled to allow ADC system to stabilize. + ** - do *NOT* *ENable* interrupts yet. + */ + /* No interrupt mode required for BASIC OPERATION. */ + SRA_NormalMode= (1 << ADEN) | (1 << ADIF) | ADC_CLOCK_DIV; + ADCSRA = SRA_NormalMode; /* Enable basic ADC mode*/ + + /* Force SleepMode into SLEEP_MODE_IDLE to indicate that + ** ADC interrupts are off. + */ +#if defined(SAVE_POWER) + if ( (TempByte == SLEEP_MODE_ADC) ) + { +#endif + TempByte = SLEEP_MODE_IDLE;/* Mark ADC mode complete. */ + set_sleep_mode(TempByte); +#if defined(SAVE_POWER) + } + Cfg.SleepMode = SLEEP_MODE_IDLE;/* Mark ADC mode complete. */ +#endif - /* perform dummy conversion anyway */ - ADCSRA |= (1 << ADSC); /* start conversion */ - while (ADCSRA & (1 << ADSC)); /* wait until conversion is done */ +#if (ADC_READU_LVL == 1) + sei(); /* Enable interrupts For the delay */ +#endif + /* wait some time for voltage stabilization */ +#if defined(ADC_LARGE_BUFFER_CAP) + /* buffer cap: 100nF */ + wait10ms(); /* 10ms */ +#else + /* buffer cap: 1nF or none at all */ + wait100us(); /* 100µs */ +#endif + } +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts again after the delay */ +#endif - /* - * sample ADC readings - */ + wdt_reset(); /* reset watchdog */ - Value = 0UL; /* reset sampling variable */ - Counter = 0; /* reset counter */ + ADCRef = MyRef; /* update reference source */ - while (Counter < Cfg.Samples) /* take samples */ - { - ADCSRA |= (1 << ADSC); /* start conversion */ - while (ADCSRA & (1 << ADSC)); /* wait until conversion is done */ + /* The selected ADC reference */ + switch (MyRef) + { + case ADC_REF_BANDGAP: + Cfg.ADCref = Cfg.Bandgap; /* Use the backup reference */ + break; +#if defined(HW_ADCREF_EXTREF) + case ADC_REF_EXTERNAL: + Cfg.ADCref = ADCExtRef; + break; +#endif + case ADC_REF_VCC: + default: + Cfg.ADCref = Cfg.Vcc; /* Default: convert to voltage; Vcc as reference */ + break; + } - Value += ADCW; /* add ADC reading */ + return; +} /* END: ChangeADCRefLocal() */ - /* auto-switch voltage reference for low readings */ - if (Counter == 4) /* 5 samples */ +#if (ADC_READU_LVL == 1) +/**************************************************************************** +** +** Function: ReadULocal() +** Refer to ReadU() for the external interface description. +** +** The ReadULocal() function does the work with interrupt entry-exit +** handled previously. +** +** Notes and Restrictions: +** - The calling routine is expected to disable interrupts. +** - The calling routine is expected to add Reference part of Channel. +** - sleep_mode(ADC) turns off Timer oscillators - beware! +*/ +static uint16_t ReadULocal( + uint8_t Channel, + uint8_t StatusReg) /* The original StatusRegister */ +{ +ADCvectData_Type MyISR_DATA; /* Local copy */ +uint16_t MyADCclock; /* Copy of clock. */ +#if defined(SAVE_POWER) +uint8_t Test; /* Test of SleepMode */ +#endif +uint8_t Samples; /* */ +uint8_t MySR; /* */ +ADC_vectFunction MyVectFnc; +uint32_t Rounder; /* Rounding value. */ +uint32_t SumValue; /* ADC value */ + + /* Force sleep mode to engage ADC Noise Reduction during sleep. */ +#if defined(SAVE_POWER) + Test = Cfg.SleepMode;/* Get current mode */ + Cfg.SleepMode = SLEEP_MODE_ADC;/* change to ADC Noise Reduction */ +#endif + + /* Start initializing all MPU registers + ** - Note interrupts are already disabled. + */ + + /* Let the interrupt routine know how many total samples to get. */ + ADC_ISR_SetRequestedSamples(Cfg.Samples); + + /* Force the Analog Comparator to Disabled so the ADC can use the MUX. */ + ACSR = (1 << ACD) | (1 << ACBG) | (1 << ACI);/* Disable AC */ + + /* Free-run mode requires triggering from the ADC complete flag. + ** Note DONT change ADC multiplexer as negative input MODE: (1 << ACME) */ + MySR = ADCSRB; /* Read */ + MySR &= ~((1 << ADTS2) | (1 << ADTS1) | (1 << ADTS0));/* Auto-trigger from ADC complete flag */ + ADCSRB = MySR; /* Write */ + + /* Enable Free-run mode but do not start ADC yet. + ** Ensure that the ADC conversion interrupts are enabled. + */ + MySR = (1 << ADEN) | (1 << ADATE) | (1 << ADIF) | (1 << ADIE) | ADC_CLOCK_DIV; + ADCSRA = MySR; /* Write */ + + ADC_ISR_GetState(&MyISR_DATA); + + /* Choose next state: do the full sample in case AutoScale is turned off. */ + MyVectFnc = ADCvectDiscardFirstSampleAutoScale;/* Default: Startup state */ + if ( !(Cfg.AutoScale) || (ADCRef != ADC_REF_VCC) ) { - if ((uint16_t)Value < 1024) /* < 1V (5V / 5 samples) */ - { - if (Ref != ADC_REF_BANDGAP) /* bandgap ref not selected */ - { - if (Cfg.AutoScale == 1) /* autoscaling enabled */ - { - Channel &= ~ADC_REF_MASK; /* clear reference bits */ - Channel |= ADC_REF_BANDGAP; /* select bandgap reference */ + MyVectFnc = ADCvectDiscardFirstSampleFull;/* Update autoscaling disabled */ + if ( (Cfg.Samples == 1) ) + MyVectFnc = ADCvectProcessAllSample; /* Process only one sample */ + } - goto sample; /* re-run sampling */ - } - } - } + /* Note: Interrupts are still disabled. */ + ADC_ISR_ChangeState(MyVectFnc); + + /* We are now free to start the Full sample when ISR returns... */ + MyVectFnc = ADCvectDiscardFirstSampleFull;/* autoscaling was completed. */ + +#if defined(SAVE_POWER) + /* Startup the ADC converter + ** - once started, the auto triggering will keep the ADC running. + */ + if ( (Test != SLEEP_MODE_ADC) ) + { +#endif + sei(); /* Ensure Re-enable interrupts */ + set_sleep_mode(SLEEP_MODE_ADC);/* START ADC conversion by set SMCR register: ADC Noise Reduction */ + cli(); /* Ensure Disable interrupts */ +#if defined(SAVE_POWER) } +#endif - Counter++; /* another sample done */ - } + /* Note: Interrupts are still disabled. */ + /* Loop to transition through the ISR processing states and re-enter + ** sleep mode if woken up too early. + */ + do + { + sleep_enable(); + sei(); /* Re-enable interrupts */ - /* - * convert ADC reading to voltage - * - single sample: U = ADC reading * U_ref / 1024 - */ - - /* get voltage of reference used */ - if (Ref == ADC_REF_BANDGAP) /* bandgap reference */ - { - U = Cfg.Bandgap; /* voltage of bandgap reference */ - } - else /* Vcc as reference */ - { - U = Cfg.Vcc; /* voltage of Vcc */ - } - - /* convert to voltage; */ - Value *= U; /* ADC readings * U_ref */ -// Value += 511 * Cfg.Samples; /* automagic rounding */ - Value /= 1024; /* / 1024 for 10bit ADC */ - - /* de-sample to get average voltage */ - Value /= Cfg.Samples; - U = (uint16_t)Value; + /* Let the MPU go to sleep while conversion is progressing; + ** - wake up after ISR has executed. */ + sleep_cpu(); + cli(); /* Disable interrupts */ + sleep_disable();/* MPU re-awakens. */ + + /* Get the state of the ADC ISR. */ + ADC_ISR_GetState(&MyISR_DATA); + + /* Check to see if we were awakened too early. */ + if ( (MyISR_DATA.pADCvectFnc != GeneralISRnullVector) ) + continue; /* Most likely interrupted by non-ADC interrupt. */ + + /* Normally, we will wake up from sleep when the samples are complete. */ + /* ...else Samples are complete - was it a full scan? */ + if ( (MyISR_DATA.Count >= MyISR_DATA.RequestedSamples) ) + break; /* Full scan complete: NOTE interrupts still disabled.*/ + +#if 0 + THIS IS NOT POSSIBLE - Count returns either AUTOPRESAMPLES or RequestedSamples + /* Samples are complete - was it AutoScale? */ + if ( (MyISR_DATA.Count != AUTOPRESAMPLES) ) + { + /* Note: Interrupts are still disabled. */ + ADC_ISR_ChangeState(MyVectFnc); + /* NOT NEEDED: sei(); enable interrupts */ + continue; + } +#endif + + /* ...else - AutoScale detected - reference change is required. */ +#if 0 + NOTE: This condition is impossible with (see comment in config.h): + Note: AUTOPRESAMPLES must be >= 2 + Note: Cfg.Samples must be > AUTOPRESAMPLES + if ( (MyISR_DATA.RequestedSamples <= AUTOPRESAMPLES) ) + break;/* Sanity-check: Cfg.Samples not high enough - use samples we have. */ +#endif + + /* ...else Change the Reference channel used by the ADC. + ** Note the ChangeADCRefLocal() may over-ride when a valid + ** external reference is available. + */ + Channel &= ~ADC_REF_MASK; /* clear reference bits */ + Channel |= ADC_REF_BANDGAP; /* select internal reference */ + + /* Note interrupts are already disabled. */ + MyADCclock = ADC_ISR_GetADCclock();/* Get the starting time */ + ChangeADCRefLocal(Channel, MyADCclock); /* set input channel and U reference */ + + /* Now that the reference change is complete restart sample + ** processing. + */ + /* Note interrupts are already disabled. */ + + /* Note: Interrupts are still disabled. */ + ADC_ISR_ChangeState(MyVectFnc); + + wdt_reset(); /* Reset watchdog */ + + /* Go back to sleep at top of loop. */ + } + while (1); /* Transition through the ISR state program */ + + /* NOT NEEDED: sleep_disable(); */ + +#if 0 + LEAVE ADC Conversion interrupts enabled + /* Leave the ADC Enabled and disable the Auto Trigger and Interrupt Enable Flag. + ** Note: ADC is left enabled to avoid restart delay when powered back up later. + */ +#endif + + SREG = StatusReg; /* Return Status Register to original */ + + /* + ** convert ADC reading to voltage + ** - single sample: U = ADC reading * U_ref / 1024 + */ // todo: do we need a sanity check for U <= Vcc? - return U; + Samples = MyISR_DATA.Count; /* Actual number of samples taken. */ + + /* Sanity check - this should never happen. */ + if ( !(Samples) ) return (Samples); + + SumValue = MyISR_DATA.Sum; + + /* Convert to the mVolt equivalent. */ + /* SumValue = ((SumValue * URefMV) + Samples * (1024U / 2)) / Samples; */ + /* Note max Samples = 2^8 times (1024/2) = 2^9 produces 2^17 bit result */ + Rounder = (uint32_t)Samples * (1024UL / 2); /* Rounding value. */ + SumValue = ScaleChange32U16U( + SumValue /* value to be converted */ + , Cfg.ADCref /* Scale factor */ + , Rounder /* 32-bit Rounding part */ + , Samples /* Divisor */ + , 10); /* power2_divider needed. */ + + return ((uint16_t)SumValue); +} /* END: ReadULocal() */ +#endif + +#if (ADC_READU_LVL == 0) +/**************************************************************************** +** +** Function: ADC_UpdateReferenceInformation() +** - Update the ADC conversion routines with measurement results of +** actual references. +** +** Notes and Restrictions: +** This function is called by CheckVoltageRefs() that executes +** periodically to re-measure the current references. +** This function defines the RANGE for valid use of a reference. +** Remember to keep changes sync'd with ADC_UpdateReferenceInformation() +** in stateADCvectISR.c +*/ +void ADC_UpdateReferenceInformation( + uint16_t Vcc, /* I: Current Vcc reference */ + uint16_t Bandgap,/* I: Current Bandgap reference */ + uint16_t ExtRef) /* I: Current External reference */ +{ +uint32_t CapValue; +uint32_t Rounder; +uint16_t IntRefLimit; + + Rounder = (Vcc / 2); + +#if defined(HW_ADCREF_EXTREF) +uint16_t ExtRefLimit; + + CapValue = (ExtRef - 1); + ExtRefLimit = (CapValue * (AUTOPRESAMPLES * 1024UL) + Rounder) / Vcc; +#endif + + CapValue = (Bandgap - 1); + IntRefLimit = (CapValue * (AUTOPRESAMPLES * 1024UL) + Rounder) / Vcc; + + memset(&RefInfo, 0, sizeof(RefInfo)); + + RefInfo.IntRefOvRg = IntRefLimit; +#if defined(HW_ADCREF_EXTREF) + RefInfo.ExtRefOvRg = ExtRefLimit; +#endif } +/************************************************************************** +** Sum ADC samples. +** - Perform busy-wait summation of a given number of ADC samples. +** - with a 125kHz ADC clock a single conversion needs about 0.1ms +** with 25 samples we end up with about 2.6ms +** +** Notes & Restirctions: +** - Supplied Counter > 0 +** - Setup channel for reading before calling. +** - Start the first conversion before calling. +** - Pre-setup the ADC MUX input channel +*/ +static uint32_t SumADCU( + uint8_t Counter)/* loop counter */ +{ +uint32_t Value; /* ADC value sum */ + /* Special case: Only one Sample required. */ + if ( (Counter == 1) ) + { + while (ADCSRA & (1 << ADSC));/* wait until conversion is done */ + Value = ADCW; /* add ADC reading */ + goto RETURN; + } + + /* ...else (Counter >= 2). Reset and wait for dummy conversion. */ + Value = 0UL; /* reset sampling variable */ + Counter -= 1; /* Note: Assumes (Counter > 1) */ + + /* Finish off the dummy conversion in progress... */ + while (ADCSRA & (1 << ADSC));/* wait until conversion is done */ + + /* Start the first useful conversion immediately. */ + ADCSRA |= (1 << ADSC);/* start conversion */ + + /* + ** Accumulate the requested ADC readings... + **/ + do + { + while (ADCSRA & (1 << ADSC));/* wait until conversion is done */ + + /* Start the next useful conversion immediately. */ + ADCSRA |= (1 << ADSC);/* start conversion */ + + Value += ADCW; /* add ADC reading */ + } + while (--Counter); /* take samples */ + + /* Finish the last conversion. */ + while (ADCSRA & (1 << ADSC));/* wait until conversion is done */ + Value += ADCW; /* add ADC reading */ + + RETURN: + + return (Value); +} /* END: SumADCU() */ + +/***************************************************************************** +** +** Function: ReadULocal() +** +** Refer to ReadU() for the external interface description. +** +** The ReadULocal() function does the work with interrupt details ignored. +** +** Notes and Restrictions: +** - The calling routine is expected to disable interrupts. +** - The calling routine is expected to add Reference part of Channel. +** +** - sleep_mode(ADC) turns off Timer oscillators! +**/ +static uint16_t ReadULocal( + uint8_t Channel) +{ +uint8_t Samples; /* For rounding */ +uint32_t Rounder; /* Rounding value. */ +uint32_t SumValue; /* ADC value */ +uint8_t MyRef; + + /* Force the Analog Comparator to Disabled so the ADC can use the MUX. */ + ACSR = (1 << ACD) | (1 << ACBG) | (1 << ACI);/* Disable AC */ + + SumValue = 0; + Samples = Cfg.Samples; + MyRef = ADCRef; /* The selected ADC reference */ + if ( !(Cfg.AutoScale) || (MyRef != ADC_REF_VCC) ) + goto full_sample; /* autoscaling disabled */ + + /* ...else AutoScaling is enabled and ADCRef == ADC_REF_VCC... */ + ADCSRA |= (1 << ADSC); /* start conversion */ + SumValue = SumADCU(AUTOPRESAMPLES);/* perform AUTOPRESAMPLES samples */ + + /* Keep the existing Reference if the lower Reference would over range. */ + if ( ADC_CHECK_REFERENCE_OVERRANGE(SumValue) ) + { /* NOTE: SumADCU() requires at least 1 count (AUTOPRESAMPLES + 1) minimum. */ + if ( (Samples <= (AUTOPRESAMPLES + 1)) ) + { + Samples = AUTOPRESAMPLES; + goto RETURN; + } + /* ...else take off AUTOPRESAMPLES samples already taken. */ + Samples -= AUTOPRESAMPLES; + goto full_sample; /* Note the VCC Reference will still be used.*/ + } + + /* ...else Change the Reference channel used by the ADC. */ + SumValue = 0; + MyRef = (Channel & ~(ADC_REF_MASK));/* Clear ref. bits */ + MyRef |= ADC_REF_BANDGAP;/* select bandgap reference */ + + /* Note: ChangeADCRefLocal() will over-ride ADC_REF_BANDGAP and use + ** the external reference if it is valid. + */ + ChangeADCRefLocal(MyRef); /* set input channel and U reference */ + +full_sample: + + ADCSRA |= (1 << ADSC); /* start conversion */ + SumValue += SumADCU(Samples); /* perform Samples samples */ + + Samples = Cfg.Samples; /* A Full set of samples was taken. */ + +// todo: do we need a sanity check for U <= Vcc? + +RETURN: + + /* + ** convert ADC reading to voltage + ** - single sample: U = ADC reading * U_ref / 1024 + */ + + /* Convert to the mVolt equivalent. */ + /* SumValue = ((SumValue * URefMV) + Samples * (1024U / 2)) / Samples; */ + /* Note max Samples = 2^8 times (1024/2) = 2^9 produces 2^17 bit result */ + Rounder = (uint32_t)Samples * (1024UL / 2); /* Rounding value. */ + + /* Equivalent to: SumValue = ((SumValue * URefMV) + Rounder) / (Cfg.Samples << 10); */ + SumValue = ScaleChange32U16U( + SumValue /* value to be converted */ + , Cfg.ADCref /* Scale factor */ + , Rounder /* 32-bit Rounding part */ + , Samples /* Divisor */ + , 10); /* power2_divider needed. */ + + return ((uint16_t)SumValue); +} /* END: ReadULocal() for ADC_READU_LVL == 0 */ +#endif /* ************************************************************************ * convenience functions @@ -190,11 +652,68 @@ uint16_t ReadU_5ms(uint8_t Channel) { - wait5ms(); /* wait 5ms */ +uint16_t MyReading; +uint8_t TempByte; - return (ReadU(Channel)); -} +#if (ADC_READU_LVL == 1) +uint8_t StatusReg; +uint16_t MyADCclock; /* Copy of clock. */ + + StatusReg = SREG; /* Note interrupt enable status */ + + cli(); /* Disable interrupts */ + + /* Note interrupts are already disabled. */ + MyADCclock = ADC_ISR_GetADCclock(); /* Get the starting time */ +#endif + /* Modify the given channel to add reference information. */ + TempByte = Channel; + + #if 0 + /* manage channels ADC8-15 (ATmega640/1280/2560) */ + if (TempByte & 0b00100000) /* bit 6 set: ADC8-15 */ + { + ADCSRB |= (1 << MUX5); /* set MUX5 */ + } + else /* bit 6 not set: ADC0-7 */ + { + ADCSRB &= ~(1 << MUX5); /* clear MUX5 */ + } + #endif + + /* Default: Use Vcc as reference. + ** prepare bitfield for register: start with AVcc as voltage reference + */ + TempByte &= ~ADC_REF_MASK;/* clear reference bits */ + TempByte |= ADC_REF_VCC;/* add bits for voltage reference: RefVcc */ + +#if (ADC_READU_LVL == 1) + ChangeADCRefLocal(TempByte, MyADCclock); /* ADMUX: set input channel and U reference */ + + sei(); /* Re-enable interrupts for the delay. */ + + /* Note: ADCautoscanDelay() turns on the interrupts temporarily. */ + ADCautoscanDelay(MyADCclock, CONVERT_USEC_TO_ADC_TICKS(5000)); +#else + ChangeADCRefLocal(TempByte);/* ADMUX: set input channel and U reference */ + + wait5ms(); /* wait 5ms */ +#endif + + /* The newer implementation uses Interrupts. */ +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts */ + + MyReading = ReadULocal(TempByte, StatusReg); + + /* Note: ReadULocal() performs the Re-Enable of interrupts. */ +#else + MyReading = ReadULocal(TempByte); +#endif + + return (MyReading); +} /* END: ReadU_5ms() */ /* @@ -204,17 +723,931 @@ uint16_t ReadU_20ms(uint8_t Channel) { - wait20ms(); /* wait 20ms */ +uint16_t MyReading; +uint8_t TempByte; - return (ReadU(Channel)); -} +#if (ADC_READU_LVL == 1) +uint8_t StatusReg; +uint16_t MyADCclock; /* Copy of clock. */ + + StatusReg = SREG; /* Note interrupt enable status */ + + cli(); /* Disable interrupts */ + + /* Note interrupts are already disabled. */ + MyADCclock = ADC_ISR_GetADCclock(); /* Get the starting time */ +#endif + + /* Modify the given channel to add reference information. */ + TempByte = Channel; + + #if 0 + /* manage channels ADC8-15 (ATmega640/1280/2560) */ + if (TempByte & 0b00100000) /* bit 6 set: ADC8-15 */ + { + ADCSRB |= (1 << MUX5); /* set MUX5 */ + } + else /* bit 6 not set: ADC0-7 */ + { + ADCSRB &= ~(1 << MUX5); /* clear MUX5 */ + } + #endif + + /* Default: Use Vcc as reference. + ** prepare bitfield for register: start with AVcc as voltage reference + */ + TempByte &= ~ADC_REF_MASK;/* clear reference bits */ + TempByte |= ADC_REF_VCC;/* add bits for voltage reference: RefVcc */ + +#if (ADC_READU_LVL == 1) + ChangeADCRefLocal(TempByte, MyADCclock); /* ADMUX: set input channel and U reference */ + + sei(); /* Re-enable interrupts for the delay. */ + + /* Note: ADCautoscanDelay() turns on the interrupts temporarily. */ + ADCautoscanDelay(MyADCclock, CONVERT_USEC_TO_ADC_TICKS(20000)); +#else + ChangeADCRefLocal(TempByte);/* ADMUX: set input channel and U reference */ + + wait20ms(); /* wait 20ms */ +#endif + + /* The newer implementation uses Interrupts. */ +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts */ + + MyReading = ReadULocal(TempByte, StatusReg); + + /* Note: ReadULocal() performs the Re-Enable of interrupts. */ +#else + MyReading = ReadULocal(TempByte); +#endif + + return (MyReading); +} /* END: ReadU_20ms() */ + +/**************************************************************************** +** +** SpinWaitSingleSample() +** - Helper function to do a single sample conversion. +** +** Notes & Restrictions: +*/ +uint16_t SpinWaitSingleSample(void) +{ +uint16_t MyReading; /* Measurement value */ + + while (ADCSRA & (1 << ADSC));/* wait until conversion is done */ + MyReading = ADCW; /* ADC reading */ + + /* Scale to the proper reference. */ + MyReading = ScaleChange32U16U( + MyReading /* value to be converted */ + , Cfg.ADCref /* Scale factor */ + , 512 /* 32-bit Rounding part */ + , 1 /* Divisor */ + , 10); /* power2_divider needed. */ + + return (MyReading); +} /* END: SpinWaitSingleSample() */ + +/**************************************************************************** +** +** ChangeADCRef() +** - Helper function to keep track when pauses are required because of +** changes to ADC Reference and/or ADC Enable (ADEN). +** +** Allow time for settling after changing the ADC reference source. +** +** Notes & Restrictions: +** The datasheet suggests a settling time delay for either change +** of ADC Enable or MUX reference. +** Do not attempt to change ADMUX outside this routine as it would +** circumvent the desired functionality. +*/ +void ChangeADCRef( + uint8_t Channel) +{ +#if (ADC_READU_LVL == 1) +uint16_t MyADCclock; /* Copy of clock. */ +uint8_t StatusReg; + + StatusReg = SREG; /* Note interrupt enable status */ + + cli(); /* Disable interrupts */ + + MyADCclock = ADC_ISR_GetADCclock(); /* Get the starting time */ +#endif + + ChangeADCRefLocal( Channel +#if (ADC_READU_LVL == 1) + , MyADCclock +#endif + ); + +#if (ADC_READU_LVL == 1) + SREG = StatusReg; /* Return Status Register to original */ +#endif + +} /* END: ChangeADCRef() */ + +/**************************************************************************** +** +** Function: TurnOffADCconversionInterrupts() +** - Turn off the ADC continuous sampling interrupts. +** +** Notes and Restrictions: +** It is expected that the ADC was previously initialized: +** - ChangeADCRef() +** - ADCautoscanDelay() +** - ReadU() +** - MilliSleep() +** +** This function turns off the normally required ADC continuous sampling +** interrupts. Only use this when dealing with very time- +** sensitive processes where interrupts could interfere such +** as bit-bang protocols and/or very short duration pulses. +*/ +void TurnOffADCconversionInterrupts(void) +{ +uint8_t SRA_NormalMode; +uint8_t TempByte; + +#if (ADC_READU_LVL == 1) +uint8_t StatusReg; + + StatusReg = SREG; /* Note interrupt enable status */ + + cli(); /* Disable interrupts */ +#endif + +#if defined(SAVE_POWER) + TempByte = Cfg.SleepMode;/* Get current mode */ + if ( (TempByte == SLEEP_MODE_ADC) ) + { +#endif + TempByte = SLEEP_MODE_IDLE;/* Mark ADC mode complete. */ + set_sleep_mode(TempByte); +#if defined(SAVE_POWER) + } + Cfg.SleepMode = SLEEP_MODE_IDLE;/* Mark ADC mode complete. */ +#endif + +#if 1 + SRA_NormalMode= 0; /* Force ADC completely off */ +#else +#if (ADC_READU_LVL == 1) + SRA_NormalMode= (1 << ADEN) | (1 << ADIF) | ADC_CLOCK_DIV; +#else + /* No interrupt mode required for basic operation. */ + SRA_NormalMode= (1 << ADEN) | (1 << ADIF) | ADC_CLOCK_DIV; +#endif +#endif + + /* Leave the ADC Enabled and disable the Auto Trigger and Interrupt Enable Flag. + ** Note: ADC is left enabled to avoid restart delay when powered back up later. + */ + ADCSRA = SRA_NormalMode; /* Disable ADC */ + +#if (ADC_READU_LVL == 1) + SREG = StatusReg; /* Return Status Register to original */ +#endif + +} /* END: TurnOffADCconversionInterrupts() */ + +/**************************************************************************** +** +** Function: ReadU() +** Read ADC channel and return voltage in mV +** - use Vcc as reference by default +** - switch to bandgap reference for low voltages (< 1.0V) to improve +** ADC resolution +** - with a 125kHz ADC clock a single conversion needs about 0.1ms +** with 25 samples we end up with about 2.6ms +** +** Notes and Restrictions: +** - sleep_mode(ADC) turns off Timer oscillators! +** - Channel: ADC MUX input channel +** - ATmega328: register bits corresponding with MUX0-3 +** - ATmega324/644/1284: register bits corresponding with MUX0-4 +** - ATmega640/1280/2560: register bits corresponding with MUX0-4 +** (todo: add MUX5 to support also ADC8-15) +*/ +uint16_t ReadU( + uint8_t Channel) +{ +uint16_t MyReading; +uint8_t TempByte; + + /* The newer implementation uses Interrupts. */ +#if (ADC_READU_LVL == 1) +uint8_t StatusReg; +uint16_t MyADCclock; /* Copy of clock. */ + + StatusReg = SREG; /* Note interrupt enable status */ +#endif + + /* Modify the given channel to add reference information. */ + TempByte = Channel; + + #if 0 + /* manage channels ADC8-15 (ATmega640/1280/2560) */ + if (TempByte & 0b00100000) /* bit 6 set: ADC8-15 */ + { + ADCSRB |= (1 << MUX5); /* set MUX5 */ + } + else /* bit 6 not set: ADC0-7 */ + { + ADCSRB &= ~(1 << MUX5); /* clear MUX5 */ + } + #endif + + /* Default: Use Vcc as reference. + ** prepare bitfield for register: start with AVcc as voltage reference + */ + TempByte &= ~ADC_REF_MASK;/* clear reference bits */ + TempByte |= ADC_REF_VCC;/* add bits for voltage reference: RefVcc */ + + /* The newer implementation uses Interrupts. */ +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts */ + + /* Note interrupts are already disabled. */ + MyADCclock = ADC_ISR_GetADCclock(); /* Get the starting time */ + ChangeADCRefLocal(TempByte, MyADCclock); /* ADMUX: set input channel and U reference */ + + MyReading = ReadULocal(TempByte, StatusReg); + + /* Note: ReadULocal() performs the Re-Enable of interrupts. */ +#else + ChangeADCRefLocal(TempByte);/* ADMUX: set input channel and U reference */ + + MyReading = ReadULocal(TempByte); +#endif + + return (MyReading); + +} /* END: ReadU() */ + +/**************************************************************************** +** +** Function: ReadUSingleSample() +** Same function as ReadULocal() with the exception that Cfg.Samples is +** ignored and a single sample is taken. +** +** Notes and Restrictions: +** - This function allows for flexibility - it can either use ADC +** interrupts or the spin-wait. +** - This function is flexible to allow pre-specified reference +** in contrast to ReadU() that forces ADC_REF_VCC. +** - Make sure that the calling code sets the desired reference to +** use (i.e. Channel |= ADC_REF_BANDGAP +** or Channel |= ADC_REF_VCC). +** - Note that no first sample discard occurs - the references should +** unchanged and settled before calling. +*/ +uint16_t ReadUSingleSample( + uint8_t Channel) +{ +uint16_t MyReading; +uint8_t OrigSamples; +uint8_t OrigAutoScale; + +#if (ADC_READU_LVL == 1) +uint8_t MySR; +uint8_t StatusReg; + uint16_t MyADCclock; + + StatusReg = SREG; /* Note interrupt enable status */ +#endif + + #if 0 + /* manage channels ADC8-15 (ATmega640/1280/2560) */ + if (Channel & 0b00100000) /* bit 6 set: ADC8-15 */ + { + ADCSRB |= (1 << MUX5); /* set MUX5 */ + } + else /* bit 6 not set: ADC0-7 */ + { + ADCSRB &= ~(1 << MUX5); /* clear MUX5 */ + } + #endif + + /* Over-ride the Samples and AutoScale settings for the subroutine call. */ + OrigSamples = Cfg.Samples; + OrigAutoScale = Cfg.AutoScale; + Cfg.AutoScale = 0; /* Over-ride. */ + Cfg.Samples = 1; /* Over-ride. */ + +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts */ + + /* Note interrupts are already disabled. */ + MyADCclock = ADC_ISR_GetADCclock(); /* Get the starting time */ + ChangeADCRefLocal(Channel, MyADCclock); /* ADMUX: set input channel and U reference */ + + MySR = ADCSRA; + + /* If the user has ADC Interrupts ENabled then use the normal routine. */ + if ( (MySR & (1 << ADIE)) ) + { + MyReading = ReadULocal( + Channel + , StatusReg); + + /* Note: ReadULocal() performs the Re-Enable of interrupts. */ + } + else /* No interrupts... use the busy-wait technique. */ + { + /* Start the first useful conversion immediately. */ + ADCSRA |= (1 << ADSC);/* start conversion */ + + MyReading = SpinWaitSingleSample(); + + SREG = StatusReg; /* Return Status Register to original */ + } +#else + ChangeADCRefLocal(Channel);/* ADMUX: set input channel and U reference */ + + /* Start the first useful conversion immediately. */ + ADCSRA |= (1 << ADSC);/* start conversion */ + + MyReading = SpinWaitSingleSample(); +#endif + + Cfg.Samples = OrigSamples; /* Return to default. */ + Cfg.AutoScale = OrigAutoScale;/* Return to default */ + + return (MyReading); + +} /* END: ReadUSingleSample() */ + +/**************************************************************************** +** Common Timer/Counter1 functions. +*****************************************************************************/ +/* +** StartTimer1AnalogComparison() +** - Analog comparison inter-linked with Timer 1. +** - Timer 1 will be captured when comparison value has been reached. +** +** Notes & Restrictions: +** - Do not call ReadU() from within this function. +** - Assumes Timer 1 Analog Comparator Input Capture is pre-enabled. +** - ADC register setup is required before calling. +** - Timer 1 is used to count prescaled MPU cycles. +** - Function returns with analog comparison off and ADC enabled again. +**/ +uint32_t StartTimer1AnalogComparison( + uint8_t Channel, /* Reference Channel and Mux Channel. */ + pChargingFnc performStartCharging, /* Function to call to start charging. */ + pChargingFnc performStopCharging, /* Function to call to stop charging when done. */ + uint8_t Mode, /* Optional: Mode of operation */ + uint8_t TIFR1_Capture_Setting, /* Sets the Timer 1 Interupt register as needed. */ + uint8_t TIFR1_Overflow_Setting, /* Sets Timer 1 Interupt register upon overflow. */ + uint16_t timeoutTicks) /* Return if no response within period. */ +{ +uint8_t SRA_DisabledMode; +uint8_t TempByte; /* temp. value */ +uint8_t MyIRQFlag; /* IRQ active flag */ +uint8_t MyPRR; /* Power Reduction Register */ +uint16_t TicksL; /* timer counter */ +uint16_t TicksH; /* timer overflow counter */ +uint8_t MyRef; + +#if (ADC_READU_LVL == 1) +uint8_t StatusReg; + + StatusReg = SREG; /* Note interrupt enable status */ +#endif + MyRef = Channel & ADC_REF_MASK; /* Get reference bits */ + TicksL = TicksH = 0;/* reset timer overflow counter */ + + /* Note: We are unable to turn off ADC power because we use the ADCMUX! + ** Turn on the TIMER1 if power to it is off. + */ + MyPRR = PRR; + if ( (MyPRR & (1 << PRTIM1)) ) /* Timer1 powered off? */ + { + PRR = (MyPRR & ~(1 << PRTIM1));/* Re-Enable Timer1 for use */ + TCCR1B = 0; /* Ensure timer is off: prescaler disabled. */ + } + + SAVE_IRQ_ACTIVE(MyIRQFlag) /* Save the original value */ + + wdt_reset(); /* reset watchdog */ + +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts */ +#endif + + /* NOTE: DO NOT CALL: ChangeADCRefLocal(Channel) - it enables ADC */ + + /* Set the ADC multiplexer and separate out the Reference source. */ + ADMUX = Channel; /* set input channel and U reference */ + + ADCRef = MyRef; /* update reference source */ + + /* The selected ADC reference */ + switch (MyRef) + { + case ADC_REF_BANDGAP: + Cfg.ADCref = Cfg.Bandgap; /* Use the backup reference */ + break; +#if defined(HW_ADCREF_EXTREF) + case ADC_REF_EXTERNAL: + Cfg.ADCref = ADCExtRef; + break; +#endif + case ADC_REF_VCC: + default: + Cfg.ADCref = Cfg.Vcc; /* Default: convert to voltage; Vcc as reference */ + break; + } + + ADC_FORCE_INTERRUPTS_OFF() + + /* Temporarily turn off the ADC converter completely. */ +#if (ADC_READU_LVL == 1) + SRA_DisabledMode= ADC_CLOCK_DIV; + + /* Note interrupts are already disabled. */ +#else + /* No interrupt mode required for basic operation. */ + SRA_DisabledMode= ADC_CLOCK_DIV; +#endif + ADCSRA = SRA_DisabledMode; /* Disable ADC */ + + /* Set up timer but do not start it yet. */ + TCCR1A = 0; /* set default mode */ + TCCR1B = 0; /* turn off timer */ + /* timer stopped, falling edge detection, noise canceler disabled */ + TCNT1 = 0; /* set Counter1 to 0 */ + + /* Set up analog comparator to see when Bandgap reference is reached. */ + ADCSRB |= (1 << ACME); /* use ADC multiplexer as negative input */ + TempByte = (1 << ACBG) | (1 << ACI); /* use bandgap as positive input */ + ACSR = TempByte; /* also reset the interrupt flag */ + +#if (ADC_READU_LVL == 1) + sei(); /* Enable interrupts for delay. */ +#endif + + /* Wait for bandgap reference to stabilize. */ + /* wait some time for voltage stabilization */ + #if defined(ADC_LARGE_BUFFER_CAP) + /* buffer cap: 100nF */ + wait10ms(); /* 10ms */ + #else + /* buffer cap: 1nF or none at all */ + wait1ms(); /* 1ms */ + #endif + + SET_IRQ_ACTIVE() /* Mark the timer active. */ + +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts again after the delay */ +#endif + + /* Timer setup is complete: Tell Analog Comparator to trigger Timer1 */ + TempByte |= (1 << ACIC); /* Add Comparator Input Capture mode */ + ACSR = TempByte; /* use bandgap (positive input), trigger Timer1 */ + + /* Start with sleep mode disabled. */ + sleep_disable(); /* Default: ensure sleep mode bit is clear */ + + /* clear all flags (input capture, compare A & B, overflow */ + TIFR1 = (1 << ICF1) | (1 << OCF1B) | (1 << OCF1A) | (1 << TOV1); + + (*performStartCharging)(Mode); // Function to pull-up pin-1 via Rh */ + +#if (ADC_READU_LVL == 1) + sei(); /* Enable interrupts for the loop */ +#endif + + /* + * timer loop + * - run until voltage is reached + * - detect timer overflow + */ + do + { + TempByte = TIFR1; /* get Timer1 flags */ + + /* end loop if input capture flag is set (= same voltage) */ + if ( (TempByte & TIFR1_Capture_Setting) ) + break; + + /* detect timer overflow by checking the overflow flag */ + if ( (TempByte & TIFR1_Overflow_Setting) ) // Timer 1 overflow flag. + { + /* happens at 65.536ms for 1MHz or 8.192ms for 8MHz */ + TIFR1 = TIFR1_Overflow_Setting;/* Reset overflow flag */ + wdt_reset(); /* reset watchdog */ + TicksH++; /* increase overflow counter */ + + /* end loop if charging takes too long (about 313 micro-seconds typical) */ + if ( (TicksH >= timeoutTicks) ) + break; + } + } + while (1); + + /* stop counter */ + TCCR1B = 0; /* stop timer */ + +#if (ADC_READU_LVL == 1) + cli(); /* Disable interrupts again */ +#endif + + /* Disable charging */ + (*performStopCharging)(Mode); + + TempByte = TIFR1; /* get Timer1 flags */ + TicksL = ICR1; /* get final capture counter value */ + + /* Catch missed timer overflow */ + if ( ((TCNT1 - TicksL) < 5050) /* Negative show as large number */ + && (TempByte & TIFR1_Overflow_Setting) ) /* Timer 1 reset capture flag */ + { + wdt_reset(); /* reset watchdog */ + TicksH++; /* increase overflow counter */ + } + + /* clear all flags (input capture, compare A & B, overflow */ + TIFR1 = (1 << ICF1) | (1 << OCF1B) | (1 << OCF1A) | (1 << TOV1); + + ADCSRB &= ~(1 << ACME);/* Turn off the Analog Comparator use of MUX. */ + TempByte = (1 << ACD) | (1 << ACBG) | (1 << ACI);/* Disable the Analog Comparator */ + ACSR = TempByte; /* also reset the interrupt flag */ + + RESTORE_IRQ_ACTIVE(MyIRQFlag)/* Restore the original value */ + + PRR = MyPRR; /* Restore Power Reduction Register */ + + /* Note: Leave the ADC disabled for now, the next ChangeRef() or + ** ReadU() will re-activate. + */ + +#if (ADC_READU_LVL == 1) + SREG = StatusReg; /* Return Status Register to original */ +#endif + + /* Combine both counter values and return the result. */ + return ( ((uint32_t)TicksH << 16) /* set upper 16 bits */ + + (uint32_t)TicksL ); /* set lower 16 bits */ +} /* END: StartTimer1AnalogComparison() */ + +#if defined(HW_EXTREF) +/**************************************************************************** +** +** Function: SumOfMeasurements() +** - helper function for main.c +** When more accurate voltage references are available than INTERNAL +** BANDGAP and VCC then we correct their typical values based +** upon the external reference. +** +** Notes & Restrictions: +** - Normally, the external reference is used when available and valid. +** - To get past this, we temporarily over-ride OP_EXT_REF. +*/ +static uint32_t SumOfMeasurements( + uint8_t Channel, + uint16_t TotalCount) +{ +uint16_t Count; +uint32_t MySum; + + ChangeADCRef(Channel);/* Delay here if reference changed. */ + + /* Do dummy measurement for settling. */ + Count = 5; + MySum = 0; + do + { + wdt_reset(); /* reset watchdog */ + MySum += ReadUSingleSample(Channel); + } + while ( (--Count) ); + + /* Do the real measurement. */ + Count = TotalCount; + MySum = 0; + do + { + wdt_reset(); /* reset watchdog */ + MySum += ReadUSingleSample(Channel); + } + while ( (--Count) ); + + return (MySum); + +} /* END: SumOfMeasurements() */ + +/**************************************************************************** +** +** Function: MakeCorrections() +** - helper function for main.c initialization of ADC reference values. +** When more accurate voltage references are available than INTERNAL +** BANDGAP and VCC then we correct their typical values based +** upon the external reference. +** +** Notes & Restrictions: +** The externally attached reference (if exists) should be highly +** - accurate (i.e. as close as possible to UEXTREF) +** - precise (i.e. requires low temperature coefficient) +** - stable (resolution of converter is 1/1024 == 977. ppm). +** - low noise (filtered from VCC and RC filtered at REF Input Pin) +*/ +static uint16_t MakeCorrections( + uint16_t SpecdReference, /* I: Well-defined voltage constant. */ + uint16_t TotalCount, /* I: total number of readings. */ + uint32_t MyExternalRefSum) +{ +uint8_t Channel; +uint32_t Rounder; +uint32_t MySum; +#if defined(HW_ADCREF_EXTREF) +uint16_t ExtBandgap; +#endif + + /************************************************************************* + ** Use the Vcc reference measurement of the external reference to + ** correct the inital value used for Vcc. + ************************************************************************** + ** Ensure that the 32bit multiply stays in range: + ** Vcc = (Measurement * Vcc + Rounder) / (UEXTREF * TotalCount) + ** Remember: Channel = ADC_REF_VCC | TP_REF; + ************************************************************************** + ** Worst-case analysis: + ** Typical maximum for 156250 Hz ADC and: + ** Given: Ext. Bandgap == 2948 mV; Vcc == 5036 mV: + ************************************************************************** + ** TotalCount /2 == 1157 / 2 == 578(2^10) + ** SpecdReference/2 == 5000 / 2 == 1474(2^11) + ** MySum == 851972(2^20) + ** MyExternalRefSum / 4 == 2948 * 1157 / 4 == 3410836 / 4 == 852709(2^20) + ** MyExternalRefSum / 4 * Vcc == 852709 * 5036 == 4294242524(2^32) + */ + MyExternalRefSum /= 4; /* Avoid overflow of 32-bit multiply */ + MySum = ((uint32_t)TotalCount / 2) * ((uint32_t)SpecdReference/ 2) ; + Rounder = MySum / 2; + Cfg.Vcc = ScaleChange32U16U( + MyExternalRefSum/* value to be converted */ + , Cfg.Vcc /* Scale factor */ + , Rounder /* 32-bit Rounding part */ + , MySum /* Divisor */ + , 0); /* power2_divider not needed. */ + + /************************************************************************* + ** Now that Cfg.Vcc is corrected, measure the internal Bandgap is using + ** Vcc as a reference. + */ + Channel = ADC_REF_VCC | ADC_CHAN_BANDGAP;/* Force VCC reference */ + MySum = SumOfMeasurements( Channel + , TotalCount); + + /* Use the Bandgap reference measurement to obtain a correct + ** Cfg.Bandgap - this is a simple rounded average value. + ** Bandgap = (MySum + Rounder) / TotalCount + */ + Rounder = ((uint32_t)TotalCount) / 2; /* For rounding */ + MySum = ScaleChange32U16U( + MySum /* value to be converted */ + , 1 /* Scale factor */ + , Rounder /* 32-bit Rounding part */ + , (uint32_t)TotalCount /* Divisor */ + , 0); /* power2_divider not needed. */ + Cfg.Bandgap = MySum + NV.RefOffset; /* add voltage offset */ + +#if !defined(HW_ADCREF_EXTREF) + return (0); /* Default: Use last measurement. */ +#else + /************************************************************************* + ** Note: the external reference has passed initial range validation. + ************************************************************************** + ** Now use the external reference as a direct ADC reference input. + ** Note: if available, this is a high-impedance reference that should + ** have a small voltage drop from the specified value. + ** Note that the external reference is only required to be measured once + ** during the startup measurement process since it is expected to be + ** ultra-stable. + */ + ExtBandgap = ADCExtRef; /* Default: Use last measurement. */ + if ( !(ADCExtRef) ) + { + /* ...else measure for the first time. */ + /* Cfg.OP_Mode |= (OP_EXT_REF);** Default: Valid reference */ + /********************************************************************* + ** Now that Cfg.Bandgap is corrected, measure it using the external + ** Bandgap. Note that this requires the Valid Reference + ** bit set. + ** Until we measure actual values, temporary use of the specification + ** value (SpecdReference) is okay. Note the reason for the + ** difference from specified value is the ~10 uAmp draw through + ** the external reference supply resistor (about 26 mV for 2.6k). + */ + ADCExtRef = SpecdReference; /* Temporary: Valid Reference. */ + + /* ExtBandgap = MySum; ** SAVE: Bandgap reference value */ + Channel = ADC_REF_BANDGAP | ADC_CHAN_BANDGAP;/* Force ext. reference */ + MySum = SumOfMeasurements(Channel, TotalCount); + ADCExtRef = 0; /* Allow limit checks to proceed.. */ + + /* Use the Bandgap reference measurement to obtain a correct + ** Cfg.ExtBandgap. + ** ExtBandgap = (MySum * Cfg.Bandgap + Rounder) / (Cfg.Bandgap * TotalCount) + */ + Rounder = ((uint32_t)TotalCount * (uint32_t)Cfg.Bandgap); + MySum = MySum * (uint32_t)Cfg.Bandgap; + MySum = MySum + (Rounder / 2); + ExtBandgap = MySum / Rounder; + } + + return (ExtBandgap); +#endif + +} /* END: MakeCorrections() */ + +#endif +/* END: defined(HW_EXTREF) */ + +/**************************************************************************** +** +** Function: CheckVoltageRefs() +** - helper function for main.c initialization of ADC reference values. +** When more accurate voltage references are available than INTERNAL +** BANDGAP and VCC then we correct their typical values based +** upon the external reference. +** +** Notes & Restrictions: +** The caller is required to change Cfg.Samples (ADC_SAMPLES) back +** to its typical value after CheckVoltageRefs() (ADC_SAMPLES). +** +** The externally attached reference (if exists) should be highly +** - accurate (i.e. as close as possible to UEXTREF) +** - precise (i.e. requires low temperature coefficient) +** - stable (resolution of converter is 1/1024 == 977. ppm). +** - low noise (filtered from VCC and RC filtered at REF Input Pin) +*/ +void CheckVoltageRefs(void) +{ +static uint16_t VccRefNominalValue = 0; +#if defined(HW_EXTREF) +/* Variables required for External Voltage Reference verification: */ +static uint16_t ExtRefNominalValue = 0; +uint8_t Channel; +uint32_t MyURef; /* reference voltage (UEXTREF) */ +uint32_t LowLimit; /* reference voltage (UEXTREF) */ +uint32_t HighLimit; /* reference voltage (UEXTREF) */ +uint16_t TotalCount; +uint32_t MyExternalRefSum; +#endif +#if defined(HW_ADCREF_EXTREF) +uint16_t ExtBandgap; /* reference voltage (UEXTREF) */ +#endif + + /* + ** Vcc voltage reference + ** + ** Note: Cfg.Vcc is initialized to zero at start-up - we use this as a do- + ** once indicator. + ** It is critical that the Cfg.Vcc value is extracted properly from flash. + */ + if ( !(ParseFlashU32(&ADCvccReference[0], &VccRefNominalValue)) ) + { + goto BAILOUT_RETURN; /* Major issue with firmware. */ + } + + Cfg.Vcc = VccRefNominalValue; /* (re)Start from nominal value. */ + + /* First call to ChangeADCRef() will delay when required. */ + Channel = ADC_REF_VCC | TP_REF; /* Force VCC reference */ + + /* Note: Interrupts are allowed here if enabled. + ** This is used because the ReadUSingleSample() routine will not force + ** interrupts on; this is the way to make sure ADC ints are on. + */ + ReadU(Channel); /* Dummy Read */ + +#if defined(HW_EXTREF) + /* + ** External voltage reference is expected - get the specified value. + */ + if ( !(MyURef = ParseFlashU32(&ADCextReference[0], &ExtRefNominalValue))) + { + goto BAILOUT_RETURN; /* Major issue with firmware. */ + } + + /* For high accuracy make reference measurements ove

Hi Ken!

Looks like GitHub added one attachement to the message, truncated it around 64kB, and dropped both file attachements. I guess, GitHub doesn't support that via email. Please try the 'Attach files' button of the comment editor or send a direct email.

Cheers,
Markus

Navigation Menu

Repository navigation

Software Enhancements Ready for Merge - Taken From v1.53m #11

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Software Enhancements Ready for Merge - Taken From v1.53m #11

Description

Activity

madires commented on Oct 30, 2024

KenBC1 commented on Nov 10, 2024

madires commented on Nov 11, 2024

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions