Gewitterfotografie

Hallo zusammen, ich möchte Euch mein kleines Projekt zeigen und eine Diskussion anstoßen um das Projekt effektiver zu machen.

Um folgendes Projekt geht es. Ich habe ein Blitzdetektor gebastelt. Mit diesem Gerät lassen sich Gewitterblitze einfacher fotografieren. Funktionsweise ist wie folgt. Ein Nanoklon wertet einen LDR aus. Wenn die Helligkeit schnell zunimmt wird die Kamera ausgelöst. Jetzt könnte man meinen dass so ein LDR recht träge ist, aber es reicht. Siehe Beispielbilder. Diese sind von heute Abend. :slight_smile:

Hardware : Nanoklon, LDR, Poti 22KOhm für Empfindlichkeit, 9 Volt Block und ein 3D Druckgehäuse.

//////////////////////////////////////////////////////////////////////////////////
// Blitztrigger von NicE                                                        //
// Version 0.5.1b                                                                //
// 01.07.2021 17:30                                                              //
// neue Helligkeit nur wenn dunkler als die vorherige                           //
// Empfindlichkeit per Poti verstellbar Map 10 - 100                                         //  
// Version Ralph: 10KOhm für LDR und Poti Map 10 - 100                                                                             //
//////////////////////////////////////////////////////////////////////////////////


int Canon_Pin = 13;               // Anschluß für Kamera
int LDR = A0;                     // LDR GL5528 mit 2,7KOhm rot,lila,rot,gold 1/2W
int Schwellwert = 10;             // Grundempfindlichkeit
int Helligkeit = 0;
int Poti = A1;                    // Anschluß 22KOhm Poti
int variable = 0;

void setup()
{
  pinMode(Canon_Pin, OUTPUT);
  digitalWrite(Canon_Pin, LOW);
  Serial.begin(9600);
  Helligkeit = analogRead(LDR);
  
}

void loop()
{
  int variable = analogRead(Poti);
  Schwellwert = map(variable, 0, 1023, 10, 100);
  Serial.println(Schwellwert);
{
  int neueHelligkeit = analogRead(LDR);

  if ((neueHelligkeit - Helligkeit) > Schwellwert)
  {
    digitalWrite(Canon_Pin, HIGH);
    delay(500);
    digitalWrite(Canon_Pin, LOW);
  {
    if (neueHelligkeit <= Helligkeit);

    {
      neueHelligkeit = Helligkeit;
      
    }
   }
  }
 }
}

Mein Problem ist nun dass das ganze bei Tag nicht Optimal funktioniert. DEr Unterschied ist für den LDR wohl zu gering. Wobei es heute recht gut funktioniert hat. Einige Blitze direkt vor mir hat es aber nicht erkannt.

Was könnte man besser machen?

Software? Hardware?

Ich habe auch schon einen AS3539 da liegen. Der muss aber noch kalibriert werden, das kann ich noch nicht.

Jetzt noch ein paar Bilder:

Gruß Nic

  • Zunächst solltest du deinen Sketch mal mit STRG-T mal einem Autoformat unterziehen dann siehst du schon selber einige Sachen.
  • Pins sind normalerweise Konstant, also kannst du diese auch Konstant machen und es braucht dafür auch keine sgned Typen mit zwei Byte, es reich ein Byte. Z.B.
constexpr uint8_t Canon_Pin = 13;    // Anschluß für Kamera
  • du deklarierst eine globale Variable variable. Der Name variable ist ein suboptimaler Name für eine Variable (was soll es sonst sein?!?). Insbesondere wenn du dann im Sketch noch mal eine lokale Variable variable anlegst. Ich schreib dir das jetzt extra 3mal hin damit du es leichter erkennst: eine Variable variable zu nennen macht wenig Sinn.
  • eine Klammer ist umsonst.
  • der Strichpunkt nach dem if ist gefährlich. Er beendet die Zeile. Die nächste Zeile wird daher immer ausgeführt. Willst du das wirklich? Wenn ja, was soll der if dann machen?
    Im Programmkommentar schreibst du
neue Helligkeit nur wenn dunkler als die vorherige

Genau das kann eigentlich aktuell nicht der Fall sein ...

  • Ich finde es spanned wie du den "Schwellwert" im loop errechnest. map() bringt dir hier theoretisch auch negative Zahlen.
  • Serial mit 9600 Baud ist schnarchlangsam im Jahr 2026. Erhöhe den Wert z.B. auf 115200.

