~gabe/flashlight-firmware/anduril2

#define F_CPU 4800000UL

#define SOLID_MODES         5       // How many non-blinky modes will we have?

#define DUAL_BEACON_MODES   5+3     // How many beacon modes will we have (with background light on)?

#define SINGLE_BEACON_MODES 5+3+1   // How many beacon modes will we have (without background light on)?

#define FIXED_STROBE_MODES  5+3+1+3 // How many constant-speed strobe modes?

#define VARIABLE_STROBE_MODES 5+3+1+3+2 // How many variable-speed strobe modes?

#define BATT_CHECK_MODE     5+3+1+3+2+1 // battery check mode index

// Note: don't use more than 32 modes, or it will interfere with the mechanism used for mode memory

#define TOTAL_MODES         BATT_CHECK_MODE

 

//#define ADC_LOW             130     // When do we start ramping

//#define ADC_CRIT            120     // When do we shut the light off

 

#define ADC_42          185 // the ADC value we expect for 4.20 volts

#define ADC_100         185 // the ADC value for 100% full (4.2V resting)

#define ADC_75          175 // the ADC value for 75% full (4.0V resting)

#define ADC_50          164 // the ADC value for 50% full (3.8V resting)

#define ADC_25          154 // the ADC value for 25% full (3.6V resting)

#define ADC_0           139 // the ADC value for 0% full (3.3V resting)

#define ADC_LOW         123 // When do we start ramping down

#define ADC_CRIT        113 // When do we shut the light off

#ifdef OWN_DELAY

#include <util/delay_basic.h>

// Having own _delay_ms() saves some bytes AND adds possibility to use variables as input

static void _delay_ms(uint16_t n)

{

    // TODO: make this take tenths of a ms instead of ms,

    // for more precise timing?

    // (would probably be better than the if/else here for a special-case

    // sub-millisecond delay)

    if (n==0) { _delay_loop_2(300); }

    else {

        while(n-- > 0)

            _delay_loop_2(1050);

    }

}

#else

#include <util/delay.h>

#endif

#include <avr/eeprom.h>

#define STAR2_PIN   PB0

#define STAR3_PIN   PB4

#define STAR4_PIN   PB3

#define PWM_PIN     PB1

#define VOLTAGE_PIN PB2

#define ADC_CHANNEL 0x01    // MUX 01 corresponds with PB2

#define ADC_DIDR    ADC1D   // Digital input disable bit corresponding with PB2

#define ADC_PRSCL   0x06    // clk/64

 

#define PWM_LVL     OCR0B   // OCR0B is the output compare register for PB1

static uint8_t modes[TOTAL_MODES] = { // high enough to handle all

    MODE_MOON, MODE_LOW, MODE_MED, // dual beacon modes (this level and this level + 2)

    MODE_MED, // battery check mode

PROGMEM const uint8_t voltage_blinks[] = {

    ADC_0,    // 1 blink  for 0%-25%

    ADC_25,   // 2 blinks for 25%-50%

    ADC_50,   // 3 blinks for 50%-75%

    ADC_75,   // 4 blinks for 75%-100%

    ADC_100,  // 5 blinks for >100%

};

    if (mode_idx > (TOTAL_MODES - 1)) {

inline void ADC_on() {

    ADMUX  = (1 << REFS0) | (1 << ADLAR) | ADC_CHANNEL; // 1.1v reference, left-adjust, ADC1/PB2

    DIDR0 |= (1 << ADC_DIDR);                           // disable digital input on ADC pin to reduce power consumption

    ADCSRA = (1 << ADEN ) | (1 << ADSC ) | ADC_PRSCL;   // enable, start, prescale

}

 

inline void ADC_off() {

    ADCSRA &= ~(1<<7); //ADC off

}

 

#ifdef VOLTAGE_MON

uint8_t get_voltage() {

    // Start conversion

    ADCSRA |= (1 << ADSC);

    // Wait for completion

    while (ADCSRA & (1 << ADSC));

    // See if voltage is lower than what we were looking for

    return ADCH;

    // Set timer to do PWM for correct output pin and set prescaler timing

    TCCR0A = 0x23; // phase corrected PWM is 0x21 for PB1, fast-PWM is 0x23

    TCCR0B = 0x01; // pre-scaler for timer (1 => 1, 2 => 8, 3 => 64...)

 

    if (mode_idx == 0) {

       TCCR0A = 0x21; // phase corrected PWM is 0x21 for PB1, fast-PWM is 0x23

        } else if (mode_idx < DUAL_BEACON_MODES) { // two-level fast strobe pulse at about 1 Hz

            for(i=0; i<4; i++) {

                PWM_LVL = modes[mode_idx-SOLID_MODES+2];

                _delay_ms(5);

                PWM_LVL = modes[mode_idx];

                _delay_ms(65);

            }

            _delay_ms(720);

            strobe_len = 1;

            if (modes[mode_idx] < 50) { strobe_len = 0; }

            _delay_ms(strobe_len);

                _delay_ms(0); // less than a millisecond

        } else if (mode_idx < BATT_CHECK_MODE) {

            uint8_t blinks = 0;

            // turn off and wait one second before showing the value

            // (also, ensure voltage is measured while not under load)

            PWM_LVL = 0;

            _delay_ms(1000);

            voltage = get_voltage();

            voltage = get_voltage(); // the first one is unreliable

            // division takes too much flash space

            //voltage = (voltage-ADC_LOW) / (((ADC_42 - 15) - ADC_LOW) >> 2);

            // a table uses less space than 5 logic clauses

            for (i=0; i<sizeof(voltage_blinks); i++) {

                if (voltage > pgm_read_byte(voltage_blinks + i)) {

                    blinks ++;

                }

            }

 

            // blink up to five times to show voltage

            // (~0%, ~25%, ~50%, ~75%, ~100%, >100%)

            for(i=0; i<blinks; i++) {

                PWM_LVL = MODE_MED;

                _delay_ms(100);

                PWM_LVL = 0;

                _delay_ms(400);

            }

 

            _delay_ms(1000);  // wait at least 1 second between readouts

            if (lowbatt_cnt >= 4) {

                if (mode_idx > 1) {

                    mode_idx = 1;