• Herzlich willkommen im "neuen" DSLR-Forum!

    Wir hoffen, dass Euch das neue Design und die neuen Features gefallen und Ihr Euch schnell zurechtfindet.
    Wir werden wohl alle etwas Zeit brauchen, um uns in die neue Umgebung einzuleben. Auch für uns ist das alles neu.

    Euer DSLR-Forum-Team

  • In eigener Sache!

    Liebe Mitglieder, liebe Besucher und Gäste
    ich weiß, es ist ein leidiges Thema, aber ich muss es ansprechen: Werbung, Werbeblocker und Finanzierung des Forums.
    Bitte hier weiterlesen ...

  • DSLR-Forum Fotowettbewerb neu erfunden!
    Nach wochenlanger intensiver Arbeit an der Erneuerung des Formates unseres internen Fotowettbewerbes ist es Frosty als Moderator
    und au lait als Programmierer gelungen, unseren Wettbewerb auf ein völlig neues Level zu heben!
    Lest hier alle Infos zum DSLR-Forum Fotowettbewerb 2.0
    Einen voll funktionsfähigen Demowettbewerb kannst du dir hier ansehen.
  • Neuer Partner: AkkuShop.de
    Akkus, Ladegeräte und mehr (nicht nur) für Digitalkameras und Drohnen
  • Neuer Gutscheincode unseres Partners Schutzfolien24:
    DSLR-Forum2024
    Dauerhaft 10% Rabatt auf alle Displayschutzfolien der Eigenmarken "Upscreen", "Brotec", "Savvies".
    Der Code ist für alle Geräteklassen gültig.
  • Stimmt ab über die Sieger des DSLR-Forum Fotowettbewerbs Februar 2024.
    Thema: "Backwaren"

    Nur noch bis zum 29.02.2024 23:59!
    Jeder darf abstimmen!
    Zur Abstimmung und Bewertung hier lang
WERBUNG

Bastelanleitung: Arduino-basierter Lichtschranken-Trigger

Niggoh

Themenersteller
Im Rahmen der Wassertropfenfotografie habe ich einen Weg gesucht, die Fotos etwas berechenbarer zu machen. Mein Ziel war es, mit (für mich) möglichst einfachen Mitteln eine regelbare Lichtschranke zu bauen, die die Kamera für mich auslöst. Ich mache beruflich etwas völlig anderes und habe mich auch sonst bisher nie mit Elektrotechnik beschäftigt, habe allerdings zu Schulzeiten ein paar Grundkenntnisse in einfachen Programmiersprachen erworben, weshalb mir eine Softwarelösung wesentlich sympathischer war, als ein reiner Hardware-Aufbau.

Es gibt diverse kommerzielle Varianten, die diese Aufgabe wesentlich besser erfüllen und darüber hinaus noch für viele andere Dinge eingesetzt werden können. Das hier ist (auf vielfachen Wunsch) eine Anleitung von einem Laien für andere Laien, die für relativ wenig Geld eine funktionierende Lösung dieses speziellen Problems haben möchten. Ich habe nur wenig Ahnung von dem, was ich hier gebaut habe, deswegen bin ich für Anregungen und Verbesserungsvorschläge von technisch versierteren Menschen dankbar. Ich übernehme keine Verantwortung für Fehlfunktionen, Schäden oder Unfälle, die aus dem Nachbau resultieren.

Grundlage und gleichzeitig teuerstes Element meiner Schaltung ist ein Arduino Uno. Infos und Bezugsquellen finden sich auf http://www.arduino.cc/
Daran angeschlossen sind zwei kleine Schaltungen: die Lichtschranke und der Auslöser für meine Kamera.

Lichtschranke

Aufbau des Senders

benötigt werden
  • Infrarot-LED
  • Widerstand, z.B. 220 Ohm
  • Lüsterklemme (3-fach)
  • Batteriefach für 2 Mignonbatterien mit Anschluss für
  • 9V Batterieanschlusskabel
  • 2 Mignonbatterien oder Akkus