Zum Programmcode wurde ja schon einiges gesagt. Hardwaremäßig würde ich den schon angeschafften Blitzsensor verwenden oder (wenn der nicht vorhanden wäre) auf eine einfache Photodiode umsteigen

Z.B. Arduino Photodiode Light Sensor (BPW34) Circuit & Code Example

Das wäre billiger gewesen.

if (neueHelligkeit <= Helligkeit);

    {
      neueHelligkeit = Helligkeit;
      
    }

Wie @noiasca geschrieben hat, macht dieses "if" gar nichts, weil hinter der Klammer ein ";" gesetzt ist. Würde das "if" die Anweisung dahinter ausführen macht das aber auch keinen sein, weil neueHelligkeit sofort beim nächsten Loopdurchlauf durch int neueHelligkeit = analogRead(LDR); überschieben wird.

Ist vielleicht eher folgendes gemeint:

 if (neueHelligkeit <= Helligkeit)    {
      Helligkeit = neueHelligkeit; 
 }

?
Wenn es im Laufe der Zeit Dunkler wird (ohne Blitze) wird die "Grundhelligkeit" angepasst?

Schickes Projekt.
Danke für die Bilder.

Du hast mit der Bedingung

 if (neueHelligkeit <= Helligkeit);

gleich mehrere Probleme.

Wie schon geschrieben, ist das Semikolon da falsch.
Aber auch sonst wird das an der Stelle nichts, denn Du prüfst erst, ob die aktuelle Helligkeit größer ist als die bisherige.
Wenn das der Fall ist, kommt die Prüfung ob die aktuelle Helligkeit kleiner ist als die bisherige immer zu einem negativen Ergebnis.

Als nächstes ist die dauerhafte Ausgabe des Schwellwertes nicht nötig und belastet nur Dein Timing.
Um das zu umgehen, merkt man sich den Wert und nur bei Änderung gibt man das neu aus.

Dann gehört das delay(500) aufgelöst. In der Zeit macht der Code nichts anderes. In dem Fall mag das noch gehen, aber sobald Du zwei Dinge machen willst, bricht es Dir das Genick.

Zum Schluß fehlt noch die Erkennung, wenn es heller wird.
Wenn es dunkler wird, setzt Du den unteren Erknennungswert zur Berechnung des aktuellen Schwellwertes herab. Wird es aber langsam wieder hell, löst irgendwann die Kamera aus sobald die Differenz zwischen altem und neuem Wert den Schwellwert übersteigt. Auch wenn das ganz langsam passiert.

Ich hab mal was gebastelt.

//////////////////////////////////////////////////////////////////////////////////
// Blitztrigger von NicE                                                        //
// Empfindlichkeit per Poti verstellbar Map 10 - 100                            //
// Version Ralph: 10KOhm für LDR und Poti Map 10 - 100                          //
//////////////////////////////////////////////////////////////////////////////////

constexpr uint8_t ldrPin {A0};                    // LDR GL5528 mit 2,7KOhm rot,lila,rot,gold 1/2W
constexpr uint8_t potiPin {A1};                   // Anschluß 22KOhm Poti
constexpr uint8_t canonPin {13};                  // Anschluß für Kamera

constexpr uint8_t minSchwelle {10};               // Schwellwerte min/max für Helligkeitsunterschiederkennung
constexpr uint8_t maxSchwelle {100};

constexpr uint8_t potiHysterese {3};              // Mindeständerung des Potieingang

constexpr uint32_t verschlussZeit {500};          // Haltezeit für den Auslöser

constexpr uint32_t hellerHysterese {10000};       // Wartezeit, bis erkennt wird, dass es heller wurde

uint16_t oldPotiValue = 2000;                     // Merker / Startwert größer maximal analogRead() garantiert Berechnung
uint8_t schwelle = minSchwelle;

uint16_t oldLdrValue;                             // Merker

uint32_t ausloeseZeit;                            // Merker
uint32_t hellerZeit;                              // Merker, wann erstes mal erkannt wurde, dass es heller wurde
bool ausgeloest = false;
bool isHeller = false;

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  pinMode(canonPin, OUTPUT);
  digitalWrite(canonPin, LOW);
  oldLdrValue = analogRead(ldrPin);
}

