/*
* moui_v2_menu.c
*
* Created: 21.04.2014 12:42:34
* Author: fritz
*/
/*
* License: Free for private, non commercial use
*
* use Fuses:
* low 0x75
* high 0xFF
* Compiler optimization set to '-Os' (optimize for size)
* 1016 Bytes used
*
* Some comments:
*
* The UI is similar to the one from NovaTac lights (with some additional features)
*
* click (c): pressing the switch for not more than 'presstime' * 5ms (default 250ms)
* press (p): pressing the switch for more than 'presstime' * ms (default 250ms)
* ('presstime' defined below)
*
* This UI features a BURST mode and the light will dim from 'BURST' to 'mode4' after 'BURSTtime' * 1.28 seconds
* (Only if constant ON BURST, at momentary ON BURST the light will not dim down.)
* If you do not want a BURST mode just set 'BURST' the same as 'mode4'
*
*
* UI description:
* From OFF:
* 'click' switches the light on to 'mode1'
* With a 'press' you get momentary 'mode1'
* With 'click' and 'press' you get momentary 'BURST'
*
* When ON:
* You can toggle between 'mode1' and mode2' with 'click''click'
* With 'click''click''click' you get to 'mode3'
* From 'mode3' you get back to 'mode1' with 'click''click'
*
* From any mode you reach momentary 'BURST' with 'press'. As soon as you release the switch you get back to your last mode.
*
* You reach constand on 'BURST' with 'click''press' from any mode
* You get back to 'mode1' with 'click''click'
*
*
*
* To do:
*
* (0) Bugfixes
* Done! (more or less...)
*
* While my usage there did not occour any bugs, so please tell me, if you find some.
*
* (1) Set Attiny to sleep mode, when light was turned of for more than 250ms
* Done! Consumes when switched OFF from .2 to 6 µA (depends on locator flash ON or OFF)
*
* I added a locator flash. It flashes every 8 seconds for .01 second at brightness 'locator' (default 5)
* calculate time until battery is empty (draintime in years):
* first calculate
* drain current drc:
*
* WDTint = Watchdog Interrupt time (8 sec by default)
* BattAmp = maximal BATTERY Current
*
* drc = [WDTint * 6 * 10^-6 + 0.01 * BattAmp * locator/255]/8.01
*
* BattC = Battery Capacity in Ah
*
* draintime = BattC/(drc * 24 * 365)
*
* Example: 2.8A driver, 18650 Battery with 3Ah Capacity, locator = 5
* drc = 0.000075A
* draintime > 4 years
*
* If you do NOT want a locator flash you can disable it in the programming menu
* See the point "programming menu" below.
* When the locator flash is disabled an 18650 battery lasts for more than 500 years...
*
* (2) Implement programming menu
* Done!
*
* You can change the brightness of any mode by switching to the mode and then 'click', 'click', 'click' and 'press'.
* After you release the switch you can ramp up by a single 'click' and save your selected brightness by a single 'press'
*
* Example:
* (c) --> Mode1 (c)(c)(c)(p) --> programming menu for Mode1
* (c)(c)(c)(c)(c)(c) (6 clicks) --> 7 of 255 selected (p) --> Mode1 is from now on 7 until the next Battery change.
* Light goes back to Mode1
*
* By clicking the light 8 or more times you get to the programming menu.
* Here you can switch the locator flash ON/ OFF, enable or disable mode memory and store your programmed modes in the
* EEPROM so that they do not get deleted after a battery change.
*
* Once you entered the programming menu you can select what you want to do by clicking (1) to (3) times and then select the option by a single press.
* After you pressed the switch the light will flash 1 to 3 times to indicate, which option is/ was selected.
*
* (1) Toggle locator flash ON or OFF (the light will flash once)
* (2) Toggle mode memory ON or OFF (the light will flash twice)
* (3) Save your programmed modes so that they are not deleted after a battery change (the light will flash three times)
*
* If you click more than three times you leave the programming menu
*
*
*
* The following data has to be stored in the EEPROM:
*
* reg0: 5 = 0x05 <-- brightness for 'mode1'
* reg1: 20 = 0x14 <-- brigthness for 'mode2'
* reg2: 90 = 0x5A <-- brightness for 'mode3'
* reg3: 165 = 0xA5 <-- brightness for 'mode4'
* reg4: 255 = 0xFF <-- brightness for 'BURST'
*
* reg5: 1 = 0x01 <-- Locatorflash default ON (0 for default OFF)
* reg6: 1 = 0x01 <-- Memory default OFF (0 for default ON)
*
* reg7: 1 = 0x01
* reg8: 2 = 0x02
* reg9: 3 = 0x03
* reg10: 4 = 0x04
* reg11: 5 = 0x05 <-- default 'mode1'
* reg12: 7 = 0x07
* reg13: 9 = 0x09
* reg14: 14 = 0x0E
* reg15: 20 = 0x14 <-- default 'mode2'
* reg16: 30 = 0x1E
* reg17: 45 = 0x2D
* reg18: 60 = 0x3C
* reg19: 75 = 0x4B
* reg20: 90 = 0x5A <-- default 'mode3'
* reg21: 105 = 0x69
* reg22: 125 = 0x7D
* reg23: 145 = 0x91
* reg24: 165 = 0xA5 <-- default 'mode4'
* reg25: 185 = 0xB9
* reg26: 205 = 0xCD
* reg27: 230 = 0xE6
* reg28: 255 = 0xFF
*
* you can create a .hex file with the following content:
:10000000051446A5FF0101010203040507090E14AA
:100010001E2D3C4B5A697D91A5B9CDE6FFFFFFFF30
:10002000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0
:10003000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD0
:00000001FF
*/
#include <avr/interrupt.h> // Include some headers...
#include <avr/sleep.h>
#include <avr/io.h>
#define F_CPU 4800000 // Prescaler is set
#include <util/delay.h>
#include <avr/wdt.h>
#define WDTflag 0 // Bit for Watchdog interrupt
#define PCINTflag 1 // Bit for Pin Change interrupt
/*
* 'OFFtime * 5ms' is the the time, which the light has to be turned ON or OFF to reset 'clicked'
* If you hold the switch for longer than 'presstime * 5ms' --> 'press', otherwise 'click'
* Both values can be changed (should be in [30, ..., 100])
* Default 250ms for both
*/
#define OFFtime 50
#define presstime 50
/*
* Set 'BURSTtime', here. If you do not want a Burst mode set 'BURST' to the same as 'mode4' (by writing different data in the hex file for the EEPROM or by programming the brightness)
*/
#define BURSTtime 11 // (BURSTtime + 1) * 1.28sec (default 15.4 seconds)
/*
* define 'locator' to your preferred brightness in [1, ..., 255]. 4 > is save for 7135 drivers
*/
#define locator 5
/*
* The address for mode1, -2, -3, -4 and BURST in the EEPROM are defined here. Do NOT change.
*/
#define mode1addr 0
#define mode2addr 1
#define mode3addr 2
#define mode4addr 3
#define BURSTaddr 4
uint8_t lastmode = 0; // Memorize the last mode
volatile uint8_t INTflag = 0; // watchdog flag for the locator flash
uint8_t modes[] = {0, 0, 0, 0, 0}; // Mode Array, do NOT change this
uint8_t click(); // Function declaration for click (tests if you click of press the switch)
void momentary(); // Function declaration for momentary
void wait_5ms(); // Name says it all...
void wait_ms(uint8_t time); // Wait for 'time' * 5ms.
void setmode(uint8_t mode); // Sets OCR0B to 'modes[mode]'
void bedtime(); // Sends ATtiny to sleep mode
void ramping(uint8_t mode); // Ramps up and sets new brightness to 'modes[]'
void blink(); // Blinks...
uint8_t EEPROM_read(uint8_t EEPROM_address); // EEPROM read
void EEPROM_write(uint8_t EEPROM_adress); // EEPROM write
void programming(); // Programming menu
void blinkblinkblink();
ISR(PCINT0_vect)
{
INTflag = (1 << PCINTflag); // Set 'INTflag' to 2 (Important for programming menu)
}
ISR(WDT_vect) // Watchdog Timer Interrupt (locatorflash)
{
INTflag = (1 << WDTflag); // Set 'INTflag' to 1
}
int main(void)
{
uint8_t time = 0; // Measure ON/ OFF time and some other things
uint8_t clicked = 0; // Count how many clicks have been made
uint8_t memory = 0; // Memorizes last mode for programming
uint8_t bursttimer = 0; // Used to count time to ramp down
uint8_t memory_ON_OFF = 0;
set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Use Power Down Sleep mode. Wakes up with Pin Change Interrupt or Watchdog Interrupt
DDRB = (1 << DDB1); // Define PB1 as output
PORTB = (1 << PINB3); // Define pull-up switch ON
GIMSK = (1 << PCIE); // Pin Change Interrupt Enable (switch is pressed --> interrupt)
PCMSK = (1 << PCINT3); // Enable Pin Change Interrupt at PINB3
TCCR0A = 0b00100001;
TCCR0B = 0b00000001; // PWM setup
/*
* Watchdog Interrupt interval
*
* WDP3 WDP2 WDP1 WDP0 timer ~seconds
* 0 1 0 1 512 mS .5
* 0 1 1 0 1024 mS 1
* 0 1 1 1 2048 mS 2
* 1 0 0 0 4096 mS 4
* 1 0 0 1 8192 mS 8
*/
WDTCR |= (1 << WDP3) | (1 << WDP0); // Set Watchdog prescaler to 8 sec
if ((EEPROM_read(5) & 1) == 1)
WDTCR |= (1 << WDTIE); // Enable Watchdog Interrupts if Locatorflash enabled...
modes[mode1addr] = EEPROM_read(mode1addr); // Mode, when light is switched ON
modes[mode2addr] = EEPROM_read(mode2addr); // Mode accessed with two clicks
modes[mode3addr] = EEPROM_read(mode3addr); // Mode accessed with three clicks
modes[mode4addr] = EEPROM_read(mode4addr); // Mode accessed when switch is hold while the light is ON
modes[BURSTaddr] = EEPROM_read(BURSTaddr); // Burst mode. The light will step down from 'BURST' to 'mode4' after 'BURSTtime' * 1.28sec
OCR0B = 0; // 'Switch on brightness' after getting getting power.
// Change if you want 'Power ON' (useful for lights with two switches)
while(1)
{
memory_ON_OFF = EEPROM_read(6);
if ((PINB & 8) == 0) // When the button is pressed (PINB3 pulled down)
{
if (OCR0B == 0) // When light was switched OFF
{
if (memory_ON_OFF == 1) // Mode memory switched OFF
OCR0B = modes[mode1addr]; // Set brightness to 'mode1', do not use setmode(mode1) otherwise it will not switch to 'mode2' after a 2 clicks
else
OCR0B = modes[memory];
clicked += click(); // Test if 'click' or 'press'
if (clicked == 0) // Press
momentary(); // --> momentary ON with 'mode1' (or 'memory' if memory enabled)
if (clicked == 1) // Light was switched OFF and button is pressed
{
if (memory_ON_OFF == 1) // Mode memory switched OFF
lastmode = mode1addr; // Set 'lastmode' to mode1 that it will switch to 'mode2' after 2 clicks
else
lastmode = memory; // Set 'lastmode' to 'memory' (so that it will switch to 'mode1' after two clicks)
if ((PINB & 8) == 0) // If switch is still pressed
{
setmode(BURSTaddr); // Set brightness to 'BURST'
momentary(); // But you have to release the switch sometime, therefore is momentary()
OCR0B = modes[BURSTaddr]; // momentary() sets brightness to 0 --> set it back to 'BURST'
}
}
if (clicked == 2) // Light was switched OFF and ON again
{
if ((PINB & 8) == 0) // If switch is still pressed
{
OCR0B = modes[BURSTaddr]; // Momentary 'BURST'
momentary();
clicked = 0;
}
else
{
if (lastmode == mode1addr) // Decide which mode and set new mode...
setmode(mode2addr);
else
setmode(mode1addr);
}
}
}
else // Light is already switched ON
{
clicked +=click();
if (clicked == 0) // Light is ON and switch is pressed
{
OCR0B = modes[BURSTaddr]; // Brightness is set to 'BURST'
momentary(); // While button is pressed...
OCR0B = modes[lastmode]; // Brightness is set to 'lastmode' again
}
if (clicked == 1) // Switch was pressed (and perhaps released)
{
OCR0B = modes[BURSTaddr]; // Momentary 'BURST'
momentary(); // --> switch light OFF
}
if (clicked == 2 || (clicked > 3))
OCR0B = 0; // --> switch light OFF
if (clicked == 3) // Access 'mode3' or ramping mode
{
setmode(mode3addr);
if ((PINB & 8) == 0) // If switch is still pressed -> ramping mode is entered
{
blinkblinkblink();
ramping(memory); // Set new brightness for the selected mode
clicked = 0; // Reset clicked
momentary(); // Wait until switch is release
OCR0B = modes[memory]; // And set brightness to the new mode
}
}
if (clicked > 7) // Save new modes in EEPROM
{
INTflag = 0;
blinkblinkblink(); // Blink three times to indicate entering the programming menu
OCR0B = 0;
programming(); // Enter programming menu
clicked = 0; // Reset click counter
}
}
time = 0; // Set 'time' to 0 to tell programm the light just was switched ON or OFF
bursttimer = 0; // Reset 'bursttimer'
}
wait_5ms();
if (time > OFFtime) // More than OFFtime * 5ms without doing anything passed
{
memory = lastmode;
clicked = 0; // Reset 'click' (counter) and
if (OCR0B == 0) // If light is switched OFF
bedtime(); // --> send ATtiny to sleep mode
if (time > 254)
bursttimer++; // Increase Burst timer when time is overflowing
}
if ((bursttimer > BURSTtime) && (lastmode == BURSTaddr))
setmode(mode4addr); // Ramp down
if ((INTflag & (1 << WDTflag)) == 1) // WDT Interrupt occurred
{
INTflag = 0; // Set 'INTflag' to 0 again
OCR0B = locator; // Set Brightness to 'locator'
wait_5ms();
wait_5ms();
OCR0B = 0; // After 10ms switch light OFF again
time = OFFtime; // Set 'time' to OFFtime to enter sleepmode again
}
time++; // Reset 'time' not needed, just creates an overflox. Important for BURSTtimer
}
}
uint8_t click() // Decide if click or press...
{ // if click --> return 1
uint8_t press_timer = 0;
while(press_timer < presstime) // if press --> return 0 (pressed for more than 50 * 5ms)
{
if ((PINB & 8) == 0) // When the button is pressed (PINB3 pulled down)
{
press_timer++; // Increase 'time' while switch is pressed
wait_5ms(); // And wait 5ms
}
else
return 1; // Switch was clicked
}
return 0; // Switch is pressed
}
void momentary() // Allows momentary function.
{
while((PINB & 8) == 0) // While switch is pressed wait
wait_5ms(); // Wait 5ms for debouncing
OCR0B = 0; // When switch is released set brightness to 0
}
void wait_5ms() // Waits for 5ms
{ // This way you use less memory than
_delay_ms(5); // Always writing _delay_ms(double argument)
}
void setmode(uint8_t mode) // Sets OCR0B to 'modes[mode]'
{ // Also uses less memory than always writing
OCR0B = modes[mode]; // OCR0B = 'modes[mode]';
lastmode = mode; // lastmode = 'mode';
}
void bedtime() // Send ATtiny to sleep mode
{
sei(); // Enable global interrupts
sleep_mode(); // Go to sleep and wait for interrupt...
cli(); // Disable global interrupts
}
void ramping(uint8_t mode) // Ramping mode
{
uint8_t new_brightness = 0; // Define some new variables
uint8_t click_counter = 0;
uint8_t dummy = 0;
momentary(); // Wait until the switch is released
while (1) // Go into a never ending loop except you reach the mode you like and press
{
if (new_brightness > 22) // 22 brightness settings are stored in the EEPROM
{
new_brightness = 0; // This avoids getting a wrong adress
click_counter = 0;
}
OCR0B = EEPROM_read(new_brightness + 7); // OCR0B is set to the current brightness
if ((PINB & 8) == 0) // If switch is pressed
{
dummy = click_counter;
click_counter += click(); // If switch is clicked the light will continue ramping up
new_brightness = click_counter;
if (dummy == new_brightness) // if dummy == new_brightness then the switch was pressed
{
blinkblinkblink(); // Blink three times to indicate that the new mode is set
click_counter = EEPROM_read(new_brightness + 7);
modes[mode] = click_counter;
return; // Return to main
}
}
wait_5ms();
}
}
void blink() // Blinks with OFFtime 250ms, ontime 250ms and brightness 20
{
OCR0B = 0; // Set brightness to '0'
wait_ms(50);
OCR0B = 20; // Set brightness to 20
wait_ms(50);
}
uint8_t EEPROM_read(uint8_t EEPROM_address) // For more information about this function look in the datasheet
{
while(EECR & (1 << 1)); // Wait for completion of previous write
EEARL = EEPROM_address; // Set up address register
EECR |= (1 << EERE); // Start eeprom read by writing EERE
return EEDR; // Return data from data register
}
void EEPROM_write(uint8_t EEPROM_adress) // For more information about this function look in the datasheet
{
while(EECR & (1 << 1)); // Wait for completion of previous write
EECR = (0 << EEPM1) | (0 >> EEPM0); // Set Programming mode
EEARL = EEPROM_adress; // Set up address and data registers
if (EEPROM_adress == 5)
EEDR = EEPROM_read(5) ^ 1;
if (EEPROM_adress == 6)
EEDR = EEPROM_read(6) ^ 1;
if (EEPROM_adress < 5)
EEDR = modes[EEPROM_adress];
EECR |= (1 << 2); // Write logical one to EEMPE
EECR |= (1 << 1); // Start eeprom write by setting EEPE
}
void wait_ms(uint8_t time) // Wait time * 5ms with using wait_5ms()
{
while ((time > 0) && ((INTflag & (1 << PCINTflag)) == 0))
{
wait_5ms();
time--;
}
}
void programming()
{
uint8_t counter = 0; // Define some new variables
uint8_t click_counter = 0;
uint8_t dummy = 0;
while (click_counter < 4) // Leave programming menu after 4 clicks
{
INTflag = 0;
sei();
wait_ms(50);
while ((counter > 0) && (INTflag & (1 << PCINTflag)) == 0)
{
blink();
counter--;
}
cli();
OCR0B = 0;
if ((PINB & 8) == 0) // If switch is pressed
{
dummy = click_counter;
click_counter += click(); // Decide if switch is clicked or pressed
counter = click_counter;
if (dummy == counter) // Switch was pressed
{
momentary();
if (dummy == 1)
{
EEPROM_write(5); // Toggle Locatorflash ON/ OFF
}
if (dummy == 2)
{
EEPROM_write(6); // Toggle mode memory ON/ OFF
}
if (dummy == 3)
{
EEPROM_write(mode1addr); // Update 'mode1'
EEPROM_write(mode2addr); // Update 'mode2'
EEPROM_write(mode3addr); // Update 'mode3'
EEPROM_write(mode4addr); // Update 'mode4'
EEPROM_write(BURSTaddr); // Update 'BURST'
}
}
}
wait_5ms();
}
}
void blinkblinkblink() // Blinks three times...
{
blink();
blink();
blink();
}
Gibt's vielleicht schon irgendwelche interessanten Erweiterungen oder besteht Interesse, mal einen TlfDrv zu bauen? Wenn man auf z.B. Programmierbarkeit verzichtet, paßt auf den ATTiny13 schon noch ein bißchen was drauf. Macht natürlich nur Sinn, wenn auch mehr als nur 2 Leute selbst flashen können... 
