YACCBOA - YetAnotherCameraControlerBasedOnArduino

Nabend zusammen,

eigentlich wollte ich mit diesem Post noch etwas warten um etwas "mehr" zeigen zu können. Da ich aber grade über einen essentiellen Punkt des Projektes brüte nehme ich meinen Bedarf an Hilfe zum Anlass dieses Beitrages.


Wie der Name schon vermuten lässt, bastel ich mir einen Controller zur Steuerung meiner DSLR-Kamera. Bin in dem Hobby Fotografie noch recht frisch aber es hat mich ziemlich gepackt. Bei diversen Ausflügen durchs Internet auf der Suche nach Empfehlungen, Techniken, Anleitungen und Ideen bin ich über die Punkte der Tropfenfotografie, High-Speed-Fotografie und Timelapse gestolpert, die beeindruckende Motive zu Tage fördern können. Und da ich von Haus aus "bewegungseffizient" bin möchte ich die Hauptarbeit von der Technik erledigen lassen. Für jeden Punkt gibt es schon separate Lösungen. Die eierlegende Wollmilchsau ist mir dabei aber noch nicht unter gekommen. Grund genug für mich, mein erstes großes Arduino Projekt in Angriff zu nehmen. So entstand die Idee zu YACCBOA!


Was soll der Controller können?

Alles :) Ich unterteile es am besten nach den (bisher) geplanten Funktionen:

Tropfenfotografie:

• Ansteuerung von bis zu drei Ventilen
• Ansteuerung von bis zu drei Blitzen
• Auslösung durch Lichtschranke, Mikrofon, Taster, Gedankenkontrolle? XD

Hochgeschwindigkeitsfotografie:

• Ansteuerung von unterschiedlichsten Auslösern (Servo zum Freilassen eines fallenden Objektes und ähnliches)
• Anteuerung von bis zu drei Blitzen
• Auslösung durch Lichtschranke, Mikrofon, Taster, Gedankenkontrolle? Schon wieder? Ist zur Tropfenfotografie doch nicht so viel anders :)

Timelaps: (hier wird es spannend)

• Auslösen der Camera in vorgegben Intervallen über eine lange (mehrere Stunden sind denkbar) Zeitspanne
• Steuern eines Kameraschlittens zwischen den Fotos für eine Bewegung
• Steuern eines Pan/Tilt-Kopfes zwischen den Fotos für noch mehr Bewegungen :)

Hardware:

• Die Steuerung soll zusammen mit einem Akku in einer möglichst kleinen Box untergebracht werden um autark arbeiten zu können
• Ein 20x4-Zeichen-LCD dient zur Visualisierung der Einstellungen oder des Fortschrittes (beim Timelaps z.B.)
• Bei der Eingabe bin ich mir noch unsicher. Einfache Taster, Drehencoder, Wii-Nunchuck oder Classic-Controller ?
• Anschluss der Peripherie über 3,5mm Klinkenstecker(VCC,GND,Signal) für Blitze, Ventile, Auslöser und Kamera.
• Schlitten und Pan/Tilt-Kopf werden per RJ45-Buchse und Kabel eingebunden. Vielleicht kommt hier sogar ein eigener Controller zum Einsatz.

Was bisher funktioniert:

Wie erwähnt wollte ich mit diesem Post noch etwas warten, weshalb die nachfolgenden Punkte wahrscheinlich bei den meisten ein müdes "Naja" entlocken wird. Aber der Vollständigkeit zur Liebe:

• MenüLib an eigene Bedürfnisse angepasst
• LCD über I2C eingebunden
• Steuerung zur Zeit über Taster (Spannungsteilerprinzip um I/Os zu sparen), Drehencoder oder per Terminal vom PC aus
• Unterprogramme zur Konfiguration der Timelapsaufnahme (ohne Schlitten und Pan/Tilt)

Warum ich mich melde:


Wie oben schon oft geschrieben melde ich mich hier weil ich ein paar essentielle Punkte klären möchte bevor ich später über fiese Fallstricke stolpere.

Ich fürchte, dass die Verbindung zwischen Controller und Peripherie via 3,5mm Klinke eine nette aber keine gute Idee war. Geplant war über das Kabel die Stromversorgung und ein Signalkabel für evtl. benötigte Schaltungen (Lichtschranke, Servo, usw.) verpolungssicher bereit zu stellen. Ich habe aber beim rumspielen gemerkt, dass beim Einstecken und Entfernen der Stecker eben doch Kontakt zwischen anderen Polen herstellen. Mit etwas Disziplin (erst alles Verkabeln, dann einschalten, Verkabelungsreihenfolge beachten) könnte man Probleme zwar umschiffen. Aber ich hätte es gern Idiotensicher. Schließlich will ich damit ja später auch selbst arbeiten ;) Die Buchsen haben zwei Öffner-Kontakte an den beiden vorderen Pins. Diese könnte ich ja per Arduino abfragen. Wird eine Buchse benutzt wird VCC erst nach einer kleinen Verzögerung aufgeschaltet. Damit ließe sich aber auch nur die Arduino-Seite prüfen. Auf Seiten der Sensoren/Aktuatoren besteht dann immer noch die Gefahr, dass ich bein Einstecken VCC/GND/Signal vermische. Welche Auswirkungen das hat lässt sich auf Grund des Noch-Nicht-Vorhanden-Sein schlecht abschätzen.
Hat von euch jemand vielleicht eine brilliante Idee die Verkabelung mit geringem Aufwand Idiot......Arkonsicher zu machen?

