Glühwürmchen in Rotkohlglas gefangen

phase++; 

phase+=seeLight(x,y)/20*phase/255;

#include "firefly.h"

firefly_t fireflies[12];                            // 12 fireflies

uint8_t   ocr_data[6];                              // OCR0A and DDRB datas for Timer0 Compare Match ISR, computed PWM Dutycycles

uint16_t  hungry_threshold;                         // threshold for lightning fireflies

// 12 fixed registers assigned to speedup ISRs, Timer0 Overflow and Output Compare

register uint16_t  _saveZ    asm("r2");             // save Z register

register uint16_t  _saveY    asm("r4");             // save Y register

register uint8_t   _saveSREG asm("r6");             // save SREG

register uint8_t   _zero     asm("r7");             // zero Register

register uint8_t*  _ocr_ptr  asm("r8");             // pointer to current ocr_data[] entry

register firefly_p _fly_ptr  asm("r10");            // pointer to current firefly[] entry

register uint8_t   _ddr_idx  asm("r16");            // index into ddr_data[] entry, 0 upto 15 in +4 steps

register uint8_t   flags     asm("r17");

static void init(void) {

  // init global registers

    _fly_ptr = (firefly_p)&fireflies;

    _zero    = 0;

    _ddr_idx = 0;

    flags    = 0;

  // enable watchdog ISR

    wdt_reset();

    WDTCR |= (1 << WDE) | (1 << WDCE);

    WDTCR  = (1 << WDIE);

  // Port

    PORTB  = 0;

  DDRB   = 0;

  // Power Reduction, enable ADC for setup

    PRR    = (1 << PRTIM1) | (1 << PRTIM0) | (1 << PRUSI);

  //  AC/ADC

    ACSR   = (1 << ACD);

    ADCSRA = 0;

    ADCSRB = 0;

    DIDR0  = (1 << ADC0D) | (1 << ADC2D) | (1 << ADC3D) | (1 << AIN1D) | (1 << AIN0D);

  // Power Reduction, enable Timer0

    PRR    = (1 << PRTIM1) | (1 << PRUSI) | (1 << PRADC);

  // Pin Change Mask on PB2, for calling Bootloader

    GIMSK  = 0;

    PCMSK  = (1 << PCINT2);

  // Timer0, Overflow & Compare Match ISR used

    TCCR0A = 0;

    TCCR0B = 0;

    OCR0A  = 0;

    TCNT0  = 0;

    TIMSK  = (1 << OCIE0A) | (1 << TOIE0);

    TIFR   = (1 << OCF0A) | (1 << TOV0);

  // init PRNG, load last seed from EEPROM, calculate next seed and store back to EEPROM, use another polynom as in lfsr()

    eeprom_read_block((uint8_t *)&seed, (uint8_t *)(0), 4);

    lfsr_poly(32, 0x8140C9D5);

    eeprom_write_block((uint8_t *)&seed, (uint8_t *)(0), 4);

}

