Glühwürmchen in Rotkohlglas gefangen

[chris_ (Gast)]

> Man kann also sowas wie ein
> gepulstes Nachleuchten wie eine Welle die durch den Schwarm läuft
> beobachten.
Dazu das Video 2 hier:
http://tinkerlog.com/2009/06/25/64-synchronizing-fireflies/
Ich vermute, dass der Lichtsensor des einzelnen "Glühwürmchens" nicht 
alle anderen sehen kann, sondern nur seine Nachbarn. Trotzdem entsteht 
keine Welle.

[Hagen R. (hagen)]

als sich fortpflanzende Welle, meinte ich. Ich habe damals einiges an 
Abhandlungen zu Glühwürmchens gelesen, besonders war ich auf der Suche 
nach digitalisierten Leuchtmustern.

Das von dir angesprochene Viedeo zeigt beide angesprochenen Effekte. 1. 
werden sich lange Dunkelperioden ergeben und dann durch wenige 
Glühwürmchens veranlasst leuchten in deren Umgebung immer mehr 
gleichzeitig auf. 2. der Impuls, eg. die Wellenfront pflanzt sich fort. 
Ist eigentlich auch logisch da ja die Glühwürmchens evolutionär keinen 
Vorteil hätten wenn sie auf 100'erte Kilometer Entfernung einem Weibchen 
antworten würden. Aus Sicht eines größeren örtlich verteilten Schwarmes 
muß es also dann so aussehen das igrendwo im Schwarm das Leuchten 
einsetzt, die umliegenden Glühwürmchens angeregt werden und dadurch 
ihrerseits weiter entfernte Glühwümchens zum Leuchten bringen. Die Welle 
pflanzt sich durch den Schwarm fort.

Übrigens meine ich auch das deine verlinkte Simulation nicht korrekt 
modelliert wurde. Die Glühwürmchen antworten schon als Masse in Wellen 
auf ein Reizsignal. Das heist aber eben nicht das sie sich von ihrem 
Timing her auf die Zukunft betrachtet hin synchronisieren. So als ob sie 
einen inneren Zeitgeber hätten, am Anfang unsynchronisiert jeder mit 
seiner eigenen Frequenz und am Ende hin alle schlagartig.
Dies widerspricht dem evolutionären Sinn des Ganzen. Es geht um 
Fortplanzung und das Anlocken möglichst vieler Männchen aus Sicht der 
Weibchens. Was ich aus wissenschaftlichen Abhandlung weiß deutet eher 
darauf hin das es immer die Weibchen sind die das Leuchten auslösen. 
Ergo heist dies für ein gutes Modell: es müssen zwei unterschiedliche 
Arten von Glühwürmchens modelliert werden, einmal Weibchens und ein 
anders Mal Männchen. Und beide unterscheiden sich in ihrem Verhalten wie 
sie auf Leuchtmuster anderer reagieren werden.

Warum sollte in einem Schwarm aus par wenigen Weibchens und ne Handvoll 
Männchens auch die zur Zeit nicht blinkenden Weibchens entschließen, 
quasi Energie opfern, und synchron mit allen anderen Glühwürmchens 
zusammen zu leuchten ? Sie haben keinen Vorteil gegenüber ihrer 
Fortpfanzungskonkurrentinnen wenn sie so wie Männchen auf das Leuchten 
der Konkurrentinnen reagieren würden.

In einem guten Modell kann der Zustand "alle leuchten demnächst zum 
gleichen Zeitpunkt" garnicht vorkommen dürfen.

Gruß hagen

[chris_ (Gast)]

> es müssen zwei unterschiedliche
> Arten von Glühwürmchens modelliert werden, einmal Weibchens und ein
> anders Mal Männchen.

Wobei man vermuten könnte, das es ausreicht, wenn nur ein Geschlecht 
leuchtet.

[chris_ (Gast)]

Das hier beschriebene Verfahren
http://www.rlocman.ru/i/File/2007/10/24/2006_WSL_Firefly_Synchronization_Ad_Hoc_Networks.pdf

zur Synchronisation der Glühwürmchen schein ja recht einfach zu sein, 
wie in dem Bild zu sehen ist:
http://cdn.instructables.com/FMB/LST2/F03GBAW2/FMBLST2F03GBAW2.LARGE.jpg

Es wird eine Phase linear bis zu einem Schellwert erhöht. Wenn der 
Schwellwert erreicht ist, blitzt das Glühwürmchen. Es kann früher 
blitzen, wenn es andere Glühwürmchen sieht.

[chris_ (Gast)]

Hier mal eine Simulation mit 8x8 Glühwürmchen.