void loop()
{
  cameraVerschluss();
}

void cameraVerschluss()
{
  if (ausgeloest == true)                                          // Es war ausgelöst?
  {
    if (millis() - ausloeseZeit > verschlussZeit)                  // und Zeit abgelaufen
    {
      digitalWrite(canonPin, LOW);                                 // Verschluss zu
      ausgeloest = false;                                          // Merker löschen
      Serial.println(F("Kamera verschlossen!"));
    }
  }

  if (checkAusloeser() == true)                                    // Blitzerkennung
  {
    if (ausgeloest == false)                                       // Verschluss noch zu?
    {
      digitalWrite(canonPin, HIGH);                                // auslösen
      ausloeseZeit = millis();                                     // Startzeitpunkt merken
      ausgeloest = true;                                           // merken, dass Verschluss auf
      Serial.println(F("Kamera ausgeloest!"));
    }
  }
}

bool checkAusloeser()
{
  bool ausloeser = false;                                          // Rückgabewert default
  uint16_t ldrValue = analogRead(ldrPin);

  if ((ldrValue - oldLdrValue) > schwelle)                         // Es ist schlagartig heller
  {
    ausloeser = true;
    // keine Ausgabe
  }
  else                                                             // Kein Blitz
  {
    checkLdr(ldrValue);
  }

  return ausloeser;
}

void checkLdr(const uint16_t ldrValue)
{
  if (ldrValue < oldLdrValue)                                      // Es ist jetzt dunkler
  {
    oldLdrValue = ldrValue;
    isHeller = false;
    Serial.print(F("Dunkler geworden - neuer Wert: "));
    Serial.println(ldrValue);
  }
  else if (ldrValue > oldLdrValue)                                 // Es ist heller
  {
    if (isHeller == false)                                         // Vorher noch nicht
    {
      hellerZeit = millis();                                       // Startzeit merken
      isHeller = true;                                             // Merker setzen
    }

    if (isHeller == true)                                          // Es ist noch immer heller
    {
      if (millis() - hellerZeit > hellerHysterese)                 // und die Wartezeit ist abgelaufen
      {
        isHeller = false;                                          // Merker löschen
        oldLdrValue = ldrValue;                                    // Wert merken
        Serial.print(F("Heller geworden - neuer Wert: "));    
        Serial.println(ldrValue);
      }
    }
  }
}

void schwellWert()
{
  uint16_t potiValue = analogRead(potiPin);                        // einlesen in Variable, weil mehrfach benutzt

  if (abs(potiValue - oldPotiValue) > potiHysterese)               // abs() garantiert auch bei negativem Ergebnis vorzeichenlose Auswertung
  {
    schwelle = map(potiValue, 0, 1023, minSchwelle, maxSchwelle);
    oldPotiValue = potiValue;
    Serial.print(F("Poti-Value: "));
    Serial.print(potiValue);
    Serial.print(F(" / Schwellwert neu: "));
    Serial.println(schwelle);
  }
}

Wenn Du Fragen hast, frag,

Guten Morgen zusammen,

vielen Dank für Eure Antworten. Ich habe mich jetzt mal drangestezt und den Sketch mal durchgedacht und habe auch sehr viele Ungereimtheiten entdeckt.

Ich habe mal den sketch neu geschrieben. Einige Sachen rausgelassen wie z.B. MAP. und die Baudrate erhöht.

Kai-R

Zum Programmcode wurde ja schon einiges gesagt. Hardwaremäßig würde ich den schon angeschafften Blitzsensor verwenden oder (wenn der nicht vorhanden wäre) auf eine einfache Photodiode umsteigen

Z.B. Arduino Photodiode Light Sensor (BPW34) Circuit & Code Example

Das wäre billiger gewesen.

if (neueHelligkeit <= Helligkeit);

    {
      neueHelligkeit = Helligkeit;
      
    }

Wie @noiasca geschrieben hat, macht dieses "if" gar nichts, weil hinter der Klammer ein ";" gesetzt ist. Würde das "if" die Anweisung dahinter ausführen macht das aber auch keinen sein, weil neueHelligkeit sofort beim nächsten Loopdurchlauf durch int neueHelligkeit = analogRead(LDR); überschieben wird.

Ist vielleicht eher folgendes gemeint:

 if (neueHelligkeit <= Helligkeit)    {
      Helligkeit = neueHelligkeit; 
 }