static uint16_t update_fireflies(void) {

  // update waves

    firefly_p fly = (firefly_p)&fireflies;

    firefly_p cur;

    for (uint8_t i = 12; i > 0; i--) {

      if ((fly->wave_ptr == 0) && (fly->hungry == 0)) {

        uint16_t* data = (uint16_t*)&wave_data[lfsr(5)];                // choose wave for lightning from a set of 32 waves randomly

        cur = fly;

        uint16_t ptr = pgm_read_word_inc(data);

        cur->wave_end = pgm_read_word_inc(data);

        cli();

        cur->wave_ptr = ptr;

        flags |= FLAG_TIMER;

        sei();                                                          // update next energy points, each neighbor fly becomes half of energy points

        uint16_t energy = pgm_read_word_inc(data);

        while (energy > 0) {

          cur->energy += energy;

          if (++cur >= &fireflies[12]) cur = (firefly_p)&fireflies;

          energy /= 2;

        }

      }

      fly++;

    }

  // calc feeding step and update fireflies hungry value

    uint16_t food = 0xFFFF;

    uint16_t threshold = hungry_threshold;

    fly = (firefly_p)&fireflies;

    for (uint8_t i = 12; i > 0; i--) {

      uint16_t hungry = fly->hungry;

      if (fly->energy > 0) {

        if ((hungry == 0) || (hungry > threshold)) {

          uint16_t max = 0xFFFF - fly->energy;

          if (hungry < max) hungry += fly->energy;

            else hungry = 0xFFFF;

          if (threshold < 0xFFF0) threshold += 3;

        } else if (threshold > 1) {

          threshold -= 2;

        }

      }

      if (hungry < food) food = hungry;

      fly->hungry = hungry;

      fly->energy = 0;

      fly++;

    }

  // hungry_threshold ensures that fireflies with low hungry is ligthning early and so we get a ligthing in periodic intervals of groups of fireflies,

  // eg. or some longer delays of no lightning dependend on how many energy is consumed by the ligthning waves

    hungry_threshold = threshold;

  // feeding

    fly = (firefly_p)&fireflies;

    for (uint8_t i = 12; i > 0; i--) {

      fly->hungry -= food;

      fly++;

    }

  // return minimal watchdog timer cycles for sleep mode, eg. food

    return food;

}

static void measure_isnight(void) {

    flags &= ~FLAG_ISNIGHT;

  // enable ADC Noise Reduction Sleep Mode

    MCUCR  = (1 << SE) | (1 << SM0);

  // first dummy reading, VRef=2.56V

  // read battery voltage

 // read solar panel voltage

  flags |= FLAG_ISNIGHT;

  // disable ADC

    ADCSRA = 0;

    PRR    = (1 << PRTIM1) | (1 << PRUSI) | (1 << PRADC);

}

static uint16_t wdt_setup(uint16_t time) {

  // setup watchdog to next highest timeout that match time

    uint16_t res = 1;

    uint8_t  idx = 1;

    while ((res <= time) && (idx < 10)) {

      res += res;

      idx++;

    }

    res /= 2;

    if (--idx > 7) idx = (idx & 0x0F) | (1 << WDP3);

    idx |= (1 << WDIE);                                                 // enable WDT-ISR

    wdt_reset();

    WDTCR |= (1 << WDE) | (1 << WDCE);

    WDTCR  = idx;

    return res;

}

int main(void) {

    init();

    sei();

    uint16_t timeout = 0;   // remaining time in WDT cycles a 16ms upto next event

    uint16_t measure = 0;   // remaining time upto next measurement

    while (1) {

    // check for update, FLAG_UPDATE is set in Watchdog ISR

      if (flags & FLAG_UPDATE) {

        flags &= ~FLAG_UPDATE;

        if (timeout == 0) {

          if (flags & FLAG_ISNIGHT) {

            timeout = update_fireflies();

            if (measure <= timeout) {

              measure = MEASURE_INTERVAL;

              flags |= FLAG_MEASURE;

            } else measure -= timeout;

          } else {

            measure = MEASURE_INTERVAL;

            timeout = measure;

            flags |= FLAG_MEASURE;

          }

        }

        timeout -= wdt_setup(timeout);

      }

    // check iff we playing waves

      if (flags & FLAG_TIMER) {

      // enable PWM-Timer0, XTAL / 64

        TCCR0B = (1 << CS01) | (1 << CS00);

      // sleep mode idle

        MCUCR  = (1 << SE);

        sleep_cpu();

      } else {

      // disable Timer0

        TCCR0B = 0;

        OCR0A  = 0;

        TCNT0  = 0;

      // enable deep Power Down Sleep Mode

        MCUCR  = (1 << SE) | (1 << SM1);

      // enable Pin Change for Bootloader on PB2

        PORTB  = 0;

        DDRB   = 0;

        cli();

        GIMSK  = (1 << PCIE);

        GIFR   = (1 << PCIF);

        sei();

        sleep_cpu();

        GIMSK  = 0;

      // check iff we must measure battery and solar panel

        if (flags & FLAG_MEASURE) {

          flags &= ~FLAG_MEASURE;

          measure_isnight();

        }

      }

    }

}

