Saved Diffs

Diff history

Diff history is cleared on refresh
Tools
-90 Removals
+134 Additions
/* STAR_momentary version 1.6/* MTN_momentary_temp version 1.0
* *
* Changelog * Changelog
* *
* 1.0 Initial version * 1.0 First stab at this based on STAR_momentary v1.6
* 1.1 Added ability for star 2 to change mode order
* 1.2 Fix for newer version of AVR Studio
* 1.3 Added support for dual PWM outputs and selection of PWM mode per output level
* 1.4 Added ability to switch to a momentary mode
* 1.5 Added ability to set mode to 0 but not have it turn off
* 1.6 Added ability to debounce the press
* *
*/ */
/*/*
* NANJG 105C Diagram * NANJG 105C Diagram
* --- * ---
* -| |- VCC * -| |- VCC
* Star 4 -| |- Voltage ADC * Star 4 -| |- Voltage ADC
* Star 3 -| |- PWM * Star 3 -| |- PWM
* GND -| |- Star 2 * GND -| |- Star 2
* --- * ---
* *
* FUSES * FUSES
* I use these fuse settings * I use these fuse settings
* Low: 0x75 (4.8MHz CPU without 8x divider, 9.4kHz phase-correct PWM or 18.75kHz fast-PWM) * Low: 0x75 (4.8MHz CPU without 8x divider, 9.4kHz phase-correct PWM or 18.75kHz fast-PWM)
* High: 0xff * High: 0xff
* *
* For more details on these settings, visit http://github.com/JCapSolutions/blf-firmware/wiki/PWM-Frequency * For more details on these settings, visit http://github.com/JCapSolutions/blf-firmware/wiki/PWM-Frequency
* *
* STARS * STARS
* Star 2 = Not used * Star 2 = Alt PWM output
* Star 3 = H-L if connected, L-H if not * Star 3 = Charger on? input
* Star 4 = Switch input * Star 4 = Switch input
* *
* VOLTAGE * VOLTAGE
* Resistor values for voltage divider (reference BLF-VLD README for more info) * Resistor values for voltage divider (reference BLF-VLD README for more info)
* Reference voltage can be anywhere from 1.0 to 1.2, so this cannot be all that accurate * Reference voltage can be anywhere from 1.0 to 1.2, so this cannot be all that accurate
* *
* VCC * VCC
* | * |
* Vd (~.25 v drop from protection diode) * Vd (~.25 v drop from protection diode)
* | * |
* 1912 (R1 19,100 ohms) * 1912 (R1 19,100 ohms)
* | * |
* |---- PB2 from MCU * |---- PB2 from MCU
* | * |
* 4701 (R2 4,700 ohms) * 4701 (R2 4,700 ohms)
* | * |
* GND * GND
* *
* ADC = ((V_bat - V_diode) * R2 * 255) / ((R1 + R2 ) * V_ref) * ADC = ((V_bat - V_diode) * R2 * 255) / ((R1 + R2 ) * V_ref)
* 125 = ((3.0 - .25 ) * 4700 * 255) / ((19100 + 4700) * 1.1 ) * 125 = ((3.0 - .25 ) * 4700 * 255) / ((19100 + 4700) * 1.1 )
* 121 = ((2.9 - .25 ) * 4700 * 255) / ((19100 + 4700) * 1.1 ) * 121 = ((2.9 - .25 ) * 4700 * 255) / ((19100 + 4700) * 1.1 )
* *
* Well 125 and 121 were too close, so it shut off right after lowering to low mode, so I went with * Well 125 and 121 were too close, so it shut off right after lowering to low mode, so I went with
* 130 and 120 * 130 and 120
* *
* To find out what value to use, plug in the target voltage (V) to this equation * To find out what value to use, plug in the target voltage (V) to this equation
* value = (V * 4700 * 255) / (23800 * 1.1) * value = (V * 4700 * 255) / (23800 * 1.1)
* *
*/ */
#define F_CPU 4800000UL#define F_CPU 4800000UL
// PWM Mode// PWM Mode
#define PHASE 0b00000001#define PHASE 0b00000001
#define FAST 0b00000011#define FAST 0b00000011
/*/*
* ========================================================================= * =========================================================================
* Settings to modify per driver * Settings to modify per driver
*/ */
#define VOLTAGE_MON // Comment out to disable - ramp down and eventual shutoff when battery is low//#define VOLTAGE_MON // Comment out to disable - ramp down and eventual shutoff when battery is low
#define MODES 0,3,14,39,125,255 // Must be low to high, and must start with 0#define CHARGER_MON // Comment out to disable - is charging cable connected
#define ALT_MODES 0,3,14,39,125,255 // Must be low to high, and must start with 0, the defines the level for the secondary output. Comment out if no secondary output#define MODES 0,3,32,125,255 // Must be low to high, and must start with 0
#define MODE_PWM 0,PHASE,FAST,FAST,FAST,PHASE // Define one per mode above. 0 tells the light to go to sleep//#define ALT_MODES 0,3,32,125,255 // Must be low to high, and must start with 0, the defines the level for the secondary output. Comment out if no secondary output
#define TURBO // Comment out to disable - full output with a step down after n number of seconds#define MODE_PWM 0,PHASE,FAST,FAST,FAST // Define one per mode above. 0 tells the light to go to sleep
//#define TURBO // Comment out to disable - full output with a step down after n number of seconds
// If turbo is enabled, it will be where 255 is listed in the modes above // If turbo is enabled, it will be where 255 is listed in the modes above
#define TURBO_TIMEOUT 5625 // How many WTD ticks before before dropping down (.016 sec each)//#define TURBO_TIMEOUT 5625 // How many WTD ticks before before dropping down (.016 sec each)
// 90 = 5625 // 90 = 5625
// 120 = 7500 // 120 = 7500
#define ADC_LOW 130 // When do we start ramping#define BATT_LOW 145 // When do we start ramping
#define ADC_CRIT 120 // When do we shut the light off#define BATT_CRIT 135 // When do we shut the light off
#define ADC_DELAY 188 // Delay in ticks between low-bat rampdowns (188 ~= 3s)#define CHARGER_HIGH 120 // When we should lower the output
#define CHARGER_LOW 100 // When we should raise the output
#define BATT_ADC_DELAY 188 // Delay in ticks between low-bat rampdowns (188 ~= 3s)
#define CHARGER_ADC_DELAY 15 // Delay in ticks before checking for charging cable (188 ~= 3s)
//#define MOM_ENTER_DUR 128 // .16ms each. Comment out to disable this feature//#define MOM_ENTER_DUR 128 // 16ms each. Comment out to disable this feature
#define MOM_EXIT_DUR 128 // .16ms each//#define MOM_EXIT_DUR 128 // 16ms each
#define MOM_MODE_IDX 4 // The index of the mode to use in MODES above if momementary feature enabled, starting at index of 0//#define MOM_MODE_IDX 4 // The index of the mode to use in MODES above, starting at index of 0
/*/*
* ========================================================================= * =========================================================================
*/ */
#include <avr/pgmspace.h>#include <avr/pgmspace.h>
#include <avr/io.h>#include <avr/io.h>
#include <util/delay.h>#include <util/delay.h>
#include <avr/interrupt.h>#include <avr/interrupt.h>
#include <avr/wdt.h> #include <avr/wdt.h>
#include <avr/eeprom.h>#include <avr/eeprom.h>
#include <avr/sleep.h>#include <avr/sleep.h>
//#include <avr/power.h>//#include <avr/power.h>
#define STAR3_PIN PB4 // If not connected, will cycle L-H. Connected, H-L
#define SWITCH_PIN PB3 // what pin the switch is connected to, which is Star 4#define SWITCH_PIN PB3 // what pin the switch is connected to, which is Star 4
#define PWM_PIN PB1#define PWM_PIN PB1
#define ALT_PWM_PIN PB0#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_DIDR ADC1D // Digital input disable bit corresponding with PB2
#define ADC_PRSCL 0x06 // clk/64#define ADC_PRSCL 0x06 // clk/64
#define PWM_LVL OCR0B // OCR0B is the output compare register for PB1#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#define ALT_PWM_LVL OCR0A // OCR0A is the output compare register for PB0
//#define DEBOUNCE_BOTH // Comment out if you don't want to debounce the PRESS along with the RELEASE//#define DEBOUNCE_BOTH // Comment out if you don't want to debounce the PRESS along with the RELEASE
// PRESS debounce is only needed in special cases where the switch can experience errant signals // PRESS debounce is only needed in special cases where the switch can experience errant signals
#define DB_PRES_DUR 0b00000001 // time before we consider the switch pressed (after first realizing it was pressed)#define DB_PRES_DUR 0b00000001 // time before we consider the switch pressed (after first realizing it was pressed)
#define DB_REL_DUR 0b00001111 // time before we consider the switch released#define DB_REL_DUR 0b00001111 // time before we consider the switch released
// each bit of 1 from the right equals 16ms, so 0x0f = 64ms // each bit of 1 from the right equals 16ms, so 0x0f = 64ms
// Switch handling// Switch handling
#define LONG_PRESS_DUR 32 // How many WDT ticks until we consider a press a long press#define LONG_PRESS_DUR 32 // How many WDT ticks until we consider a press a long press
// 32 is roughly .5 s // 32 is roughly .5 s
#define BEACON
#define BEACON_DUR 70 // How many WDT ticks until we enter the hold-to-BEACON mode
/*/*
* The actual program * The actual program
* ========================================================================= * =========================================================================
*/ */
/*/*
* global variables * global variables
*/ */
const uint8_t modes[] = { MODES };const uint8_t modes[] = { MODES };
#ifdef ALT_MODES#ifdef ALT_MODES
const uint8_t alt_modes[] = { ALT_MODES };const uint8_t alt_modes[] = { ALT_MODES };
#endif#endif
const uint8_t mode_pwm[] = { MODE_PWM };const uint8_t mode_pwm[] = { MODE_PWM };
volatile uint8_t mode_idx = 0;volatile uint8_t mode_idx = 0;
volatile uint8_t press_duration = 0;volatile uint8_t press_duration = 0;
volatile uint8_t low_to_high = 0;
volatile uint8_t in_momentary = 0;volatile uint8_t in_momentary = 0;
#ifdef VOLTAGE_MON
volatile uint8_t adc_channel = 1; // MUX 01 corresponds with PB2, 02 for PB4. Will switch back and forth
#else
volatile uint8_t adc_channel = 2; // MUX 01 corresponds with PB2, 02 for PB4. Will switch back and forth
#endif
// Debounce switch press value// Debounce switch press value
#ifdef DEBOUNCE_BOTH#ifdef DEBOUNCE_BOTH
int is_pressed()int is_pressed()
{{
static uint8_t pressed = 0; static uint8_t pressed = 0;
// Keep track of last switch values polled // Keep track of last switch values polled
static uint8_t buffer = 0x00; static uint8_t buffer = 0x00;
// Shift over and tack on the latest value, 0 being low for pressed, 1 for pulled-up for released // Shift over and tack on the latest value, 0 being low for pressed, 1 for pulled-up for released
buffer = (buffer << 1) | ((PINB & (1 << SWITCH_PIN)) == 0); buffer = (buffer << 1) | ((PINB & (1 << SWITCH_PIN)) == 0);
if (pressed) { if (pressed) {
// Need to look for a release indicator by seeing if the last switch status has been 0 for n number of polls // Need to look for a release indicator by seeing if the last switch status has been 0 for n number of polls
pressed = (buffer & DB_REL_DUR); pressed = (buffer & DB_REL_DUR);
} else { } else {
// Need to look for pressed indicator by seeing if the last switch status was 1 for n number of polls // Need to look for pressed indicator by seeing if the last switch status was 1 for n number of polls
pressed = ((buffer & DB_PRES_DUR) == DB_PRES_DUR); pressed = ((buffer & DB_PRES_DUR) == DB_PRES_DUR);
} }
return pressed; return pressed;
}}
#else#else
int is_pressed()int is_pressed()
{{
// Keep track of last switch values polled // Keep track of last switch values polled
static uint8_t buffer = 0x00; static uint8_t buffer = 0x00;
// Shift over and tack on the latest value, 0 being low for pressed, 1 for pulled-up for released // Shift over and tack on the latest value, 0 being low for pressed, 1 for pulled-up for released
buffer = (buffer << 1) | ((PINB & (1 << SWITCH_PIN)) == 0); buffer = (buffer << 1) | ((PINB & (1 << SWITCH_PIN)) == 0);
return (buffer & DB_REL_DUR); return (buffer & DB_REL_DUR);
}}
#endif#endif
inline void next_mode() {void next_mode() {
if (++mode_idx >= sizeof(modes)) { if (++mode_idx >= sizeof(modes)) {
// Wrap around // Wrap around
mode_idx = 0; mode_idx = 1;
} }
}}
inline void prev_mode() {void prev_mode() {
if (mode_idx == 0) { if (mode_idx == 1) {
// Wrap around // Wrap around
mode_idx = sizeof(modes) - 1; mode_idx = sizeof(modes) - 1;
} else { } else {
--mode_idx; --mode_idx;
} }
}}
inline void PCINT_on() {inline void PCINT_on() {
// Enable pin change interrupts // Enable pin change interrupts
GIMSK |= (1 << PCIE); GIMSK |= (1 << PCIE);
}}
inline void PCINT_off() {inline void PCINT_off() {
// Disable pin change interrupts // Disable pin change interrupts
GIMSK &= ~(1 << PCIE); GIMSK &= ~(1 << PCIE);
}}
// Need an interrupt for when pin change is enabled to ONLY wake us from sleep.// Need an interrupt for when pin change is enabled to ONLY wake us from sleep.
// All logic of what to do when we wake up will be handled in the main loop.// All logic of what to do when we wake up will be handled in the main loop.
EMPTY_INTERRUPT(PCINT0_vect);EMPTY_INTERRUPT(PCINT0_vect);
inline void WDT_on() {inline void WDT_on() {
// Setup watchdog timer to only interrupt, not reset, every 16ms. // Setup watchdog timer to only interrupt, not reset, every 16ms.
cli(); // Disable interrupts cli(); // Disable interrupts
wdt_reset(); // Reset the WDT wdt_reset(); // Reset the WDT
WDTCR |= (1<<WDCE) | (1<<WDE); // Start timed sequence WDTCR |= (1<<WDCE) | (1<<WDE); // Start timed sequence
WDTCR = (1<<WDTIE); // Enable interrupt every 16ms WDTCR = (1<<WDTIE); // Enable interrupt every 16ms
sei(); // Enable interrupts sei(); // Enable interrupts
}}
inline void WDT_off()inline void WDT_off()
{{
cli(); // Disable interrupts cli(); // Disable interrupts
wdt_reset(); // Reset the WDT wdt_reset(); // Reset the WDT
MCUSR &= ~(1<<WDRF); // Clear Watchdog reset flag MCUSR &= ~(1<<WDRF); // Clear Watchdog reset flag
WDTCR |= (1<<WDCE) | (1<<WDE); // Start timed sequence WDTCR |= (1<<WDCE) | (1<<WDE); // Start timed sequence
WDTCR = 0x00; // Disable WDT WDTCR = 0x00; // Disable WDT
sei(); // Enable interrupts sei(); // Enable interrupts
}}
inline void ADC_on() {void ADC_on() {
ADMUX = (1 << REFS0) | (1 << ADLAR) | ADC_CHANNEL; // 1.1v reference, left-adjust, ADC1/PB2 ADMUX = (1 << REFS0) | (1 << ADLAR) | adc_channel; // 1.1v reference, left-adjust, ADC1/PB2 or ADC2/PB3
DIDR0 |= (1 << ADC_DIDR); // disable digital input on ADC pin to reduce power consumption DIDR0 |= (1 << ADC_DIDR); // disable digital input on ADC pin to reduce power consumption
ADCSRA = (1 << ADEN ) | (1 << ADSC ) | ADC_PRSCL; // enable, start, prescale ADCSRA = (1 << ADEN ) | (1 << ADSC ) | ADC_PRSCL; // enable, start, prescale, Single Conversion mode
}}
inline void ADC_off() {void ADC_off() {
ADCSRA &= ~(1<<7); //ADC off ADCSRA &= ~(1 << ADSC); //ADC off
}}
void sleep_until_switch_press()void sleep_until_switch_press()
{{
// This routine takes up a lot of program memory :( // This routine takes up a lot of program memory :(
// Turn the WDT off so it doesn't wake us from sleep // Turn the WDT off so it doesn't wake us from sleep
// Will also ensure interrupts are on or we will never wake up // Will also ensure interrupts are on or we will never wake up
WDT_off(); WDT_off();
// Need to reset press duration since a button release wasn't recorded // Need to reset press duration since a button release wasn't recorded
press_duration = 0; press_duration = 0;
// Enable a pin change interrupt to wake us up // Enable a pin change interrupt to wake us up
// However, we have to make sure the switch is released otherwise we will wake when the user releases the switch // However, we have to make sure the switch is released otherwise we will wake when the user releases the switch
while (is_pressed()) { while (is_pressed()) {
_delay_ms(16); _delay_ms(16);
} }
PCINT_on(); PCINT_on();
// Enable sleep mode set to Power Down that will be triggered by the sleep_mode() command. // Enable sleep mode set to Power Down that will be triggered by the sleep_mode() command.
//set_sleep_mode(SLEEP_MODE_PWR_DOWN); //set_sleep_mode(SLEEP_MODE_PWR_DOWN);
// Now go to sleep // Now go to sleep
sleep_mode(); sleep_mode();
// Hey, someone must have pressed the switch!! // Hey, someone must have pressed the switch!!
// Disable pin change interrupt because it's only used to wake us up // Disable pin change interrupt because it's only used to wake us up
PCINT_off(); PCINT_off();
// Turn the WDT back on to check for switch presses // Turn the WDT back on to check for switch presses
WDT_on(); WDT_on();
// Go back to main program // Go back to main program
}}
// The watchdog timer is called every 16ms// The watchdog timer is called every 16ms
ISR(WDT_vect) {ISR(WDT_vect) {
//static uint8_t press_duration = 0; // Pressed or not pressed //static uint8_t press_duration = 0; // Pressed or not pressed
static uint16_t turbo_ticks = 0; static uint16_t turbo_ticks = 0;
static uint8_t adc_ticks = ADC_DELAY; static uint16_t batt_adc_ticks = BATT_ADC_DELAY;
static uint16_t charger_adc_ticks = CHARGER_ADC_DELAY;
static uint8_t lowbatt_cnt = 0; static uint8_t lowbatt_cnt = 0;
static uint8_t high_charger_cnt = 0;
static uint8_t low_charger_cnt = 0;
static uint8_t highest_mode_idx = 255;
if (is_pressed()) { if (is_pressed()) {
if (press_duration < 255) { if (press_duration < 255) {
press_duration++; press_duration++;
} }
#ifdef MOM_ENTER_DUR #ifdef MOM_ENTER_DUR
if (in_momentary) { if (in_momentary) {
// Turn on full output // Turn on full output
mode_idx = MOM_MODE_IDX; mode_idx = MOM_MODE_IDX;
if (press_duration == MOM_EXIT_DUR) { if (press_duration == MOM_EXIT_DUR) {
// Turn light off and disable momentary // Turn light off and disable momentary
mode_idx = 0; mode_idx = 0;
in_momentary = 0; in_momentary = 0;
} }
return; return;
} }
#endif #endif
if (press_duration == LONG_PRESS_DUR) { if (press_duration == LONG_PRESS_DUR) {
// Long press // Long press
if (low_to_high) {
prev_mode(); prev_mode();
} else { highest_mode_idx = mode_idx;
next_mode();
}
} }
#ifdef BEACON //Is BEACON turned on
if (press_duration == BEACON_DUR) {
PWM_LVL = 0;
while(is_pressed()){
//Exit loop once switch is let go
PWM_LVL = 255;
_delay_ms(500);
PWM_LVL=0;
_delay_ms(5000);
//Can alter values to change BEACON duration
}
}
#endif
#ifdef MOM_ENTER_DUR #ifdef MOM_ENTER_DUR
if (press_duration == MOM_ENTER_DUR) { if (press_duration == MOM_ENTER_DUR) {
in_momentary = 1; in_momentary = 1;
press_duration = 0; press_duration = 0;
} }
#endif #endif
// Just always reset turbo timer whenever the button is pressed // Just always reset turbo timer whenever the button is pressed
turbo_ticks = 0; turbo_ticks = 0;
// Same with the ramp down delay // Same with the ramp down delay
adc_ticks = ADC_DELAY; batt_adc_ticks = BATT_ADC_DELAY;
charger_adc_ticks = CHARGER_ADC_DELAY;
} else { } else {
#ifdef MOM_ENTER_DUR #ifdef MOM_ENTER_DUR
if (in_momentary) { if (in_momentary) {
// Turn off the light // Turn off the light
mode_idx = 0; mode_idx = 0;
return; return;
} }
#endif #endif
// Not pressed // Not pressed
if (press_duration > 0 && press_duration < LONG_PRESS_DUR) { if (press_duration > 0 && press_duration < LONG_PRESS_DUR) {
// Short press // Short press
if (low_to_high) {
next_mode(); next_mode();
} else { highest_mode_idx = mode_idx;
prev_mode();
}
} else { } else {
// Only do turbo check when switch isn't pressed // Only do turbo check when switch isn't pressed
#ifdef TURBO #ifdef TURBO
if (modes[mode_idx] == 255) { if (modes[mode_idx] == 255) {
turbo_ticks++; turbo_ticks++;
if (turbo_ticks > TURBO_TIMEOUT) { if (turbo_ticks > TURBO_TIMEOUT) {
// Go to the previous mode // Go to the previous mode
prev_mode(); prev_mode();
} }
} }
#endif #endif
// Only do voltage monitoring when the switch isn't pressed // Only do voltage monitoring when the switch isn't pressed
#ifdef VOLTAGE_MON // See if conversion is done. We moved this up here because we want to stay on
if (adc_ticks > 0) { // the current ADC input until the conversion is done, and then switch to the new
--adc_ticks; // input, start the monitoring
if (batt_adc_ticks > 0) {
--batt_adc_ticks;
} }
if (adc_ticks == 0) { if (charger_adc_ticks > 0) {
// See if conversion is done --charger_adc_ticks;
if (ADCSRA & (1 << ADIF)) { }
// See if voltage is lower than what we were looking for if (ADCSRA & (1 << ADIF)) {
if (ADCH < ((mode_idx == 1) ? ADC_CRIT : ADC_LOW)) { if (adc_channel == 0x01) {
++lowbatt_cnt;
} else { if (batt_adc_ticks == 0) {
lowbatt_cnt = 0; // See if voltage is lower than what we were looking for
if (ADCH < ((mode_idx == 1) ? BATT_CRIT : BATT_LOW)) {
++lowbatt_cnt;
} else {
lowbatt_cnt = 0;
}
// See if it's been low for a while
if (lowbatt_cnt >= 4) {
prev_mode();
highest_mode_idx = mode_idx;
lowbatt_cnt = 0;
// If we reach 0 here, main loop will go into sleep mode
// Restart the counter to when we step down again
batt_adc_ticks = BATT_ADC_DELAY;
charger_adc_ticks = CHARGER_ADC_DELAY;
}
} }
} // Switch ADC to temp monitoring
adc_channel = 0x02;
ADMUX = ((ADMUX & 0b11111100) | adc_channel);
} else if (adc_channel == 0x02) {
if (charger_adc_ticks == 0) {
// See if temp is higher than the high threshold
if (ADCH > ((mode_idx == 1) ? 255 : CHARGER_HIGH)) {
++high_charger_cnt;
// See if it's lower that the low threshold, but not at or above the batt-adjusted mode
} else {
high_charger_cnt = 0;
low_charger_cnt = 0;
}
// See if it's been low for a while // See if it's been low for a while
if (lowbatt_cnt >= 4) { if (high_charger_cnt >= 1) {
prev_mode(); // TODO - step down half
lowbatt_cnt = 0; mode_idx = 0;
// If we reach 0 here, main loop will go into sleep mode high_charger_cnt = 0;
// Restart the counter to when we step down again low_charger_cnt = 0;
adc_ticks = ADC_DELAY; // If we reach 0 here, main loop will go into sleep mode
// Restart the counter to when we step down again
charger_adc_ticks = CHARGER_ADC_DELAY;
} else {
// TODO - step up half
mode_idx;
high_charger_cnt = 0;
low_charger_cnt = 0;
// TODO - CHARGER_ADC_DELAY?? Might jump up and cause it to overheat waiting too long
charger_adc_ticks = CHARGER_ADC_DELAY;
}
}
#ifdef VOLTAGE_MON
// Switch ADC to battery monitoring
adc_channel = 0x01;
ADMUX = ((ADMUX & 0b11111100) | adc_channel);
#endif;
} }
// Make sure conversion is running for next time through
ADCSRA |= (1 << ADSC);
} }
#endif // Start conversion for next time through
ADCSRA |= (1 << ADSC);
} }
press_duration = 0; press_duration = 0;
} }
}}
int main(void)int main(void)
{ {
// Set all ports to input, and turn pull-up resistors on for the inputs we are using // Set all ports to input, and turn pull-up resistors on for the inputs we are using
DDRB = 0x00; DDRB = 0x00;
PORTB = (1 << SWITCH_PIN) | (1 << STAR3_PIN); PORTB = (1 << SWITCH_PIN);
// Set the switch as an interrupt for when we turn pin change interrupts on // Set the switch as an interrupt for when we turn pin change interrupts on
PCMSK = (1 << SWITCH_PIN); PCMSK = (1 << SWITCH_PIN);
// Set PWM pin to output // Set PWM pin to output
#ifdef ALT_MODES #ifdef ALT_MODES
DDRB = (1 << PWM_PIN) | (1 << ALT_PWM_PIN); DDRB = (1 << PWM_PIN) | (1 << ALT_PWM_PIN);
#else #else
DDRB = (1 << PWM_PIN); DDRB = (1 << PWM_PIN);
#endif #endif
// Set timer to do PWM for correct output pin and set prescaler timing // 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 //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...) TCCR0B = 0x01; // pre-scaler for timer (1 => 1, 2 => 8, 3 => 64...)
// Turn features on or off as needed // Turn features on or off as needed
#ifdef VOLTAGE_MON
ADC_on(); ADC_on();
#else
ADC_off();
#endif
ACSR |= (1<<7); //AC off ACSR |= (1<<7); //AC off
// Determine if we are going L-H, or H-L based on Star 3
if ((PINB & (1 << STAR3_PIN)) == 0) {
// High to Low
low_to_high = 0;
} else {
low_to_high = 1;
}
// Enable sleep mode set to Power Down that will be triggered by the sleep_mode() command. // Enable sleep mode set to Power Down that will be triggered by the sleep_mode() command.
set_sleep_mode(SLEEP_MODE_PWR_DOWN); set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_until_switch_press(); sleep_until_switch_press();
uint8_t last_mode_idx = 0; uint8_t last_mode_idx = 0;
while(1) { while(1) {
// We will never leave this loop. The WDT will interrupt to check for switch presses and // We will never leave this loop. The WDT will interrupt to check for switch presses and
// will change the mode if needed. If this loop detects that the mode has changed, run the // will change the mode if needed. If this loop detects that the mode has changed, run the
// logic for that mode while continuing to check for a mode change. // logic for that mode while continuing to check for a mode change.
if (mode_idx != last_mode_idx) { if (mode_idx != last_mode_idx) {
// The WDT changed the mode. // The WDT changed the mode.
if (mode_idx > 0) { if (mode_idx > 0) {
// No need to change the mode if we are just turning the light off // No need to change the mode if we are just turning the light off
// Check if the PWM mode is different // Check if the PWM mode is different
if (mode_pwm[last_mode_idx] != mode_pwm[mode_idx]) { if (mode_pwm[last_mode_idx] != mode_pwm[mode_idx]) {
#ifdef ALT_MODES #ifdef ALT_MODES
TCCR0A = mode_pwm[mode_idx] | 0b10100000; // Use both outputs TCCR0A = mode_pwm[mode_idx] | 0b10100000; // Use both outputs
#else #else
TCCR0A = mode_pwm[mode_idx] | 0b00100000; // Only use the normal output TCCR0A = mode_pwm[mode_idx] | 0b00100000; // Only use the normal output
#endif #endif
} }
} }
PWM_LVL = modes[mode_idx]; PWM_LVL = modes[mode_idx];
#ifdef ALT_MODES #ifdef ALT_MODES
ALT_PWM_LVL = alt_modes[mode_idx]; ALT_PWM_LVL = alt_modes[mode_idx];
#endif #endif
last_mode_idx = mode_idx; last_mode_idx = mode_idx;
if (mode_pwm[mode_idx] == 0) { if (mode_pwm[mode_idx] == 0) {
_delay_ms(1); // Need this here, maybe instructions for PWM output not getting executed before shutdown? _delay_ms(1); // Need this here, maybe instructions for PWM output not getting executed before shutdown?
// Go to sleep // Go to sleep
sleep_until_switch_press(); sleep_until_switch_press();
} }
} }
} }
return 0; // Standard Return Code return 0; // Standard Return Code
}}
Editor
Clear
Export as PDF
Original Text
Changed Text