[ATTACH_ERROR="dslrToolsAttachRewrite"]1540921[/ATTACH_ERROR]
[ATTACH_ERROR="dslrToolsAttachRewrite"]1540922[/ATTACH_ERROR]

Batteriekabel ans Batteriefach stecken. An der Lüsterklemme an den beiden äußeren Klemmschrauben wie gezeigt das rote und schwarze Kabel anschließen. Der mittlere Kontakt bleibt auf dieser Seite frei.
Auf der gegenüberliegenden Seite müssen wir den Widerstand und die Infrarot-LED einschrauben. Dazu lösen wir zunächst alle drei dem Batteriekabel gegenüberliegenden Klemmschrauben. Auf der Seite, auf der das rote Batteriekabel angeschlossen ist, wird der Pluspol (also das längere Bein auf der gerundeten Seite der LED) eingesteckt. Der Minuspol (kürzeres Bein auf abgeflachter Seite) kommt in die Mitte. Von der Mitte zum schwarzen Kabel wird dann noch der Widerstand als Verbindung eingeschraubt. Dieser hat keine Polarität, es ist egal wie er gedreht ist. Es bietet sich an, die Beinchen umzubiegen und etwas zu kürzen.
Batterien einlegen würde ich erst, wenn die Lichtschranke fertig ist, weil ein Sender ohne Empfänger bringt nicht sonderlich viel. Außerdem gibt es keinen Ausschalter, weshalb man die Batterien wieder entnehmen sollte, wenn man den Sender nicht benutzt.

Aufbau des Empfängers

benötigt werden
  • Fototransistor
  • Widerstand, z.B. 220 Ohm
  • Lüsterklemme (3-fach)
  • 3 isolierte Drähte, lieber zu lang als zu kurz

[ATTACH_ERROR="dslrToolsAttachRewrite"]1540923[/ATTACH_ERROR]

Der Aufbau ist ähnlich dem Aufbau des Senders. Zunächst die drei Drähte abisolieren und in drei verschiedene Anschlüsse auf einer Seite der Lüsterklemme einschrauben. Gegenüber schrauben wir wie beim Sender einen Widerstand ein. Der Fototransistor sieht so ähnlich aus, wie die LED, nur muss man ihn andersherum einschrauben, d.h. die abgeflachte Seite kommt gegenüber vom roten Draht und die runde Seite in die Mitte.

Die andere Seite der Drähte wird wie folgt ans Arduino angeschlossen:
  • Rot - 5V
  • Schwarz - GND
  • Gelb - A0

Sender und Empfänger müssen sich gegenüberstehen, damit das ganze funktioniert. Ich habe sie einfach auf einen kleinen Holzrest geschraubt.

Kameraauslöser

Auch hier kommen wieder Lüsterklemmen zum Einsatz. Hier wäre ein Lötkolben allerdings tatsächlich hilfreich, weil man dann anstelle der Krokodilklemmen einfach eine 3,5 mm Klinkenbuchse verbauen könnte, das werde ich auch in näherer Zukunft nachholen.

benötigt werden
  • Transistor (Typ N2222)
  • 4 Drähte
  • Lüsterklemme (1-fach)
  • Lüsterklemme (2-fach)
  • 2 Verbindungskabel mit Krokodilklemmen
  • Kameraspezifisches Fernauslösekabel mit 3,5 mm Klinkenstecker auf der anderen Seite (bei mir Canon N3)

[ATTACH_ERROR="dslrToolsAttachRewrite"]1540924[/ATTACH_ERROR]
[ATTACH_ERROR="dslrToolsAttachRewrite"]1540925[/ATTACH_ERROR]

Der Transistor hat 3 Beinchen. Das mittlere wird vorsichtig nach hinten gebogen, die anderen beiden nach vorn (dort ist der Transistor abgeflacht) und leicht zur Seite. Das hintere Beinchen kommt in eine 1-fach-Lüsterklemme, auf der anderen Seite wird ein Draht eingeschraubt. Die beiden vorderen Beinchen kommen in eine 2-fach-Lüsterklemme, auch hier werden auf der anderen Seite Drähte eingeschraubt. Der rote Draht ist allein, auf die andere Seite kommen zwei Drähte, bei mir schwarz.