Zweiter Punkt, bei dem ich noch unsicher bin, ist die Eingabemethode. Bisher spiele ich gedanklich mit einfachen Buttons (Hoch,Runter,Links,Rechts,Enter,Back), Drehencoder (Erhöhen,Verringern,Bestätigen), Seriell (per Terminal. Soll aber nur optional sein, da ich nicht jedes Mal nen Laptop daneben stehen will) und Wii Nunchuck bzw. ClassicController. Bis auf die Wii-Controller habe ich alles getestet richtig glücklich bin ich noch mit keiner Lösung geworden. Jemand ne Idee?


Aussicht auf Dinge die noch kommen könnten.....

.....sollte ich mit der obrigen Liste in diesem Jahrhundert überhaupt fertig werden.

• Steuerung über HandyApp (Welches Produkt kommt heute noch ohne App aus......Klopapier.....mehr fällt mir nicht ein)
• PC-Interface falls man doch mal zu Hause spielt
• to be continued

Nach ein wenig rumspielen habe ich für mich zur Zeit einen Kompromiss bei der Bedienung gefunden. Die Navigation durch die Menüs und Funktionen werde ich über die Taster (Up,Down,Left,Right,Enter,Back) bewerkstelligen. Zum In- bzw. Dekrementieren von Variablen (Anzahl der Bilder, Dauer der Timelapse, ect.) werde ich einen Drehencoder verwenden. Drehen erhöht die Variablen in groben Schritten (+-5 bei der Anzahl der Bilder, +-10 bei der Dauer der Timelaps). Drehen und drücken des Drehencoder wird für die Feineinstellung genommen.

Für den Slider+Pan/Tilt-Kopf wollte ich neben der Voragbe der Start-,Zwischen- und Endwerte per fester Variabel ein Live-Teach-In vorsehen. Also das System an einen bestimmten Punkt fahren/Ausrichten und diese Werte dann speichern. Diese Bewegung wird wohl ein Wii-Controller (ClassicController) übernehmen welcher an die dedizierte Steuerung für Slider+Pan/Tilt gesteckt wird.

Die Schiene für den Slider habe ich bestellt. Da kommt das, bei anderen Projekten und für diesen Einsatzzweck vorgesehen, DryLin-System von Igus zum Einsatz. Erst mal mit einer Schlittenlänge von 1200mm. Größer werden dürfte Später kein Problem werden :D

Die Bedenken mit der Verbindung via Klinkenstecker verschiebe ich erst einmal, bis der erste Sensor aufgebaut wurde. Dafür muss erst mal das Grundgerüst stehen.

Auch wenn bisher noch niemand geantwortet hat, hoffe ich doch, dass mir jemand bei meiner nächsten Frage hilft ;)

Ich halte mich, gefühlt schon wieder zu lange, an einer Kleinigkeit auf. Ich möchte, während das Programm durchfahren wird, auf dem Display einen Countdown anzeigen. Verbleibende Zeit zur nächsten Auslösung, verbleibende Dauer der aktuellen Auslösung und wer weiß wo sich das noch einbauen lässt. Ich bekomme nur keine vernünftige Ausgabe hin. Ich hab schon Knoten in meinen Windungen und fürchte, dass ich mich mit einem zu komplizierten Weg nur im Kreis drehe. Ein Anstoß von außen wäre daher super ;)

Code:

---

void countdown(unsigned int countdown_sec, unsigned int countdown_mill){
  unsigned int start_mill = millis();
  unsigned int act_sec = 0;
  unsigned int act_mill = millis();
  unsigned int disp_sec = 1;
  int disp_mill = 0;
  unsigned int check_mill = 0;
  int temp_mill = countdown_mill;
  int i = 0;
 
  Serial.println("");
  Serial.println("");
  Serial.println("");
 
  while(!((disp_mill == 0) && (disp_sec == 0)))
  {
//  Serial.print("Schleife");
    act_mill = millis() - start_mill;
    act_sec  = (act_mill / 1000);
    act_mill = ((act_mill - act_sec * 1000)/100);
   
    if(check_mill != act_mill)
    {
      disp_mill = 9 - act_mill - countdown_mill;
      disp_sec = countdown_sec - act_sec -1;
      Serial.print(countdown_sec);
      Serial.print(",");
      Serial.print(countdown_mill);
      Serial.print("          ");
      Serial.print(act_sec);
      Serial.print(",");
      Serial.print(act_mill);
      Serial.print("          ");
      Serial.print(disp_sec);
      Serial.print(",");
      Serial.println(disp_mill);
      check_mill = act_mill;
    }
  }
  while(1)
  {}
}

