AVR Freaks

			// the next led should start fading if the current one has reached the start_bright threshold
			// and it's fading in, two if statements one for each direction.
			if ((led_bright[i] == start_bright) && (led_increment[i] > 0) && (reverse_leds == 0)) {
				if (i < CHMAX) {
					led_increment[i + 1] = fade_inc;
				} else {
					led_increment[0] = fade_inc;
				}				
			}
			if ((led_bright[i] == start_bright) && (led_increment[i] > 0) && (reverse_leds)) {
				if (i > 0) {
					led_increment[i - 1] = fade_inc;
				} else {
					led_increment[CHMAX] = fade_inc;
				}				
			}

/*
 * Author: Blark - blark at pwnp.al
 *  - some of this code is ripped from Atmel's software PWM example
 *  - modified by larryvc for testing on an ATtiny2313
 */

#define F_CPU 8000000UL

#include 
#include 
#include 

#define CHMAX 7             // CHMAX should equal the number of LEDs
#define PWMDEFAULT 0x00     // default PWM value at start up for all channels   NOT USED
#define CYCLEDEL 200        // ms delay between each cycle of the LEDS
#define FADEDEL 1000        // us delay between updates to PWM

#define LED0 PB0            // assign LED names to output ports on the ATtiny2313 - change to PA for ATtiny84
#define LED1 PB1
#define LED2 PB2
#define LED3 PB3
#define LED4 PB4
#define LED5 PB5
#define LED6 PB6

#define LED0_CLEAR (pin_level &= ~(1 << LED0))
#define LED1_CLEAR (pin_level &= ~(1 << LED1))
#define LED2_CLEAR (pin_level &= ~(1 << LED2))
#define LED3_CLEAR (pin_level &= ~(1 << LED3))
#define LED4_CLEAR (pin_level &= ~(1 << LED4))
#define LED5_CLEAR (pin_level &= ~(1 << LED5))
#define LED6_CLEAR (pin_level &= ~(1 << LED6))

#define PORT_MASK 0x7F;
#define LED_PORT PORTB    // change to PORTA for ATtiny84
#define LED_DDR DDRB      // change to DDRA for ATtiny84

void delay_ms(uint16_t ms);
void init(void);

// Shared between main and ISR, must be volatile.
volatile uint8_t led_bright[CHMAX] = { 0 };    // led brightness array holds current brightness for each led.

int main(void)
{
    volatile uint8_t i, flashcount = 0, j;

    const uint8_t max_bright = 254;    // maximum brightness to go to is 254
    const uint8_t start_bright = 84;   // turn on the next led when we reach 1/3 of the max_bright of the previous one

    int8_t led_increment[CHMAX] = { 2, 0 };    // if 0 fade is off, if positive fading up, if negative fading down

    //////THIS IS NOT WORKING
    int8_t fade_inc = 2;         // altering this value will increase/decrease fade speed

    // countup means LEDs are going 0 -> CHMAX, countdown means LEDs are going CHMAX -> 0.
    enum DIR { countup, countdown } led_dir = countup;

    init();

    while (1) {

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

            // check if the led has reached max_bright
            // if it has, change the fade_inc to negative so it goes back down.
            if (led_bright[i] == max_bright) {
                led_increment[i] = -led_increment[i];
            }
            
            // the next led should start fading if the current one has reached the start_bright threshold
            // and it's fading in
            if ((led_bright[i] == start_bright) && (led_increment[i] > 0)) {

                if (led_dir == countup) {
                    if (i < CHMAX) {
                        led_increment[i + 1] = fade_inc;
                    } else {
                        led_increment[0] = fade_inc;
                    }
                }

                if (led_dir == countdown) {
                    if (i > 0) {
                        led_increment[i - 1] = fade_inc;
                    } else {
                        led_increment[CHMAX] = fade_inc;
                    }
                }
            }
            
            // if the current led brightness is 0 and the fade_inc is a negative then the led cycle
            // is complete - we need to turn it off.
            if ((led_bright[i] == 0) && (led_increment[i] < 0)) {
                
                // set led_increment to 0 to turn led updates off
                led_increment[i] = 0;

                // if we're at the last led, reverse the fade
                if ((i == (CHMAX - 1)) && (led_dir == countup)) {
                    led_dir = countdown;
                    led_increment[CHMAX - 1] = fade_inc;    // sets the last led to start
                    delay_ms(CYCLEDEL);
                    // Every 6 cycles flash all LEDs
                    if (flashcount++ == 5) {
                        cli();
                        LED_PORT = 0;
                        for (j = 0; j < 10; j++) {
                            delay_ms(150);
                            LED_PORT ^= 0xFF;
                        }
                        flashcount = 0;
                        sei();
                    }
                }
                
                // if we're at the first led, reverse the fade
                if ((i == 0) && (led_dir == countdown)) {
                    led_dir = countup;
                    led_increment[0] = fade_inc;    // sets the first led to start
                    delay_ms(CYCLEDEL);
                }
            }
            
            // this is where the led_increment actually gets added
            led_bright[i] += led_increment[i];
        }

        // if this delay isn't here the leds race across so fast you can hardly see the fade.
        _delay_us(FADEDEL);
    }
}

void delay_ms(uint16_t ms)
{
    while (ms) {
        _delay_ms(1);
        ms--;
    }
}

void init(void)
{
    LED_DDR = PORT_MASK;      // set the direction of the ports
    CLKPR = (1 << CLKPCE);    // enable clock prescaler update
    CLKPR = 0;                // set clock to maximum (= crystal)
    TIFR = (1 << TOV0);       // clear interrupt flag - change to TIFR0 for ATtiny84
    TIMSK = (1 << TOIE0);     // enable overflow interrupt - change to TIMSK0 for ATtiny84
    TCCR0B = (1 << CS00);     // start timer, no prescale
    sei();
}

ISR(TIMER0_OVF_vect)    // change to TIM0_OVF_vect for ATtiny84
{
    static uint8_t compare[CHMAX] = { 0 };
    static uint8_t pin_level = PORT_MASK;
    static uint8_t softcount = 0xFF;

    LED_PORT = pin_level;    // update outputs
    
    if (++softcount == 0)    // increment modulo 256 counter and update the compare values only when counter = 0.
    {
        compare[0] = led_bright[0];    // verbose code for speed
        compare[1] = led_bright[1];
        compare[2] = led_bright[2];
        compare[3] = led_bright[3];
        compare[4] = led_bright[4];
        compare[5] = led_bright[5];
        compare[6] = led_bright[6];
        pin_level = PORT_MASK;    // set all port pins high
    }
    
    // clear port pin on compare match (executed on next interrupt)
    if(compare[0] == softcount) { LED0_CLEAR; }
    if(compare[1] == softcount) { LED1_CLEAR; }
    if(compare[2] == softcount) { LED2_CLEAR; }
    if(compare[3] == softcount) { LED3_CLEAR; }
    if(compare[4] == softcount) { LED4_CLEAR; }
    if(compare[5] == softcount) { LED5_CLEAR; }
    if(compare[6] == softcount) { LED6_CLEAR; }
}