Die Drähte werden wie folgt ans Arduino angeschlossen:
  • einer der beiden schwarzen Drähte - GND
  • grün - 7

Den zweiten schwarzen Draht und den roten Draht habe ich über Verbindungskabel mit Krokodilklemmen mit meinem Fernauslösekabel verbunden. Hier kommt das rote Kabel an die Spitze des 3,5 mm Steckers und das schwarze Kabel an den unteren Teil. Der mittlere Ring ist für den Autofokus, der wird nicht angeschlossen, weil sowieso manuell fokussiert werden muss.
Wesentlich eleganter wäre es, die beiden Drähte an eine 3,5 mm Klinkenbuchse anzulöten und den Stecker einfach da reinzustecken. Aber hatte ich den fehlenden Lötkolben schon erwähnt? ;)


Programmierung des Arduino

Zunächst auf http://arduino.cc/en/Main/Software die Arduino-Software herunterladen. Es wird Java benötigt, gibts auf http://www.java.com/. Hinweise zur Treiber- und Softwareinstallation finden sich auf http://arduino.cc/en/Guide/HomePage. Nach Treiberinstallation kann das Arduino über ein USB-Kabel an den Computer angeschlossen werden.
Nach dem Starten der Software erscheint ein leeres weißes Feld. Hier wird der folgende Programm-Quelltext eingefügt:

Code:
#define ausloeser 7
#define led 13
#define lichtschranke A0

void setup() {
  pinMode(led, OUTPUT);
  pinMode(ausloeser, OUTPUT);
  digitalWrite(ausloeser, LOW);
  Serial.begin(9600);
  
}

void loop() {
  int schwelle = 40; // Schwellenwert für die Lichtschranke hier festlegen
  int verzoegerung = 120; // Auslöseverzögerung in ms festlegen
  int sensorValue = analogRead(lichtschranke);
  Serial.println(sensorValue, DEC); // Daten der Lichtschranke auf dem Computer ausgeben => darüber Schwellenwert festlegen
  if (sensorValue < schwelle)
   { 
     delay(verzoegerung); // Kameraauslösung verzögern
     digitalWrite(ausloeser, HIGH); // Kameraauslöser betätigen
     digitalWrite(led, HIGH); // LED anmachen zur Bestätigung, dass die Kamera ausgelöst hat
     delay(500); // Kameraauslöser loslassen verzögern
     digitalWrite(ausloeser, LOW); // Kameraauslöser wieder loslassen
     delay(10000); // 10 Sekunden warten, bevor der Trigger wieder "scharf" ist
     digitalWrite(led, LOW); // nach 10 Sekunden auch die LED wieder abschalten
   }
}

Die Werte für die Auslöseschwelle und die Auslöse-Verzögerung werden direkt im Quelltext an den kommentierten Stellen eingegeben. Es gäbe sicherlich komfortablere Lösungen, die ich in näherer Zukunft hier noch anbieten kann. Um die richtigen Werte für den Schwellenwert zu ermitteln, baut man seine Lichtschranke auf und klickt auf das Symbol ganz oben rechts im Programmfenster. Daraufhin sollten eine Menge Zahlen angezeigt werden, die alle relativ nah beieinander liegen. Den Schwellenwert setzt man einfach etwas niedriger an. Die Auslöseverzögerung hängt von der Fallhöhe und evtl. eingestellter Spiegelvorauslösung an der Kamera sowie natürlich vom gewünschten Ergebnis ab.

Ich wünsche viel Spaß beim Basteln!
Für Hinweise von technisch begabteren Menschen zur Schaltung und zur Programmierung des Arduino bin ich wie gesagt dankbar, weil ich im Grunde genommen keine Ahnung von der ganzen Geschichte habe. Zum Schluss noch einige Quellen, die mir sehr geholfen haben:

http://arduino.cc/
https://www.dslr-forum.de/showthread.php?t=714343
http://www.glacialwanderer.com/hobbyrobotics/
http://www.dieelektronikerseite.de/
http://www.hiviz.com/kits/instructions/instructions.htm
https://www.dslr-forum.de/showthread.php?t=407068

Ich bin mir bewusst, dass die Fotos zur Anleitung furchtbar sind, das werde ich bei Gelegenheit nochmal ändern.
 
Zuletzt bearbeitet:
Hier noch ein paar Fotos von meinem Gesamtaufbau, um den Überblick zu erleichtern.

Ich habe die Lichtschranke einfach an den Rest einer Dachlatte geschraubt.

Wasser kommt aus einer 1000 ml Infusionsflasche über ein Infusionssystem, an dessen Ende eine 14G Venenverweilkanüle angeschlossen ist. Als Zuleitung zur Infusionsflasche habe ich eine Perfusorspritze mit 2 Heidelberger-Verlängerungen und einem Dreiwegehahn mittels Kanüle an die Infusionsflasche angeschlossen. Infusionsständer ist ein Trekking-Stock von Lidl. Das Becken ist ein Eigenbau aus einer 2mm Forex-Platte, Silikon und ein paar Metern Klebeband. Die Schraube im Becken ist meine Fokussierhilfe.
 
Zuletzt bearbeitet:
wow Super Projekt! (y)
Ich weiß jetzt nur nicht so genau welchen Arduino man braucht.
Es scheint ja verschiedene Versionen zu geben.
 
Gefällt, Thema abboniert... könntest du die Fotos noch verkleinern?

Oder deinen Text von Hand auf ca. 75 Zeichen umbrechen?

Oder am besten beides!

Das horizontale Scrollen im Browser durch die riesigen Fotos ist nervig... :(

Danke :)
 
Jo, mach ich. Ich vergesse immer mal wieder, dass nicht jeder mit einem großen Monitor unterwegs ist.

EDIT: Habs geändert.
 
Zuletzt bearbeitet:
Hallo,

Erstmal großes Dankeschön! Wirklich super! (y)

Habe seit vorgestern einen Arduino Uno und habe heute mit den Teilen meiner Conrad Lichtschranke und einem noch vorhandenen 2N2222 die Schaltung aufgebaut.

Bin leider nur noch zu einem Trockentest gekommen aber funktioniert wirklich prima. Reagiert auch noch auf kleinste und schnelle Dinge ganz im Gegensatz zu meiner Relaisversion vom großen C.

Hoffe ich kann morgen ein paar Versuche im praktischen Betrieb damit machen :)

Also nochmal: DANKE!

LG Jörg

ps:

Das einzige was ich jetzt noch interessant finden würde und für Versuchebei meinen Bildern brauchen würde, wäre ein Klatschschalter oder Sound-Trigger per Arduino. Aber leider bin ich mit dem Baustein und der Programmierung eines solchen noch ziemlicher Laie. :(
 
Falls ich da mal Interesse dran bekommen sollte, schreibe ich dazu auch noch ein Tutorial. Ich kann mir aber eigentlich nicht vorstellen, dass das sonderlich kompliziert ist. Falls Du Dich selbst ein bisschen einlesen willst, hab ich auf die Schnelle das hier gefunden: http://www.dtic.upf.edu/~jlozano/interfaces/blow_sensor.html und http://www.dtic.upf.edu/~jlozano/interfaces/microphone.html

EDIT:
Bin seit heute auch Lötkolben-Besitzer. Sobald ich den zu sinnvollem Einsatz gebracht habe, gibts hier nochmal ein Update.
 
Zuletzt bearbeitet:
Hallo,

Dank dir schonmal für die Hilfe! :)

Werde mich morgen mal darüber machen ob es nicht möglich ist meinen schon fertig gelöteten hviz Sound-Trigger mit an den Arduino zu packen.