?
Wenn es im Laufe der Zeit Dunkler wird (ohne Blitze) wird die "Grundhelligkeit" angepasst?

Das habe ich nun rausgelassen. Es wird ja im LOOP die aktuelle Helligkeit gemessen und der Schwellwert neu ermittelt.

Das mit der Photodiode war auch schon mein Gedanke, werde ich eine besorgen.

Den AS3539 habe ich mir schon besorgt, da ist aber das Problem mit der kalibrierung. Das habe ich noch nicht angegangen.

**
my_xy_projekt
**Karma: 2000+

37 min

post #4

Schickes Projekt.
Danke für die Bilder.

Du hast mit der Bedingung

 if (neueHelligkeit <= Helligkeit);

gleich mehrere Probleme.

Wie schon geschrieben, ist das Semikolon da falsch.
Aber auch sonst wird das an der Stelle nichts, denn Du prüfst erst, ob die aktuelle Helligkeit größer ist als die bisherige.
Wenn das der Fall ist, kommt die Prüfung ob die aktuelle Helligkeit kleiner ist als die bisherige immer zu einem negativen Ergebnis.

Als nächstes ist die dauerhafte Ausgabe des Schwellwertes nicht nötig und belastet nur Dein Timing.
Um das zu umgehen, merkt man sich den Wert und nur bei Änderung gibt man das neu aus.

Dann gehört das delay(500) aufgelöst. In der Zeit macht der Code nichts anderes. In dem Fall mag das noch gehen, aber sobald Du zwei Dinge machen willst, bricht es Dir das Genick.

Zum Schluß fehlt noch die Erkennung, wenn es heller wird.
Wenn es dunkler wird, setzt Du den unteren Erknennungswert zur Berechnung des aktuellen Schwellwertes herab. Wird es aber langsam wieder hell, löst irgendwann die Kamera aus sobald die Differenz zwischen altem und neuem Wert den Schwellwert übersteigt. Auch wenn das ganz langsam passiert.

Ich hab mal was gebastelt.

Das ist mal ein Sketch, coole Sache. Da bin ich noch sehr weit davon entfernt. :slight_smile:

Den werde ich selbstverständlich auch testen.

Ihr alle habt ja den Teil mit "neue Helligkeit" angesprochen der hier schlichtweg zu falschen Ergebnissen führt. Dazu kann ich jetzt sagen was mir beim fotografieren aufgefallen ist. Je länger der sketch läuft umso weniger hat er Blitze erkannt. Das passt zu euren Aussagen ganz gut.

Was mich auch stört ist die empfindlichkeitsregelung per Poti, Irgedwie ungenau. Ich werde dies wahrscheinlich durch einen Festwert ersezten oder gibt es hier andere Möglichkeiten?

Hier noch mein neuer Sketch

constexpr uint8_t Canon_Pin = 13;  // Anschluß für Kamera
constexpr uint8_t LDR = A0;        // Eingang LDR
constexpr uint8_t Poti = A1;       // Eingang Poti
int Helligkeit = 0;

void setup() {
  Serial.begin(115200);
  pinMode(Canon_Pin, OUTPUT);
  digitalWrite(Canon_Pin, LOW);
  Helligkeit = analogRead(LDR);
}

void loop() {
  int Schwellwert = analogRead(Poti);
  {
    int neue_Helligkeit = analogRead(LDR);
    if ((neue_Helligkeit - Helligkeit) > Schwellwert)
      digitalWrite(Canon_Pin, HIGH);
    delay(500);
    digitalWrite(Canon_Pin, LOW);
  }
}


jetzt brauche ich noch ein Gewitter :-)

Gruß Nic

ich denke man sollte erst mal klären welches genaues Systemverhalten eigentlich gewünscht ist.
z.B. soll es pro Blitz nur eine Auslösung geben oder ist der (implizite) 500ms Intervall gewünscht?
Wenn eine Serie von Bildern ausgelöst werden soll, in welchem Intervall und wie lange?

Wenn ich nur den Sketch in #1 ein wenig aufräumen müsste würde das ca so aussehen:

//////////////////////////////////////////////////////////////////////////////////
// Blitztrigger von NicE                                                        //
// Version 0.5.1b                                                                //
// 01.07.2021 17:30                                                              //
// neue Helligkeit nur wenn dunkler als die vorherige                           //
// Empfindlichkeit per Poti verstellbar Map 10 - 100                                         //
// Version Ralph: 10KOhm für LDR und Poti Map 10 - 100
// edited by noiasca 2026-06-20   https://forum.arduino.cc/t/gewitterfotografie/1449066/4                                                          //
//////////////////////////////////////////////////////////////////////////////////

#include <Streaming.h>  // by Mikal Hart - install via Library manager

constexpr uint8_t cameraPin = 13;       // Anschluß für Kamera
constexpr uint8_t sensorPin = A0;       // LDR GL5528 mit 2,7KOhm rot,lila,rot,gold 1/2W
constexpr uint8_t potPin = A1;          // Anschluß 22KOhm Poti
constexpr uint16_t threasholdMin = 10;  // Schwellwert minimum
uint16_t threashold = threasholdMin;    // Schwellwert / Grundempfindlichkeit
uint16_t threasholdPrevious = 0;        // Schwellwert zuletzt
uint16_t brightness;                    // Helligkeit aktuell
uint16_t brightnessPrevious;            // Helligkeit zuletzt

void potentiometerRead() {
  // todo: nicht so häufig lesen, alle 300ms könnte reichen
  uint16_t adcPoti = analogRead(potPin);
  threashold = adcPoti >> 3;                                   // mit dem Rechtsshift bekommt man Werte zwischen 0 .. 127 ohne Divison
  if (threashold < threasholdMin) threashold = threasholdMin;  // untere Grenze festlegen
  if (threashold != threasholdPrevious) {                      // Ausgabe bei neuen Werten
    threasholdPrevious = threashold;
    Serial << F("Threashold: ") << threashold << endl;
  }
}

void sensorRead() {
  brightness = analogRead(sensorPin);
  if ((brightness > brightnessPrevious) && (brightness - brightnessPrevious) > threashold) {  // nur Helligkeitsanstiege auswerten
    digitalWrite(cameraPin, HIGH);
    delay(500);
    digitalWrite(cameraPin, LOW);
  }
  brightnessPrevious = brightness;
}

void setup() {
  pinMode(cameraPin, OUTPUT);
  digitalWrite(cameraPin, LOW);
  Serial.begin(115200);
  brightnessPrevious = analogRead(sensorPin);
}

void loop() {
  potentiometerRead();
  sensorRead();
}
//

da hast jetzt in deinem neuen Sketch vermutlich eine Klammer vergessen.

Da hab ich schon ein Ansatz drin, findest Du unter potiHysterese.
Der analogEingang hat ein gewisses Pendeln, da kann man mit dem Hysteresewert schon einiges weg machen.

Auch kann der Wert mehrfach ausgelesen werden und dann geglättet.
Sieht dann so aus:

// Forensketch
// https://forum.arduino.cc/

#include <Streaming.h>     // https://github.com/janelia-arduino/Streaming

constexpr uint8_t potiPin {A1};
constexpr uint8_t valueCounts {5};

void setup()
{
  Serial.begin(115200);
  delay(500);
  Serial << (F("\r\nStart...\r\n")) << endl;
}

void loop()

{
  getAnalog();
  delay(1000);
}

void getAnalog()
{
  uint16_t minValue = 1024;
  uint16_t maxValue = 0;
  uint16_t maxCount = valueCounts + 2;                // Da min und maxwert abgezogen werden, müssen die mitgezählt werden!
  uint32_t myValue = 0;
  Serial << (F("\r\n Lese analogWerte:")) << endl;

  for (uint8_t count = 0; count < maxCount; count++)
  {
    uint16_t value = analogRead(potiPin);
    Serial << count << ": " << value << endl ;

    if (value > maxValue)
    { maxValue = value; }
    else if (value < minValue)
    { minValue = value; }

    myValue += value;
  }

  Serial << "oberer maximaler Wert: " << maxValue << endl;
  Serial << "unterer minimaler Wert: " << minValue << endl;
  myValue -= maxValue;
  myValue -= minValue;
  myValue /= valueCounts;
  Serial << "errechneter Durchschnittswert: " << myValue << endl;
}

Ja, jetzt habe ich eine vergessen. :slightly_smiling_face:

Ok. Das mit dem glätten hört sich gut an. Eigentlich bräuchte ich schon den Regler. Bei Gewitter nachts muss es nicht so empfindlich reagieren.