Der Algorithmus für ein einzelnes Glühwürmchen ist im wesentlichen 
folgender:

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

Wobei seeLight(x,y) im die Summe der Helligkeiten der Farbe Grün der 
benachbarten Glühwürmchen zurück gibt.

[Der_Kochloeffel (Gast)]

Hallo,
eine Frage an jemanden der sich hier gut auskennt?

Habe die Glühwürmchen nachgebaut, und Funktioniert ganz gut.
Nun die Fragen:

1. was muss ich wo am Code weglassen, oder verändern, wenn ich keine 
Spannungsüberwachung des Akkus und der Solarzelle wünsche, so das die 
Würmchen gleich loslegen wenn ich einen Akku einsetzte, b.z.w. die 
Elektronik einer Gartensolarlampe auf Nacht schaltet und meinen mC mit 
Energie versorgt?
Also völlig ohne Tag/Nacht und Akku Überwachung.

2. wenn ich statt des Tiny 45 einen Tiny44 20 PU also einen mit 14 
Beinchen einsetzten möchte, habe ich den Code, also die Befehle 
entsprechend angepasst laut beiden Datenblättern, aber ich bekomme das 
Programm einfach nicht zum Laufen?
Das einzige das ich nicht anpassen konnte waren die 2,5v Interne 
Reverenz Spannung, bei meinem Tiny44 sind das 1,1V oder leitung zum 
entsprechenden Port mit VCC also 5V Legen, und hatte dann testhalber 
Akkuspannung von 1,2 V drann und auch 5 V aber das hat nicht 
funktioniert, oder es liegt an etwas anderem was nicht so ganz passend 
ist?


Ziel hiervon wäre ein bis Zwei mehr LED Ports und Externen Oszilator 
verwenden und dann auch eventuell noch mehr LED Ports zu verwenden.

Da aber das Programm auf meinem Tiny44 scheinbar nichts macht, also 
nichts an den LED's erkennbares, kann ich auch nicht Testen ob sich das 
Programm, wie weiter oben als Tip von Hagen beschrieben erweitern lässt?

Geflasht habe ich alles ohne Bootloader, einfach nur das Hexfile das 
nach anwendung von Make ensteht habe ich auf den mC übertragen.


Wäre sicherlich für andere auch Hilfreich, da eine Solarlampe schon fast 
alles mit sich bringt was man zum Laden und Tag / Nacht erkennung 
benötigt, und die Sorte die ich zum Basteln hier habe, hat eine sehr 
gute Diode verbaut, Spannungsverlust Solarpanel zum Akku 0,1 V konnte 
ich Messen.

Von da her ist es ja eigentlich einfacher das der Zweckentfremdetetn 
Electronic der Lampe zu überlassen oder?




Mit Freundlichem Gruß
Michael

[Der_Kochloeffel (Gast)]

Hallo,
hab das Problem selbst gelöst bekommen, hier der Code ohne die Solar und 
Akku Messung und damit Zwei freien Pin's ähem Port's!

Wenn es Jetzt Nacht ist bekommt der Attiny von der ehemaligen 
Gartenlampe, also der Stepup erst Energie, und dann läuft das Programm 
einfach und die Glühwürmchen fangen an zu Leuchten!

Lg
Michael
zuerst die firefly.c

#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();
        }
      }
    }
}

dann noch die firefly.h

#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

[Der_Kochloeffel (Gast)]

Hallo,
noch ne Frage, ich habe Versucht die Tierchen zu erweitern um genau Zwei 
LED Port's, alles war ein wenig extrem schwer für mich, und es tut sich 
absolut nichts an meinen LED's auch nicht wenn ich nur Einen Port mehr 
hineinschreibe, und 6 LED Ports scheinen gar unmöglich zu sein?

Mir gehen einfach die Register aus, also gehen bei diesem Programm 
scheinbar nur Maximal 4 eventuell 5 Port's für die LED's.

Kann das denn sein, ich hänge gerade mal mein beim Registerumherschieben 
entstandenes Wunderwerk als Datei an, und Hoffe auf Ratschläge?

Ach ja Umschreiben auf andere Mega's oder Tiny's scheint ja auch nicht 
so einfach, da andere Typen die Befehle oder gar andere Voraussetzungen 
garnicht erfüllen können?

Gibt's wirklich nur 32 Register, wo ich auch dann nur noch die oberen 15 
für einige Dinge verwenden kann und darf?

Über Antworten würde ich mich riesig freuen, versuche mich schon ne 
ganze Ecke an dem Projekt.
LG
Michael

[Bernhard M. (boregard)]

Hi,