Sollte ja eigentlich gehen in dem man das Signal des Thyristors das normalerweise den Blitz auslöst an den Arduino bekommt.
Nach dem motto wenn auf Pin so und so High dann schalte den Pin für den Transistor wie in deiner Schaltung auf High und der Blitz löst aus. So könnte man auch wieder je nach Wunsch eine Verzögerung mit einbinden.

Das einzige kleine Problem das ich beim Gedanken darüber machen noch habe ist das die Hviz Schaltung ja mit 9V läuft. Und ich nicht gerade der elektro Profi bin. Meine Überlegung wäre so mit Hilfe des Thyristors vom 5V Power pin auf einen Eingang 5V+ als High durchzuschalten, aber so einfach wirds dann wohl auch wieder nicht sein :)

Aber trotzdem nochmal Danke!

LG Jörg
 
Wie Geil!!
...sehr schön zu sehen das ich nicht der Einzige bin der einen kl. Kanll hat :D

Wenn Du aus meiner Gegend kommst, sollte man sich mal treffen :)

Schönes teil!

Gruß Carsten
 
Der Trigger in den Links ist NICHT von mir. Ich orientiere mich nur am Schaltplan.
An diesem Ding kann man ewig weiterbauen.
Wenn es erst mal so läuft, wie ich möchte ist der nächste Schritt ein kleines LCD-Display mit Tastern...
 
Zuletzt bearbeitet:
Update: Magnetventilsteuerung

Inzwischen habe ich mein Projekt ein wenig ausgeweitet und noch ein Magnetventil integriert, um die Tropfen einfacher kontrollieren zu können. Da die Ströme, die beim Schalten des Magnetventils fließen, das Arduino zerstören würden, ist dafür eine kleine Zusatzschaltung notwendig, die allerdings für sich genommen schon komplexer ist, als die Lichtschranke.

Die Selbstentwicklung wäre über meine bescheidenen Elektronikkenntnisse hinausgegangen. Zum Glück gibt es Menschen mit mehr Ahnung, so zum Beispiel Pixelmagier, dessen Schaltung ich 1:1 übernommen habe (im Original hier zu finden). Spätestens an dieser Stelle macht es dann aber leider nicht mehr viel Sinn, mit Lüsterklemmen zu arbeiten.
Ich habe die Schaltung zum Testen auf ein Breadboard gesteckt und dann auf eine kleine Platine gelötet. Dazu habe ich erstmalig in meinem Leben einen Lötkolben in die Hand genommen, hat trotzdem keine halbe Stunde gedauert. Wie das mit dem Löten funktioniert, wird in diesem Video recht gut erklärt, sofern man der englischen Sprache mächtig ist.

Als Ventil habe ich das billigste 12V Gleichstromventil in einem Online-Auktionshaus gekauft, die restlichen Teile kamen von einem großen deutschen Elektronikhändler, der auch einige Ladengeschäfte betreibt. Außerdem benötigt man eine 12V Gleichstromquelle, da bin ich auf ein Netzteil umgestiegen, weil ich keine Lust mehr auf Batterien hatte. Theoretisch wären aber z.B. auch 8 AA-Batterien denkbar, auch dafür gibt es entsprechende Batteriefächer.

Die eigentlich Arbeit war dann, das zugehörige Arduino-Programm zu schreiben. Das wurde deutlich länger, weil die Verzögerung nicht mehr mittels delay() implementiert werden kann, da ansonsten die Lichtschranke nicht schalten kann, während die Tropfenverzögerung am Ventil stattfindet. So ganz komfortabel ist auch dieses Programm nicht, aber es funktioniert.
Ein paar Bemerkungen: die Pins für Ventil und Kamera habe ich gegenüber der ursprünglichen Version verändert, ebenso einige der Variablennamen. Entweder müssen also die Kabel an andere Stellen gesteckt werden oder die Pin-Belegung (im Programm Zeile 3 und 4) muss geändert werden. Die Lichtschranke kalibriert sich jetzt in den ersten zwei Sekunden Programmlaufzeit und legt dann automatisch einen Schwellenwert fest. In der Hauptprogrammschleife wird ganz zu Anfang eine Boolsche Variable auf true gesetzt, diese könnte man bei Bedarf dazu nutzen, die Tropfen nur auf Knopfdruck fallen zu lassen, anstatt alle 10 Sekunden, wie es derzeit implementiert ist. Dazu müsste man dann die Schaltung noch um einen Knopf und einen Widerstand erweitern, was kein großes Problem sein dürfte.