#ifndef FIREFLY_H

#define FIREFLY_H

#include <inttypes.h>

#include <avr/eeprom.h>

#include <avr/pgmspace.h>

#include "lfsr32.h"

#include "wave.h"

/*

   PB2 =      = InOut = LED0

   PB1 =      = InOut = LED1

   PB0 =      = InOut = LED2

   PB5 =      = InOut = LED3

   connection schemata for LEDs are:

   - two antiparallel connected LEDs to two wire, makes six such wires

   - connect these wires to PB0-PB1, PB0-PB2, PB0-PB5, PB1-PB2, PB1-PB5, PB2-PB5

   - the order of these connections are not relevant

   setup:

   - install AVRootloader.HEX on AVR

   - setup fuses to XTAL=8Mhz, no Brownout Detection, no WDTON

   - connect RS232 on PB2 and test Bootloader (reading/writing EEPROM)

   - setup fuses to disable RESET Pin and lockbits

   - connect with bootloader an program FireFly.HEX

*/

#define FLAG_WAVE           (1 << 0)                    // PWM is active for a LED

#define FLAG_TIMER          (1 << 1)                    // PWM is active

#define FLAG_UPDATE         (1 << 2)                    // Watchdog signaled a update

#define FLAG_ISNIGHT        (1 << 3)                    // is at night

#define FLAG_MEASURE        (1 << 4)                    // measure battery and solarpanel

#define MEASURE_INTERVAL    (uint16_t)(1 *  1200)       // each 6 minutes measure interval

#define BATTERY_OK          (uint16_t)(0 * 400)       // 0.9 Volt

// LED Rows, Pins connected to LEDs

#define R0  (1 << PB0)

#define R1  (1 << PB1)

#define R2  (1 << PB2)

#define R3  (1 << PB5)

// bitmasks for driving LEDs on PORTB and DDRB, first value are for PORTB (always 1), 

// next 3 values for DDRB to connect LEDs to GND (on) or as high-Z input (off)

// you can reorder this array iff needed so long as each row depends to only one PORTB value,

// means in each row you can savely reorder the colums and/or you can savely reorder the rows.

prog_uint8_t ddr_data[16] = {

    R0, R0^R1, R0^R2, R0^R3,

    R1, R1^R0, R1^R2, R1^R3,

    R2, R2^R0, R2^R1, R2^R3,

    R3, R3^R0, R3^R1, R3^R2};

// a Firefly

typedef struct {

    uint16_t wave_end;                              // pointer to end of wave samples

    uint16_t wave_ptr;                              // pointer to current wave sample == PWM Dutycylce of one LED

    uint16_t hungry;                                // energy points that must be feed to activate lightning of firefly

    uint16_t energy;                                // next energy points to add to hungry

} firefly_t;                                        // one energy/hungry point relates to one WDT cycle of 16ms

typedef firefly_t* firefly_p;

// some macros, don't use WinAVR GCC default macros because these produce inefficient compiled code

#define  wdt_reset()         asm volatile("wdr")

#define  cli()               asm volatile("cli")

#define  sei()               asm volatile("sei")

#define  sleep_cpu()         asm volatile("sleep")

// read word from FLASH with postincrement addresspointer

#define pgm_read_word_inc(addr) \

(__extension__({                \

    uint16_t __result;          \

    __asm__                     \

    (                           \

        "lpm %A0, Z+" "\n\t"    \

        "lpm %B0, Z+" "\n\t"    \

        : "=r" (__result),      \

          "=z" (addr)           \

        : "1" (addr)            \

    );                          \

    __result;                   \

}))

#endif