---

Wie man erkennen kann möchte ich mich auf die Angabe in "Sekunde,Zehntelsekunde" beschränken. Mit einem Countdown der bei X,0 startet ist die Ausgabe fast gut, nur die erste Zehntelsekunde wird verschluckt. Aber bei ungraden Zeiten rutsche ich immer in Minus und komme auf keinen grünen Zweig. Wäre super wenn mal jemand mit dem Zaunpfahl winken könnte wo ich mich verrannt habe.

Führe ich hier Selbstgespräche oder gibt es wenigstens interessierte, schweigende Mitleser? :D

Es hilft scheinbar bei vielen Probleme diese erst ein mal zur Seite zu legen und auf den Geistesblitz zu warten. Dieser traf mich heute. Das größte Problem beim obigen Code war, dass ich es zu kompliziert angegangen bin. Etwas verschlankt und vereinfacht funktioniert nachfolgender Code zufriedenstellend :D

Code:

---

void countdown(unsigned int countdown_sec, unsigned int countdown_mill, unsigned int row, unsigned int col){
  unsigned int start_mill = millis();
  unsigned int check_mill = 0;
  unsigned int act_mill = millis();
  unsigned int disp_sec = countdown_sec;
  unsigned int disp_mill = countdown_mill;
  char buffer[4];


 
  Serial.println("");
  Serial.println("");
  Serial.println("");
 
  while(!((disp_mill == 0) && (disp_sec == 0)))
  {
    act_mill = (millis() - start_mill)/100;
   
    if(check_mill != act_mill)
    {
      lcd.setCursor(row,col);
     
      if(disp_sec<10)
        lcd.print(" ");
       
      sprintf(buffer, "%d,%d", disp_sec, disp_mill);
      lcd.print(buffer);
     
      if(disp_mill == 0)
      {
        disp_sec--;
        disp_mill = 9;
      }
      else
      {
        disp_mill--;
      }
      check_mill = act_mill;
    }
  }
  while(1)
  {}
}

---

Heute kamen meine Bestellungen für den Schlitten. So kann ich auch mechanisch endlich wieder ein bissche basteln. Ich berichte weiter. Ob ihr wollt oder nicht :P

Hallo

Sehr interessant.
Mir kommt es so vor als haetten wir so eine Loesung schon in unserem Hackerspace Bremen.
Komm doch einfach mal vorbei.

KR

Ja, die Aparatur habe ich schon bei der MakerFair gesehen. Wohnort Bremen ist nicht mehr aktuell. Hab es nur verpeilt hier zu ändern. Aber ich muss mal gucken ob ich nicht mal wieder nen Grund finde euch im Space zu besuchen. Mal gucken wie sich das weiterentwickelt hat ;)

Also die Kamerasteuerung (Hardware) habe ich ja schon mal gebaut :
https://www.roboternetz.de/community...blitzsteuerung

Und einen Kameraslider hat sich Michael ja gebaut (gezeigt/gesehen auf der Makerfaire), der steuert die Kamera ja auch sogar komplett über USB.