Hier der Quelltext:

Code:
// KONSTANTEN
const int lichtschranken_pin = A0;
const int ventil_pin = 12;
const int kamera_pin = 13;

// VARIABLEN
// Alle Zeiten in Millisekunden angegeben

// Zeitvariablen initalisieren
// Auslöseverzögerung Kamera
long aktuellezeit_ausloeseverzoegerung = 0;
long startzeit_ausloeseverzoegerung = 0;
// Ventil
long aktuellezeit_ventil = 0;
long startzeit_ventil = 0;

// Ventilöffnungszeiten festlegen
int tropfenzeit_1 = 150;
int verschlusszeit_1_2 = 70;
int tropfenzeit_2 = 150;
int verschlusszeit_2_3 = 70;
int tropfenzeit_3 = 150;
int gesamtzeit_tropfserie = tropfenzeit_1 + verschlusszeit_1_2 + tropfenzeit_2 + verschlusszeit_2_3 + tropfenzeit_3 + 500; // für die Inaktivzeit der Lichtschranke, 500 ms Sicherheitsreserve, damit die Lichtschranke nicht durch den dritten Tropfen doch wieder aktiviert werden kann

// Zeit zwischen den Tropfenserien festlegen
int pausenzeit = 10000;

// Auslöseverzögerung festlegen
int ausloeseverzoegerung = 288;

// Aktivierungszeit für Kameraauslöser festlegen
int ausloeser_aktivzeit = 200;

// Lichtschranken-Schwellenwert festlegen
int lichtschranke_messwert;
int lichtschranke_maximum;
int lichtschranke_minimum;
int lichtschranke_schwellenwert;
float lichtschranke_schwellenwertfaktor = 0.85; // Faktor, mit dem der maximale Messwert der Lichtschranke multipliziert wird, um den Schwellenwert zu errechnen, muss unbedingt kleiner als 1 sein!

// Statusvariable Lichtschranke
boolean lichtschranke_unterbrochen = false;

// Statusvariable Kameraauslöser
boolean kamera_ausloeser_aktiv = false;

// Satusvariable Ventil
boolean ventil_offen = false;

// Statusvariable Tropfserie
boolean tropfserie_laeuft = false;

// Statusvariable Tropfen ausgelöst
boolean tropfen_ausgeloest = false;

// Ventilzeiten in Absolutwerte umrechnen
int endzeit_offen_1 = tropfenzeit_1;
int endzeit_geschlossen_1_2 = endzeit_offen_1 + verschlusszeit_1_2;
int endzeit_offen_2 = endzeit_geschlossen_1_2 + tropfenzeit_2;
int endzeit_geschlossen_2_3 = endzeit_offen_2 + verschlusszeit_2_3;
int endzeit_offen_3 = endzeit_geschlossen_2_3 + tropfenzeit_3;
int endzeit_pause = endzeit_offen_3 + pausenzeit;

// Eingabevariable initialisieren
int eingabe;

void setup() {
  // Ausgangspins initialisieren
  pinMode(ventil_pin, OUTPUT); 
  pinMode(kamera_pin, OUTPUT);
  // Serielle Verbindung zum Computer initialisieren für Textausgabe
  Serial.begin(9600);
  Serial.println("Lichtschranke wird kalibiert...");
  // Die ersten zwei Sekunden die Lichtschranke kalibrieren
  while (millis() < 2000) {
    lichtschranke_messwert = analogRead(lichtschranken_pin);
    // Maximalwert speichern
    if (lichtschranke_messwert > lichtschranke_maximum) {
      lichtschranke_maximum = lichtschranke_messwert;
    }
    // Minimalwert speichern, nur fuer den Fall, dass wir den Schwellenwert irgendwann mal anders berechnen wollen
    if (lichtschranke_messwert < lichtschranke_minimum) {
      lichtschranke_minimum = lichtschranke_messwert;
    }
  }
  lichtschranke_schwellenwert = lichtschranke_maximum * lichtschranke_schwellenwertfaktor;
  Serial.print("Leerwert der Lichtschranke: ");
  Serial.println(lichtschranke_maximum);
  Serial.print("Schwellenwert der Lichtschranke: ");
  Serial.println(lichtschranke_schwellenwert);
}