Folgende funktion möchte ich erreichen. Der Canon_Pin bleibt ne halbe Sekunde lang auf. Die Kamera macht dann per Dauerfeuer ein paar Bilder.

und reichen die 500ms heute immer oder soll die Fotoserie weitergehen wenn es noch immer blitzt?

Testen lässt sich das ganze mit dem Blitz vom Handy :slight_smile:

Darum habe ich das auch Verschluss genannt :-)

Man kann auch im Verhältnis der Grundhelligkeit die Empfindlichkeit anpassen.
Ist es dunkel, wird die Empfindlichkeitsschwelle höher gestellt und ist es hell, wird die dementsprechend abgesenkt.

Das ist ne gute Frage. Müsste so aber mit den 500ms reichen. In der Vergangenheit habe ich gesehen das es gar nicht so viel nacheinander Blitz. Andererseits, es kann ja mal vorkommen. Wie wäre da der Lösungsansatz? Meine Programmierkenntnisse reichen für „if“ und „else“ gerade mal aus. Vergesse des öfteren mal ne Klammer. :grimacing:

Schönes Projekt - baue ich mir bestimmt für meine Nikon mal nach (nachdem das aktuelle Projekt fertig ist).

Kannst Du noch kurz ein Wort zur Schaltung Richtung Kamera verlieren?

Grund: Einfach "HIGH" geht beim Fernauslöser bei mir nicht, ich muss erst Fokus und dann zusätzlich den Shutter gegen den Ground-Pin auf der dreipoligen Fernauslöserbuchse schalten. Mal sehen, wie das zu adaptieren ist...

Cool. Ich seh schon dass es da in Sachen Funktionalität noch Luft nach oben gibt. Ich werde die Sachen auf jeden Fall testen.

Hallo, ja ist schon cool wenn man die Fotos macht. Früher wurde mit Graufilter ND1000 einfach 30 Sekunden belicht in der Hoffnung dass es Blitz.

Die Schaltung reiche ich auch noch nach, sobald ich wieder vom Computer aus schreibe.

An meinem Code mal gezeigt:

void cameraVerschluss()
{
  if (ausgeloest == true)                                          // Es war ausgelöst?
  {
    if (millis() - ausloeseZeit > verschlussZeit)                  // und Zeit abgelaufen
    {
      digitalWrite(canonPin, LOW);                                 // Verschluss zu
      ausgeloest = false;                                          // Merker löschen
      Serial.println(F("Kamera verschlossen!"));
    }
  }

  if (checkAusloeser() == true)                                    // Blitzerkennung
  {
    if (ausgeloest == false)                                       // Verschluss noch zu?
    {
      digitalWrite(canonPin, HIGH);                                // auslösen
      ausloeseZeit = millis();                                     // Startzeitpunkt merken
      ausgeloest = true;                                           // merken, dass Verschluss auf
      Serial.println(F("Kamera ausgeloest!"));
    }
  }
}

Dort wird für 500ms geöffnet und dann wieder zwangsweise geschlossen, da die Zeit abgelaufen ist.
Die entsprechende Zeile:

    if (millis() - ausloeseZeit > verschlussZeit)                  // und Zeit abgelaufen

Ausgelöst wird immer dann, wenn der Verschluss nicht ausgelöst ist.
Die entsprechende Zeile:

    if (ausgeloest == false)                                       // Verschluss noch zu?

In dieser Variante ist die ausloeseZeit während der Öffnungszeit nicht nachtriggerbar.

Läßt Du die Prüfung auf ausgeloest weg, wird mit jedem Blitz die ausloesezeit neu gestartet - retrigger.

Der gesamte Code ändert sich nicht.
Verschlossen wird dann, wenn der letzte Blitz 500ms vorbei ist.

@seppel08151 Du schreibst von einer Canon Kamera.
Hast Du Dir mal das CHDK ( Canon Hack Development Kit) angeschaut?
Da gibt es ein Beispiel, wie die Kamera das Auslösen bei Blitz selbst erledigen kann.

Gruß Tommy

[OT]
Da ist aber auch einiges broken. Das deutsche Forum auf das verwiesen wird ist zu, der angegebene Archivort (http://chdk.bplaced.net/) ist nicht mal https und von dort aus gehts mit einem kaputten phpBB in eine Sackgasse...

Meine D1000 käme für sowas wohl eher nicht infrage.