was meinst Du mit 2 LED Ports? Willst Du um 2 LEDs erwitern, oder um 
wirklich um 2 Anschlüsse, also das Charlieplexing mit dann 30?? LEDs?
Da kommt doch vom Multiplexen gar nicht mehr viel raus, da wird das 
Puls-Pausen Verhältnis reichlich schlecht.

Bedenke dabei auch, daß Hagen hier das Charlieplexing in den 
Interruptroutinen ziemlich optimiert hat, mit fest vergebenen Registern 
u.ä.

Bevor Du den Code nicht genau verstanden hast (habe ich auch einige Zeit 
gebraucht ...), und nicht weisst, wie der Compiler mit den Registern 
umgeht, wirst Du das nicht erweitern können.

Dann ist allerdings das Umschreiben auf andere AVRs auch nicht mehr 
schwer.

Gruß,
Bernhard

[Der_Kochloeffel (Gast)]

Hallo Bernhard,

ja das hatte ich eigentlich vor, ziel der Sache ist das es noch 
realistischer wirkt.

Es sollen eigentlich nicht mehr gleichzeitig leuchten, sondern eher das 
sich die Stellen an denen die Tierchen auf dem Grünzeug angebracht sind 
besser verteilen, so das es nach mehr Zufall aussieht.

Oder auch das mehr zur gleichen Zeit Leuchten?

Die Hardware ist schon fertig, 30 SMD LED's in Grün mit Schwarzen 0,1 mm 
Drähtchen die mit winzigen Heißklebetropfen auf einem recht echt 
aussehenden, aus Drei Verschiedenen Pflanzen bestehenden Gestrüpp 
sitzen, die Drähte sind sogar wenn man es weiß, nahezu unsichtbar um die 
Ästchen gewickelt, und damit es weniger Eckig aussieht hat jede LED 
einen winzigen Tropfen Heißkleb oben drauf bekommen, ich Schick meinen 
letzten Versuch, mit Änderungen an der isrs.S Datei mit, in dem ich 
Versuchte Zwei LED Ports auf 4 Register zu Packen, aber es hat sich 
nichts getahn.
LG
Michael

[Der_Kochloeffel (Gast)]

Nachtrag:

Hier noch die Bilder der Hardware, zur Zeit noch mit Kabeln zu einem 
mini Steckbrett, da die Fassung mitten in dem Gebüsch versteckt ist, und 
so das Testen einfacher ist.

Überlege noch ob ich die Tiere unter eine Art Käseglocke packen soll?
könnte eventuell noch besser aussehen, auf den Boden etwas Sand und Erde 
oder Torf???

Habe auch ein Video gemacht das halt nur 12 angesteuerte von den 30 in 
Aktion zeigt.
Einstellungen am Prescaler ziemlich unten in der firefly.c ist auf 8 
gestellt anstatt 64, und der eine Timerwert in der firefly.h ist auf 1 * 
250 gestellt.
Und das Programm hat das Batterie und Nacht Flag dauernd gesetzt.


http://www.youtube.com/watch?v=lXky5xcLvwU&feature=youtu.be

LG
Michael

[T.M .. (max)]

Hallo,

wird es denn nochmal Platinen geben. Bestellt da vielleicht jemand 
welche in näherer Zukunft?

[Der_Kochloeffel (Gast)]

Hallo,
habe einen Versuch mit einem Tiny44 und der MIK Variante gemacht, indem 
ich die Spannungsmessung entfernt habe, und versucht habe 30 LED's 
anzusteuern, aber in der Firefly.h komme ich oben nicht über 26 und 
weiter unten nicht über 28 hinaus, sobald ich nur eine Zahl höher 
reinschreibe tut sich garnix mehr, und die Würmchen hören nach kurzer 
Zeit auf zu Leuchten und fangen nur wieder an wenn ich die Spannung 
unterbreche und wieder anschliese!

ALso es leuchten auf jeden fall mehr als die 12 Orginalen Würmchen, aber 
nicht alle werden angesteuert, woran kann das liegen???

Habe den gesammten Ordner mit allen Dateien angehängt.

LG
Michael

[chris_ (Gast)]

Hackaday bastelt auch Glühwürmchen:
http://hackaday.com/2014/01/27/low-power-smd-fireflies/

[Karsten W. (lsmod)]

Hagen Re schrieb:
>
> Wenn gewünscht poste ich auch noch die Dateien für die Simulation in
> LTSpice.
> Idee stammt von hier
> http://library.solarbotics.net/circuits/misc_switching.html
>
> Gruß Hagen

Ein wirklich spätes interesse, aber diesen Teil der Schaltung finde ich 
sehr interessant.