void loop() {
  tropfen_ausgeloest = true;

  // Tropfserie fallen lassen falls ausgelöst
  if (tropfen_ausgeloest == true) {
    aktuellezeit_ventil = millis();
    if (aktuellezeit_ventil - startzeit_ventil < endzeit_offen_1 && ventil_offen == false) {
      digitalWrite(ventil_pin, HIGH);
      ventil_offen = true;
      tropfserie_laeuft = true;
      Serial.println("Tropfen 1 Start, Ventil offen");
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_offen_1 && aktuellezeit_ventil - startzeit_ventil < endzeit_geschlossen_1_2 && ventil_offen == true) {
      digitalWrite(ventil_pin, LOW);
      ventil_offen = false;
      Serial.println("Tropfen 1 Ende, Ventil geschlossen");    
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_geschlossen_1_2 && aktuellezeit_ventil - startzeit_ventil < endzeit_offen_2 && ventil_offen == false) {
      digitalWrite(ventil_pin, HIGH);
      ventil_offen = true;
      Serial.println("Tropfen 2 Start, Ventil offen");
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_offen_2 && aktuellezeit_ventil - startzeit_ventil < endzeit_geschlossen_2_3 && ventil_offen == true) {
      digitalWrite(ventil_pin, LOW);
      ventil_offen = false;
      Serial.println("Tropfen 2 Ende, Ventil geschlossen");        
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_geschlossen_2_3 && aktuellezeit_ventil - startzeit_ventil < endzeit_offen_3 && ventil_offen == false) {
      digitalWrite(ventil_pin, HIGH);
      ventil_offen = true;
      Serial.println("Tropfen 3 Start, Ventil offen");
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_offen_3 && aktuellezeit_ventil - startzeit_ventil < endzeit_pause && ventil_offen == true) {
      digitalWrite(ventil_pin, LOW);
      ventil_offen = false;
      Serial.println("Tropfen 3 Ende, Ventil geschlossen");    
    }
    else if (aktuellezeit_ventil - startzeit_ventil > endzeit_pause) {
      startzeit_ventil = aktuellezeit_ventil;
      tropfserie_laeuft = false;
      lichtschranke_unterbrochen = false;
      Serial.println("Ende der Pause, Startzeit aktualisiert, Lichtschranke wieder scharf");
    }
  }
  
  // Lichtschranke abfragen
    lichtschranke_messwert = analogRead(lichtschranken_pin);
    if (lichtschranke_messwert < lichtschranke_schwellenwert && lichtschranke_unterbrochen == false) {
      Serial.println("Lichtschranke unterbrochen");
      lichtschranke_unterbrochen = true;
      startzeit_ausloeseverzoegerung = millis();
    }
    // Verzögerungszeit abwarten, dann Kamera-Auslöser aktivieren
    aktuellezeit_ausloeseverzoegerung = millis();
    if (aktuellezeit_ausloeseverzoegerung - startzeit_ausloeseverzoegerung > ausloeseverzoegerung && aktuellezeit_ausloeseverzoegerung - startzeit_ausloeseverzoegerung < ausloeseverzoegerung + ausloeser_aktivzeit && kamera_ausloeser_aktiv == false && lichtschranke_unterbrochen == true) {
      digitalWrite(kamera_pin, HIGH);
      kamera_ausloeser_aktiv = true; 
      Serial.println("Kamera-Ausloeser aktiviert");
    }
    // Aktivzeit des Auslösers abwarten, dann Kamera-Auslöser deaktivieren
    else if (aktuellezeit_ausloeseverzoegerung - startzeit_ausloeseverzoegerung > ausloeseverzoegerung + ausloeser_aktivzeit && aktuellezeit_ausloeseverzoegerung - startzeit_ausloeseverzoegerung < gesamtzeit_tropfserie && kamera_ausloeser_aktiv == true) {
      digitalWrite(kamera_pin, LOW);
      kamera_ausloeser_aktiv = false;
      Serial.println("Kamera-Ausloeser deaktiviert");
    }
}