Wenn Du `ne Mate ausgibst, dann kannst Du uns im Space gerne ausfragen... :-)

Hab deine, und auch andere, Steuerungen schon gesehen und dazu ein bisschen gelesen. Allerdings geht es mir auch um das selber bauen. Ein Professor von mir meinte immer "Kopiert ist nicht gleich kapiert" ;)

Fertige Produkte kaufen möchte ich eigentlich nicht, andere Projekte nachbauen auch ungern, da bei Fehlfunktionen das große Um-Hilfe-betteln los geht. Außerdem lerne ich dabei weniger ;)

Übers Wochenende werde ich mal die Mechanik vom Slider zusammen klöppeln.

@Andree-HB: Ist Mittwochs noch der offene Themenabend?

...vielleicht einfach nur als kleine Hilfe/Gedankestützt der damalige Schaltplan:
http://www.pixelklecks.de/pictures/TriggerControl_2.png

Dienstags ist immer öffentlicher Themenabend, da geht es aber um Workshops
Mittwochs ist Projektabend, aber auch da ist Jeder Besucher herzlich gerne eingeladen. Da kann man soetwas gut "eintüten".

Da nehme ich schon den Weg nach Bremen auf mich um dir ne Mate zu spendieren und du lässt dich nicht blicken :P

Ich stehe im Moment vor dem Problem, das mein roter Faden ziemlich ausfranst. Ich meine damit, dass mir beim Programmieren immer neue Ideen kommen, ich andere Infos darstellen möchte, die Struktur des Menüs abändere und alles immer wieder in Frage stelle. Dadurch drehe ich mich ganz schön im Kreis. Ich muss mich da die Tage mal ran setzen und das Grundgesrüst zu Papier bringen.

Zudem habe ich am Dienstag in Bremen gelernt, dass mein Zahnriemen/Motor-Gespann zu schwach sein wird, um die Kamera in steileren Winkel den Schlitten hoch zu befördern und in den Fotopositionen zu halten. Für den Prototypen wird es wohl erstmal dabei bleiben. Die Endlösung bekommt dann ne Gewindespindel spendiert ;)

*staubwisch*

Soooo.....

In den letzten Wochen bin ich nicht wirklich weiter gekommen. Nicht weil ich vor Problemen bei diesem Projekt stand, sondern weil ein anderes Projekt die höhere Priorität hat (haben den Fuhrpark bei unserer DLRG-Ortsgruppe erneuert und die meisten Umbauten blieben an mir hängen)

In der Zwischenzeit habe ich immer mal ein bisschen dran rum gespielt und getestet und gemacht und getan und und und.

Mittlerweile habe ich mich bei der Hardware für den Prototypen festgelegt. Hauptsächlich kommen Bauteile zum Einsatz, die noch bei mir rumliegen.

In ein kleines Alugehäuse kommen somit:
- Arduino Pro mini
- Arduino Ethernet-Shield (zur steuerung der Funktionen via PC)
- Standart 20x4 LCD mit I2C-Adapter
- 5 Taster zur Steuerung der Funktionen
- 6 Klinkenbuchsen zum Anschluss von Kamera, Blitz, Sensoren, Peripherie
- RJ45 Buchse zur Verbindung mit der Steuereinheit des Sliders
- 850mAh 3s LiPo-Akku für die Stromversorgung


Und während ich das so schreibe frage ich mich ob hier jemand an nem Schrumpfstrahler arbeitet damit ich den granzen Kram überhaupt in dem kleinen Gehäuse unterbringen kann.....

In den kommenden Tagen gibt es endlich mal ein paar Bilder ;) Versprochen.

*staubwisch*

Moinsen,

zuerst wünsche ich obligatorisch jedem Leser hier mal ein frohes neues Jahr.

Über die Feiertage hatte ich endlich mal Zeit und Gelegenheiten mein Projekt voran zu treiben. So hat sich jetzt eine ganze Menge Elektronik in einem kleinen Gehäuse eingefunden und die ersten, grundlegenden Funktionen verrichten ihr Werk. Bitte beachtet, dass es zur Zeit ein Prototyp ist. Dazu im Verlauf mehr.

Anhang 27044
Hier zu sehen das Display und die sechs Knöpfe zur Bedienung. Wahrscheinlich wird es in der finalen Version nur vier Knöpfe geben. Das stellt sich während der kommenden Erprobung heraus. Aber ich denke, dass sowohl für die Navigation im Menü als auch zum Einstellen der Parameter Knöpfe für "Hoch","Runter","Enter" und "Zurück" reichen wird.

Anhang 27045
Auf der Rückseite befinden sich die Anschlüsse. Links beginnend eine 3,5mm Klinkenbuchse für den Anschluss der Kamera.

Dann folgen sechs Eingänge für Sensoren (Licht, Ton, Berührung, Blitz, ect.). Aber auch Servos aus dem Modellbau können hier betrieben werden, um z.B. Gegenstände kontrolliert fallen zu lassen oder mechanisch etwas zu betätigen. Auch hier verwende ich Klinkenbuchsen und -stecker, da ich so über die drei Pins Vcc, GND für die Versorgung der Sensoren und eine Signalleitung für die Auswertung am Arduino habe.

Dann folgen sechs gelbe Cinch-Buchsen für die Ansteuerung von Ventilen für die Tropfenfotografie und deren Verwandte.

Rechts außen befinden sich dann noch drei rote Cinch-Buchsen für die Auslösung von Blitzen. Damit ließen sich während einer Langzeitbelichtung gezielt Blitze auslösen um Bewegungen einzufrieren oder Mehrfachbelichtungen anzufertigen.

Alle Ein- und Ausgänge sollten sich eigentlich separat Auslesen und Ansteuern lassen. Aber wenn der geneigte Leser kurz durchzählt wird er feststellen, dass nicht genügend Pins verfügbar sind. Und da kommen wir zum nächsten Grund, warum dies "nur" ein Prototyp ist :) Denn zusätzlich zu den bisher aufgezählten Signalen werden noch zwei Pins für das I2C-Display benötigt, ein ADC Pin der die Knöpfe ausliest und vier Pins werden für den Slider benötigt.

Slider? Richtig! Über eine RJ45 Buchse wird ein Schrittmotor angeschlossen der einen Schlitten auf einer IGUS-Schiene bewegt. Bilder dazu folgen. Der Antrieb über Zahnriemen rutschte durch, wenn der Schlitten nicht nur horizontal verfahren soll. Darum werde ich eine Gewindestange an den Motor flanschen und über eine Mutter den Schlitten antreiben. Dazu noch zwei Endschalter für die Referenzierung. Somit entsteht ein vorerst einfacher Slider für bewegte Timelapse-Aufnahmen.

Anhang 27046
Neben der RJ45-Buchse ist noch eine Aussparrung angebracht, um die Arduino Pro Mini von außen flashen zu können.

Anhang 27047
Im Inneren sieht es derzeit so aus. Die Anschlüsse für die Sensoren sind noch nicht eingebaut, da ich sie im Moment noch nicht benutzen kann (fehlende Sensorik) Der restliche freie Platz ist für einen Lipo (3s 800mAh) vorgesehen, um das System auch Abseits einer Steckdose betreiben zu können. Für einen Autonomen Einsatz des Sliders muss ich mal gucken, welche Laufzeit mit dem integrierten Akku erreicht werden. Alternativ wird wohl eine Buchse nach außen führen, um zusätzliche Energiespender einbringen zu können.

Das war es vorerst. Die kommenden Tage werden für die Software und erste Probeläufe drauf gehen.

To-Do
- Sensoren aufbauen
- Anschlüsse für Sensoren einbauen
- Slider fertig stellen
- Code, Code und noch mehr Code

Und wenn ich dann einen Status habe der mir gefällt und ich Erfahrungen habe, wie viele Ports ich von welcher Sorte endgültig brauche wird es wohl noch eine professionell gefertigte Platine geben. Kann ja sein, dass noch jemand Interesse an einem YACCBOA hat ;)

Tja......

Ich sitze hier grade vor meinem Aufbau und bin ziemlich ernüchtert. Es tun sich immer neue Baustellen auf....


Die Hardware funktioniert im Prinzip. Die Ventile öffnen, die Blitze blitzen und die Kamera nimmt Bilder auf. ABER! Aber..... aber -_-

Zwei Blitze unterschiedlicher Hersteller haben unterschiedliche Verzögerungen. Daher habe ich zur Zeit noch Doppelbelichtungen. Dies würde sich recht einfach beheben lassen, wenn nicht das zweite, gravierendere Problem wäre.

Die Bibliotheken, die ich für das Menü, LCD oder mein eigener Code haben die blöde Eigenschaft, die Vorgänge nicht im Millisekundenbereich aufeinander abzustimmen. Ich habe den Tropfen immer ein paar Millimeter über der Wasseroberfläche, gar nicht im Bild oder schon die letzten Kräusel auf der Oberfläche. Aber ich schaffe es nicht, das Bild zwischen diesen Momenten zu schießen. Ich vermute, dass irgend ein Teil des Codes die Abläufe so verzögert, dass ich z.B. nur in 10ms-Sekunden springen kann.

Ich vermute, dass es an meinem eigenen Code liegt, da in den Funktionen für den Ablauf (Kamera, Tropfen, Blitz) weder das LCD noch das Menü arbeitet. Ich zähle die Millisekunden per

Code:

---

millis_aktuell = millis() - millis_start;

---

und lasse die entsprechenden Aktionen ausführen wenn eine if-Abfrage erkennt, dass genug ms vergangen sind.

Verwendet wird ein Arduino Pro Mini 16MHz.

Kann mir jemand nen Tipp geben, wie ich Vorgänge auf die Millisekunde genau timen kann?

Das Arduino Pro Mini hat den ATmega328 als µC verbaut. Dieser hat 3 Timerbausteine (2x 8Bit und 1x 16Bit).
Ich würde es damit versuchen.

Entweder du liest das/die Register TCNTx per Hand aus, oder du stellst einen Timer so ein, dass er alle 1ms einen Überlauf hat und einen Interrupt auslöst.

Ich bin mir nicht sicher wo das Problem liegt. Ich habe heute Vormittag den Durchlauf der Funktion mal per

Code:

---

micros_durchlauf_start = micros();
.....
jede menge Code
.....
micros_durchlauf = micros() - micros_durchlauf_start;
Serial.println(micros_durchlauf);

---

gemessen. Dabei werden mir pro Durchlauf 20-28 Microsekunden ausgegeben. Was mich aber stutzig macht ist ein Wert nach ca. 100 Durchläufen aus der Reihe schlägt und mit rund -15500µs angegeben wird. Es ist bei jeden Aufruf der Funktion nur ein einzelner Wert nach ca 100 Durchläufen.


Ich bin mir nicht sicher, ob ein Timer-Interrupt mein Problem lösen wird. Die Funktion scheint ja (meistens) schnell genug zu sein, um sogar mehrmals pro Millisekunde auf ein evtl. auszuführendes Event zu überprüfen. Die ISR müsste ja ähnlich aussehen wie meine bisher verwendete (nachfolgende) Funktion.

Code:

---

void ausloesen(void)
{
  int millis_start = millis();
  int millis_aktuell = millis();
  int status_ventil_open[3] = {0,0,0};
  int status_ventil_closed[3] = {0,0,0};
  int status_blitz = 0;
  int status_sva = 0;
  int status_trigger = 0;
  int timer_blitz = 500;
  int kamera_delay = 82;
  int micros_durchlauf = 0;
  int micros_durchlauf_start = 0;
 


 
  lcd.clear();
  lcd.home();
  lcd.print(valve_delay[1]);
  sva();
 
 
  while(tmp == 0)
  {
    millis_aktuell = millis() - millis_start;
    micros_durchlauf_start = micros();
   
   
//    lcd.setCursor(0,2);
//    lcd.print(millis_aktuell);
   
    // Ventile öffnen
    for(int i = 0; i<valve_amount;i++)
    {   
      if((millis_aktuell > valve_delay[i]) && (status_ventil_open[i] == 0) && (valve_active[i] == 1))
      {
        digitalWrite(+i,HIGH);
        status_ventil_open[i] = 1;
      }
    }
   
    // Ventile schließen
    for(int i=0;i<valve_amount;i++)
    {
      if((millis_aktuell > (valve_delay[i]+valve_size[i])) && status_ventil_closed[i] == 0)
      {
        digitalWrite(+i,LOW);
        status_ventil_closed[i] = 1;
      }
    }
   
    // Kamera auslösen
    if((millis_aktuell > (timer_blitz - kamera_delay) && (status_trigger == 0)))
    {
      digitalWrite(13,HIGH);
      status_trigger = 1;
    }
   
    // Blitze auslösen
    if((millis_aktuell > timer_blitz) && (status_blitz == 0))
    {
      trigger_blitze();
      status_blitz = 1;
    }
   
    micros_durchlauf = micros() - micros_durchlauf_start;
    Serial.println(micros_durchlauf);
    if(millis_aktuell > 2000)
    {
      tmp=1;
      digitalWrite(13,LOW);
      display_setup_valve_delay();
    }
  }
}

---

Okay... ich habe min. 10 mal die Antwort hier verworfen.

Was mich stört, ist das eine menge Lib. aufgerufen werden, die für mich scheinbar der Plattform Arduino als Entwicklungsumgebung abhängig sind.
Korregiere mich, wenn das nicht stimmt.

Ich würde immer noch einfach den 16Bit Timer im Hintergrund mitlaufen lassen und ihn als Zeitgeber nehmen.
Aber ich weiß jetzt nicht, ob Arduino einen so tief in die Hardware des µC rein läst. Sprich ob du einfach das CS11-Bit im TCCR1B Register auf High setzten kannst und das TCNT1 Register einfach auslesen kann, ohne eine aufwendige Funktion zu benutzen.

Sprich so:

Code:

---

unsigned int auslesen;
TCCR1B|=(1<<CS11);
auslesen=TCNT1;

---

Die Anweisungen dauern jeweils meine ich max. 4 Takte.

Daher meine Grundlegende Frage: Kannst du direkt, ohne irgendwelche Funktionen, auf die Register zugreifen?

Hallo,

schickes Gerät, gefällt mir sehr gut. Wollte auf deine PM antworten, aber dein Postfach ist voll.

@Jimmybot Beim Arduino läuft bereits der Timer im Hintergrund im Interrupt als Zeitgeber. Da würde ich nicht dran herum schrauben.

Das Problem liegt vermutlich eher an den Variablen Typen. Millis() und micros() geben 'unsigned long' zurück, du verwendest 'int' (das sind beim Arduino 16Bit Werte). Das kann zu Überläufen und ungeahnten Problemen führen.

Bei meinen Tests habe ich nur schnöde delay() Aufrufe verwendet, will aber auch später millis() verwenden. Brauche ich aber erst wenn ich mehrere Ventile verwende.
Kann meinen Code aber gerne hier posten, falls gewünscht.

LG Peter

Zitat:

---

Zitat von m.a.r.v.i.n

@Jimmybot Beim Arduino läuft bereits der Timer im Hintergrund im Interrupt als Zeitgeber. Da würde ich nicht dran herum schrauben.

---

Wieder was dazu gelernt. Danke für den Hinweis.

Danke für die Antwort. Timer sind, wie schon erwähnt, durch die Arduino IDE zum Teil belegt. Gibt Wege diese freizulegen und zu nutzen. Aber da bin ich noch nicht fit genug für.

Der Hinweis mit den Datentypen ist berechtigt. Hab ich ganz vergessen. Werde ich mir morgen mal Gedanken drüber machen.

PS: Postfach ist wieder frei :)

Zwei Fehler die zu seltsamen Verhalten führten. Zuerst habe ich in der for-Schleife für das Öffnen der Ventile durch ständiges Testen und Ändern nur noch Schwachsinn stehen gehabt. Etwas Schlaf und ein frisches Auge haben dies behoben. Dazu habe ich jetzt die Variablen für millis() als unsigned long initialisiert. Ich hab den Überlauf etwas unterschätzt. Hatte nur im Kopf, dass millis(); nach 49 Tagen überläuft. Ich hab dabei aber ignoriert, dass meine Variablen als Integer schon schneller überlaufen.

Jetzt machen die Ventile was sie sollen. Nur die Wassertropfen muss ich noch bändigen.

Als nächstes steht etwas Optimierung auf dem Plan. Der Code ist kaum kommentiert, ein paar Funktionen lassen sich vereinfachen oder auslagern um sie an mehreren Stelen zu nutzen. Zur Zeit sind 18.740 Bytes (von einem Maximum von 30.720 Bytes) in Gebrauch. Und ein paar Funktionen sollen noch implementiert werden :D

Nachdem der Code endlich arbeitet wie er soll muss ich die Physik noch ein wenig verbiegen. Ich habe oberhalb eines Wasserbeckens drei Magnetventile (Kettenöler) angebracht, über die ich Flüssigkeiten Tropfenweise fallen lasse. Ziel ist es, einen ersten Tropfen fallen zu lassen und dessen, vom Becken aufsteigende Säule, mit einem zweiten Tropfen zu treffen.

Mein Problem ist, dass ich den zweiten Tropfen, aus einem anderen Ventil, nicht über die Säule bekomme sondern immer einen seitlichen Versatz habe. Ich habe die beiden Ventile (mitte und rechts, siehe nächstes Bild) schon so weit zusammen geschoben, dass der Tropfen aus dem mittleren Ventil fast am rechten Ventil hängen bleibt.

Ich könnte die Vorratsbehälter etwas unter Druck setzen, um die Tropfen stärker zu beschleunigen. Allerdings müsste ich dafür noch Ventile dran basteln, die Behälter verschließen (wodurch das Reinigen/Ausspülen/Trocknen erschwert wird) und müsste permanent die Ventile nachstellen, da der Druck nach jedem Tropfen etwas sinkt. Die elegantere Variante wäre dann wahrscheinlich ein gemeinsamer Druckbehälter für alle Flüssigkeitsreservoirs und einen Druckregler, der den Druck konstant hält. Aber das ist mir eigentlich zu viel Bau- und Kostenaufwand.

Jemand ne Idee wie man das Problem lösen könnte?

Hallo Arkon,

die Anhänge aus deinem letzten Post lassen sich nicht öffnen. Aber ich denke ich habe dein Problem verstanden. Einfachste Möglichkeit, die Vorratsbehälter unter Druck zu setzen, wären Luftballons, die man aufgeblasen über die Behälter stülpt. Die richtige Einstellung zu finden wird aber in jedem Fall eine Herausforderung.

Ich konnte mich mit solchen Problemen bisher gar nicht befassen, da mir schlicht die Zeit fehlt. Bin schon bei der nächsten Baustelle. Gerne können wir wieder eine Skype Session abhalten.

Hey Marvin,

das Problem lag nicht an dem fehlenden Druck sondern an der Begebenheit, dass der Schlauch vom Vorratsbehälter zum Ventil einen kleineren Innendurchmesser hatte als der Durchgang des Ventils. Ich habe jetzt an den Ausgang ebenfalls ein Stück Schlauch montiert und dieses in ein Stück Alurohr gesteckt. Ein Bild vom aktuellen Aufbau und die ersten beiden Tropfen:

Anhang 27161Anhang 27162Anhang 27163

Wie oben schon erwähnt bin ich im Moment dabei den Code zu optimieren und sprachlich zu korrigieren. Irgendwie hat sich eine bunte Mischung aus Deutsch und Englisch eingeschlichen. Ich sollte mich da vielleicht mal auf eine Sprache festlegen :)

Als nächstes folgt dann die Ansteuerung für den Slider. Das ist im Moment ja noch nicht sonderlich aufwändig, da wesentlich geringere Anforderungen an das Timing gestellt werden.

Parallel wird der Schaltplan digitalisiert um ihn anschließend hier prüfen und zerpflücken zu lassen. Ich bin gelernter/studierter Mechaniker. Der Teil mit dem Strom besteht daher auf viel Halbwisse, kopierten Schaltplänen und experimenten die ich vom Steckbrett auf Lochraster gebracht habe. Es funktioniert zwar alles wie ich es mir wünsche aber jeder mit etwas mehr Ahnung wird ne Menge Verbesserungsvorschläge finden. Wenn er vor lauter Hände-über-dem-Kopf-zusammen-schlagen nicht schon Kopfschmerzen hat ;)

Ziel ist es eine Platine zu entwickeln, die zum Einen platzsparender ist um neuen Raum für weitere Funktionen zu schaffen und die Reproduzierbarkeit des gesamten Systems zu erhöhen. Würde mich halt freuen, wenn ich jemand anderes mein Projekt näher bringen könnte. Denn so entstehen neue Ideen, Wünsche und Verbesserungen.

Am Wochenende hab ich mich ein bisschen an der Tropfenmaschine ausgetobt, die Grundlagen geübt und die Bedienbarkeit getestet.

Dabei bin ich zu dem Schluss gekommen, dass die nächste Version mit vier Tasten auskommen wird.

Außerdem ist mir ein "Problem" in meinem Konzept des Tropfvorgangs aufgefallen. Ich hatte das Programm so ausgelegt, dass jedes Ventil nur ein einzelnes Mal pro Foto ausgelöst werden kann. Den TaT (Tropfen auf Tropfen) konnte ich so nur erzeugen, wenn ein weiteres Ventil genau ausgerichtet wurde. Da für manche Gebilde drei, vier oder mehr Tropfen auf der gleichen Stelle auftreffen müssten war das Konzept nicht zielführend.

Daher habe ich in den vergangenen Tagen den Code umgeschrieben. Ich kann jetzt sechs Events einstellen wobei ich in jedem einzelnen das zu aktivierende Ventil, dessen Öffnungszeit und die Verzögerung einstellen kann.

Auch den Zeitpunkt des Blitzes kann ich jetzt variieren. Im ursprünglichen Code hatte ich den Blitz fest bei 500ms nach Aufruf der Funktion ausgelöst. Durch die Verzögerung an den Ventilen konnte ich so den zu belichtenden Zustand des Wassergebildes beeinflussen. So lange ich mit zwei Tropfen gearbeitet habe war dies auch zielführend. Doch bei meinen Spielereien der vergangenen Tage habe ich mir häufig gewünscht, den Blitzzeitpunkt zu verschieben, um den Tropfvorgang früher oder später aufzunehmen ohne alle Events einzeln anpassen zu müssen. Also wurde diese Funktion ebenfalls implementiert.

Als nächstes werde ich mir Gedanken über Sensoren machen. Ich möchte mit dem YACCBOA nicht nur Tropfen fotografieren sondern auch andere Vorgänge, die im Bruchteil einer Sekunde ablaufen. Mir fallen da spontan platzende Ballons, explodierendes Feuerwerk, Gewitter, abbrennende Glühlampen und Dinge auf die ich mit meinem Paintballmarkierer schieße ein.

Dafür müssten Nadeln bewegt, Geräusche und Lichtblitze erfasst oder Dinge fallen gelassen werden. An die sechs Klinkenanschlüsse möchte ich also Sensoren und Aktuatoren(hauptsächlich Modellbau-Servos) anschließen. Also werde ich mir als nächstes Gedanken zu ein paar Sensoren machen.

Auf der Liste habe ich:
- Schall (Knall, Klatsch, Klopf)
- Licht (für Gewitter- oder "Sprengstoff"-Blitze)
- Lichtschranke
- Entfernungsmesser
- Berührung

Mit ein/zwei Fragen in die Runde will ich diesen Post dann auch beenden:

Welche Vorgänge würdet ihr mit einer solchen Automation ablichten, bzw. welche Funktionen würden euch interessieren?
Welche Art von Sensor könnte man noch benötigen?

Rund einen Monat später möchte ich nur ein kurzes Lebenszeichen von mir und diesem Projekt in die Welt schicken.

Sonderlich viel hat sich nicht getan, da das Ehrenamt im Moment wieder mit Arbeit um sich wirft und leider eine höhere Priorität geniest.

Ich habe am mechanischen Teil der Apparatur gebastelt um die Ventile besser ausrichten zu können. Meinen Kameraschlitten habe ich zusammen gebaut und leicht modifiziert. Leider ist mir der Steppertreiber (Pololu A4988) verstorben, da ich die Motorsversorgung fest verlötet habe und die Schaltung mehrmals ohne Motor in Betrieb genommen habe.

Zur Zeit findet ein wenig theoretische Arbeit statt. Ich arbeite mich in Eagle ein, um die Platinen nicht mehr auf Lochraster aufbauen zu müssen und so dem Platzmangel im Gehäuse entgegen wirken zu können. Dabei wir die Schaltung etwas optimiert um den Mangel an I/Os am Arduino zu kompensieren.

Die neue Schaltung würde ich bei Gelegenheit hier gerne einmal einstellen und von den Profis zerpflücken lassen. Wie schon einmal geschrieben besteht meine Schaltungsentwicklung aus viel Google, gefährlichem Halbwissen und Try&Error -_-