~toykeeper/flashlight-firmware/trunk

 *      I use these fuse settings

 *      Low:  0x75  (4.8MHz CPU without 8x divider, 9.4kHz phase-correct PWM or 18.75kHz fast-PWM)

 *      High: 0xff

 *

 *      For more details on these settings, visit http://github.com/JCapSolutions/blf-firmware/wiki/PWM-Frequency

#define F_CPU 4800000UL

#define OWN_DELAY           // Should we use the built-in delay or our own?

// Adjust the timing per-driver, since the hardware has high variance

// Higher values will run slower, lower values run faster.

#define DELAY_TWEAK         950

#define CONFIG_STARS

#define MODESNx1            0,0,0,6,56,135,255

#define MODES1x1            3,20,100,255,255,255,0

#define MODESNx2            0,0,79,255

#define MODES1x2            20,200,255,0

#define NUM_HIDDEN          3

#define HIDDENMODES         BATTCHECK,STROBE,TURBO

#define HIDDENMODES_PWM     PHASE,PHASE,PHASE

// Uncomment to use a 2-level stutter beacon instead of a tactical strobe

//#define BIKING_STROBE

#define TURBO_TIMEOUT       60

 

// These values were measured using wight's "A17HYBRID-S" driver built by DBCstm.

// Your mileage may vary.

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

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

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

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

#define ADC_25          141 // the ADC value for 25% full (3.5V resting)

#define ADC_0           118 // the ADC value for 0% full (3.0V resting)

#define ADC_LOW         109 // When do we start ramping down (2.8V)

#define ADC_CRIT        104 // When do we shut the light off (2.7V)

// These values were copied from s7.c.

// Your mileage may vary.

//#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.5V resting)

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

//#define ADC_LOW         123 // When do we start ramping down (2.8V)

//#define ADC_CRIT        113 // When do we shut the light off (2.7V)

// Values for testing only:

//#define ADC_LOW         125 // When do we start ramping down (2.8V)

//#define ADC_CRIT        124 // When do we shut the light off (2.7V)

 

// the BLF EE A6 driver may have different offtime cap values than most other drivers

#ifdef OFFTIM3

#define CAP_SHORT           250  // Value between 1 and 255 corresponding with cap voltage (0 - 1.1v) where we consider it a short press to move to the next mode

#define CAP_MED             190  // Value between 1 and 255 corresponding with cap voltage (0 - 1.1v) where we consider it a short press to move to the next mode

#else

#define CAP_SHORT           190  // Value between 1 and 255 corresponding with cap voltage (0 - 1.1v) where we consider it a short press to move to the next mode

                                 // Not sure the lowest you can go before getting bad readings, but with a value of 70 and a 1uF cap, it seemed to switch sometimes

                                 // even when waiting 10 seconds between presses.

#endif

 

#define TURBO     255       // Convenience code for turbo mode

#define STROBE    254       // Convenience code for strobe mode

#define BATTCHECK 253       // Convenience code for battery check mode

#ifdef OWN_DELAY

#include <util/delay_basic.h>

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

void _delay_ms(uint16_t n)

{

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

    // for more precise timing?

    while(n-- > 0) _delay_loop_2(DELAY_TWEAK);

}

void _delay_s()  // because it saves a bit of ROM space to do it this way

{

    _delay_ms(1000);

}

#else

#include <util/delay.h>

#endif

#define STAR2_PIN   PB0     // But note that there is no star 2.

#define STAR3_PIN   PB4

#define CAP_PIN     PB3

#define CAP_CHANNEL 0x03    // MUX 03 corresponds with PB3 (Star 4)

#define CAP_DIDR    ADC3D   // Digital input disable bit corresponding with PB3

#define PWM_PIN     PB1

#define ALT_PWM_PIN PB0

#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

#define ALT_PWM_LVL OCR0A   // OCR0A is the output compare register for PB0

uint8_t fast_presses = 0;  // counter for entering config mode

PROGMEM const uint8_t modes1x1[] = { MODES1x1, HIDDENMODES };

PROGMEM const uint8_t modes1x2[] = { MODES1x2, HIDDENMODES };

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%

};

 

    uint8_t oldpos=eepos;

    uint16_t eep;

    eepos=(eepos+2)&63;  // wear leveling, use next cell

    eep = mode_idx | (fast_presses << 12) | (modegroup << 8);

    eep = mode_idx | (fast_presses << 12) | (modegroup << 8) | (memory << 9);

    eeprom_write_word((uint16_t *)(eepos), eep);      // save current state

    eeprom_write_word((uint16_t *)(oldpos), 0xffff);  // erase old state

    // two 8-bit reads use less ROM space than a single 16-bit write

    uint8_t eep1;

    uint8_t eep2;

    for(eepos=0; eepos<64; eepos+=2) {

        eep1 = eeprom_read_byte((const uint8_t *)eepos);

        eep2 = eeprom_read_byte((const uint8_t *)eepos+1);

        if (eep1 != 0xff) break;

    if (eepos < 64) {

        mode_idx = eep1;

        fast_presses = (eep2 >> 4);

        modegroup = eep2 & 1;

        memory = (eep2 >> 1) & 1;

    //else eepos=0;  // unnecessary, save_state handles wrap-around

#ifdef VOLTAGE_MON

inline void ADC_on() {

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

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

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

}

#else

inline void ADC_off() {

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

}

#endif

 

void set_mode(mode) {

#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;

}

#endif

 

        set_output(0,20);

        _delay_ms(100);

        _delay_ms(400);

    ADMUX  = (1 << REFS0) | (1 << ADLAR) | CAP_CHANNEL; // 1.1v reference, left-adjust, ADC3/PB3

        if (fast_presses < 15) fast_presses ++;

        fast_presses = 0;

        if (fast_presses == 0x0f) {  // Config mode

            modegroup ^= 1;

            save_state();

            blink(2);

            modegroup ^= 1;

 

            _delay_s();

            memory ^= 1;

            save_state();

            blink(2);

            memory ^= 1;

 

            save_state();

            // 10Hz tactical strobe

            set_output(255,255);

            _delay_ms(50);

            set_output(0,0);

            _delay_ms(50);

        }

            uint8_t blinks = 0;

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

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

            set_output(0,0);

            _delay_s();

            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

            blink(blinks);

            _delay_s();  // wait at least 1 second between readouts

            if (ticks < 255) ticks++;

            if (fast_presses) {

                fast_presses = 0;

                save_state();

            }