Ich werde auch hierzu noch ein Fototutorial erstellen. Die zusätzlichen Kosten belaufen sich auf unter 20 Euro, wovon etwa 15 auf das Ventil entfallen.

Vorab erstmal für die bastelfreudigeren Menschen unter uns eine Fritzing Skizze und ein Foto von meinem Breadboard, die selbige korrigiert. In Fritzing gibts den von Pixelmagier vorgeschlagenen Optokoppler nicht, deswegen musste ich einen anderen einmalen (mit gestrichelter Linie umrandet). Der von Pixelmagier vorgeschlagene Optokoppler muss wie gezeigt eingesetzt werden, man beachte die kleine Aussparung, die ich unauffällig rot umrandet habe. Die 2 AA-Batterien sollen die 12V Gleichspannungsquelle darstellen. Pluspol rotes Kabel, Minuspol schwarzes Kabel. Das Magnetventil ist das lustige Ding unten in der Mitte, die Polung der Anschlüsse ist zumindest bei dem von mir gekauften Ventil egal.

Ich freue mich über alle Nachbauten, übernehme aber nach wie vor keine Verantwortung für Schäden und Fehlfunktionen. Bei mir funktioniert es aber und mein Haus steht auch noch. Nett wäre natürlich auch, wenn diejenigen, die die Idee noch erweitert oder verändert haben, Fotos und Anregungen hier posten würden.

Beispielfotos, die mit dem System geschossen wurden z.B. hier.
 
Einige Anmerkungen:

Ich bin derzeit dabei, so was Ähnliches aufzubauen: Arduino Uno plus Magnetventil plus Optokoppler um Kamera und Blitz auszulösen.

Eines verstehe ich nicht: wozu brauchst du eine Lichtschranke? Die Tropfen gehorchen der Schwerkraft, es reicht doch nach dem letzten Tropfen den Blitz mit einer gewissen, variablen Verzögerungszeit auszulösen anstatt da noch eine Lichtschranke zu bemühen.

Gehe ich recht in der Annahme dass du nur die Kamera auslöst, also der Blitz an der Kamera hängt? Das wäre aus meiner Sicht eher suboptimal, weil die Auslöseverzögerung der meisten Kameras nicht 100% konstant ist. Blitze lassen sich mit wesentlich kürzeren Verzögerungszeiten und kleinerem Jitter auslösen.

Mein vereinfachter zeitlicher Ablauf sieht übrigens folgendermaßen aus:

Kamera aktivieren (Kamera über Fokuskontakt aufwecken)
Kamera-Verschluss öffnen (bulb)
Ventil öffnen und schließen (evtl mehrfach)
Verzögerungszeit abwarten
Blitz zünden
Kamera-Verschluss schließen
Kamera deaktivieren

Das ganze kann man dann in einer Schleife n-mal laufen lassen und dabei dann diverse Parameter variieren (Tropfengröße, Verzögerung etc).

Die SW ist schon halbwegs fertig, die Sequenz wird auf Tastendruck gestartet. Ich muss nur noch die Verkabelung des Ventils und von Kamera und Blitz fertigstellen.
 
Könntet ihr mir vielleicht irgentwie mitteilen, was für magnetventile ihr verwendet?
Am besten per PN, da händlerlinks ja nicht erwünscht sind.
Ich habe auch evtl. vor sowas zu bauen nur ich bin noch am zusammenrechnen der Preise, da ich im moment etwas knapp bei kasse bin.
 
WERBUNG
Zurück
Oben Unten