Hallo allerseits,

eigentlich wollte ich heute die Motorfokussierung für den Lunt testen. Aber meisten kommt es anders und zweiten als man denkt. Das Programm zur Steuerung lief korrekt, aber der Auszug machte, was er wollte aber nicht wa er sollte. Die Ursache war schnell gefunden. Die feststellbare Kupplung war immer nur eine Rutschkupplung. Da muss ich noch ein Teil verändern, ist aber kein Problem.

Ich habe dann per Hand fokussiert, und da kam das zweite Problem. Ich habe nicht den übliche Kontrast erreicht. Kann sein, dass das Verhältnis Empfindlichkeit zu Belichtungszeit ungünstig war. Da hatte ich aber keine Zeit mehr zum Testen.

Durch den geringen Kontrast rauscht es natürlich. Es sieht aber auch aus, als ob da Streulicht mit vorhanden ist.

DMK51, AVI 400 Bilder, 20 mm Okular, 40 mm Projektion.

Hallo Rudi,

Kolibri habe ich hier noch nicht gesehen, aber Fledermäuse gibt es hier. Da das im Dunklen aufgenommen wurde, wird es wohl eine Maus mit Flügeln sein.

Hallo allerseits,

eigentlich wollte ich das Tier filmen, was sich die ausgelegten Äpfel holt. Ist sicherlich ein Igel. Aber da ging mir was ganz anderes in die Fotofalle:

Ufo

Wem es zu schnell ist, ein einzelnes Bild:

Hallo Detlev,

> jetzt hab ich aber ein wenig ein schlechtes Gewissen weil ich dir diesen Floh ins Ohr gesetzt habe...

Da mach dir mal keine Sorgen, das war so geplant. Die Anzeigen brauchte ich für mein nächstes Projekt.

Eigentlich gab es nur ein Problem, dass war eine funktionierende "LiquidCrystal_I2C" zu finden. Es kamen entweder Fehlermeldungen, die ich nicht deuten konnte oder es kam der Fehler "302". Den kenne ich mittlerweile, nur mit dem Beheben ist es nicht so leicht, fast unmöglich. Die Fehlermeldungen kommen ja auch meistens nicht für die Zeile, in der der Fehler steckt.

> Hut ab vor deiner Lernkurve!

So toll war das nicht. Auch wenn der Umgang mit C für mich Neuland war (ist), Programmieren war ja mal (vor vielen Jahren) ein Teil meiner Arbeit. Ich weiß nicht, wie viele tausende Programmzeilen ich geschrieben habe. Nur waren die auf Maschinenebene.

Aber wenn man das lehrbuchmäßig gemacht hat, dann gab es da auch nur Folgen, Alternativen und Zyklen. Das habe ich auch in C wiedergefunden. Auch die Programmierung in Ebenen ließ sich realisieren (Ablaufsteuerung, Hauptprogramme, Unterprogramme). Ich musste das nur alles wieder im Gedächtnis suchen . . .

Hallo allerseits,

es hat mir keine Ruhe gelassen und so ist die Version 3 vom Debugger entstanden. Der Unterschied ist die verwendete Anzeige. In dem Fall eine LCD 1602A 16x2. Angesteuert über ein I2C Modul.

Der Anschluss des Moduls:

GND -> GND ; VCC -> 5V ; SDA -> A4 (Daten) ; SCL -> A5 (Takt)

Ansonsten alles wie in der Version 2.

Die Programme können hier geladen werden: Programme Debugger V3

Hallo Detlev,

das mit den LCD-Anzeigen kommt vielleicht mal später. Jetzt versuche ich mich erst mal in die Programmiersprache einzuarbeiten. Da kommt es mir in erster Linie darauf an, jeden einzelnen Schritt zu verstehen. Auch wenn die von mir verwendete Lösung in den einen oder anderen Schritt umständlich ist, ich weiß genau was dabei passiert.

Ich habe die Zeit, den Weg so zu gehen. Außerdem macht es mir mehr Spaß, selber etwas in die Reihe zu bekommen. Sicherlich werde ich mich auch in der Zukunft mit solchen Anzeigen und dem I2C Protokoll beschäftigen. Aber eins nach dem anderen.

Hallo Detlev,

wie versprochen die Beschreibung des Debuggers:

Die verwendeten Programme können hier geladen werden: Programme Debugger

Der Debugger besteht aus zwei Teilen, einen Sender und einen Empfänger.

Der Sender ist ein Arduino UNO. Auf diesen läuft das zu überprüfende Programm. In diesem Programm kann man beliebig viele Haltepunkte setzen. Bei Erreichen eines Haltepunktes wird das zu untersuchende Programm gestoppt und bis zu 4 Parameter an den Empfänger gesendet.

Durch den Sender kann bestimmt werden, wann das zu untersuchende Programm wieder weiter läuft.

Der Empfänger ist ebenfalls ein Arduino UNO. Dieser steuert eine 4-Stellige 7-Segment Anzeige an. Außerdem befindet sich dort ein Taster. Nach Übermittlung der Daten wird der erste Parameter angezeigt. Nach einem Tastendruck wechselt die Anzeige auf den zweiten Parameter usw.

Nach dem vierten Parameter erlischt die Anzeige. Ein weiterer Tastendruck startet das zu untersuchende Programm wieder.

Während der Datenübertragung leuchtet jeweils ein Segment A. Bei der ersten Ziffer das rechte, bei der zweiten das nächste Segment A usw.

Bei kleinen Ziffern geht das sehr schnell. Bei 9999 dauert es in etwa eine Sekunde.

Aufgebaut sieht der Empfänger bei mir so aus:

Die Anschlüsse sind wie folgt verschaltet:

Digital 0 = Daten

Digital 2 = 1 KOhm Segment A

Digital 3 = 1 KOhm Segment B

Digital 4 = 1 KOhm Segment C

Digital 5 = 1 KOhm Segment D

Digital 6 = 1 KOhm Segment E

Digital 7 = 1 KOhm Segment F

Digital 8 = 1 KOhm Segment G

Digital 9 = Taster gegen GND

Digital 10 = Digit 4

Digital 11 = Digit 3

Digital 12 = Digit 2

Digital 13 = Digit 1

Die Lage der Segmente ist im Kopf des Programmes beschrieben. Das Programm für den Empfänger ist debug_empfaenger_V2.ino.

Bei Digital 0 (Daten) ist noch folgendes zu beachten:

An diesen Pin müssen zwei Widerstände angeschlossen werden. Ein Widerstand (6,8 KOhm, ist nicht kritisch) an GDN. Es kann sein, dass sowohl das Daten-Pin beim Sender und Empfänger auf Eingang geschaltet sind. Dann tritt ein nicht definierter Zustand ein der zu Funktionsstörungen führen kann.

Der zweite Widerstand (270 Ohm) liegt in Reihe zwischen den beiden Daten-Pin. Ich kann nicht ausschließen, dass kurzeitig beide Daten-Pin auf Ausgang geschaltet sind und unterschiedliches Potenzial führen. Das kann zu Zerstörung der Ausgänge führen.

Digit 1 ist die linke Ziffer. Als Anzeige wurde ein LTC-4727 (gemeinsame Katode) verwendet. Die Begrenzungswiderstände betragen jeweils 1 KOhm. Das reicht für die verwendete Anzeige vollkommen aus.

Das Programmpaket für den Sender besteht aus drei Programmen:

debug_sender_v2.ino -> Hier kann das zu überprüfende Programm rein geschrieben werden.

programm.ino -> Dieses Programm läuft nach erreichen eines Haltepunktes im Hintergrund und erledigt den Datenaustausch.

up1.h -> In diesen Programm werden die für Programm.ino benötigten Variablen deklariert.

Alle drei Programme müssen sich im gleichen Ordner befinden. Gestartet wird der Sender mit debug_sender_v2.ino. Das Programm kann beliebig umbenannt werden. Sinnvollerweise nach dem Start mit „Speichern unter“. Dann wird automatisch ein neuer Ordner angelegt. In ihm befinden sich dann gleich alle drei Programme.

Nach dem Start sollte sich folgendes Bild zeigen:

Wichtig, dass alle drei Programm zu sehen sind.

Auch beim Sender sollte das Daten-Pin mit einen 6,8 KOhm Widerstand gegen GND gezogen werden. Im Prinzip ist es egal, welches Port man wählt. Es muss dann nur in up.h (int deb_daten=13;) geändert werden.

Die 13 habe ich gewählt, weil eine LED auf dem Bord mit diesem Pin verbunden ist. Man kann dann sehen, ob gesendet wird.

Zur Funktion müssen beide Bords mit dem GND, so wie die Daten-Pin über den Widerstand (270 Ohm) verbunden sein.

Beim Übertragen der Programme muss die Datenleitung getrennt sein. Mache ich das nicht, kann ich den Rechner neu starten. Er erkennt die USB Schnittstelle nicht mehr.

Es ist günstig, gleich am Anfang einen Haltepunkt zu setzen. Das ermöglicht, das zu untersuchende Programm definiert zu starten.

Verwendet man mehrere HP macht es Sinn, als erstes Parameter die Nummer des HP zu übertragen.

Der Datenaustausch erfolgt nach folgendem Muster:

Am Anfang ist der Daten-Pin des Empfängers auf Eingang geschaltet.

Nach erreichen eines Haltepunktes wird der Pin des Senders auf Ausgang geschaltet. Es wird ein Start-Bit gesendet. Dann erfolgt das Senden des ersten Datenpaketes als Mäander.

Nach dem ersten Datenpaket kommt eine Pause. Diese wird vom Empfänger erkannt und die nachfolgenden Daten dem zweiten Parameter zugeordnet.

Die Übertragung des zweiten Parameters beginnt wieder mit einen Start-Bit. Das ist nötig, da sonst eine Null nicht übertragen werden kann.

Nach Übertragung des 4. Paketes schaltet das Daten-Pin des Senders auf Eingang, dass des Empfängers auf Ausgang (LOW),

Nach der Darstellung der Ziffern und dem Start mit dem Taster, wird ein HIGH vom Empfänger gesendet und danach das Daten-Pin wieder auf Eingang geschaltet.

Das gesendete HIGH ist für den Sender das Signal, das zu untersuchende Programm wieder frei zu geben und das Spiel beginnt wieder von vorn.

Implementiert man den Sender auf einen anderen Typ des Arduino kann die Pausenerkennung kritisch sein (while (zw3 < 100);.). Dann muss man die 100 ändern. Ist die Ziffer zu klein, wird das erste Parameter entweder als 0 oder 1 dargestellt, unabhängig was gesendet wurde.

Ist sie zu groß, kommen nur undefinierte Werte an. Diese Zeile existiert 4 mal.

Ich hoffe das war jetzt nicht zu großes Kauderwelsch. Bei Fragen fragen . . .

Auch wenn ich auf dem Gebiet der Programmierung (Assembler, Maschine) jahrelang (lang ist es her) gearbeitet habe, ist diese Art für mich Neuland. Für Ratschläge bin ich dankbar. Es würde mich auch interessieren, wenn es jemand zum Laufen gebracht hat und es anwendet.

Nicht dass das missverstanden wird. Ich will das nicht verkaufen, sondern bei Interesse stelle ich die Programme und die Bauanleitung ein.

Hallo allerseits,

hat jemand Interesse an einen solchen Debugger? Der besteht aus zwei Rechnern. In dem einen kann man sein Programm testen. Dazu kann man beliebig viele Haltepunkte setzen. Bei jedem Haltepunkt kann man bis zu 4 beliebige Parameter darstellen. Wird ein Haltepunkt erreicht, wird das Programm gestoppt und die Parameter an einem zweiten Rechner (UNO) übergeben. Wenn man sich die Parameter angesehen hat, gibt der Haltepunkt das zu untersuchende Programm wieder frei.

Der zweite Rechner stellt die Parameter auf einer 4-Stelligen Anzeige nacheinander dar. Durch Tastendruck wechselt die Anzeige.

Zur Datenübertragung wird nur ein Digitaler Port benötigt.

Hallo allerseits,

das schöne Wetter ausnutzend war ich gestern mal wieder unterwegs. Der Hammerbach in Bad Düben war die Kulisse für folgende Aufnahmen:

Hallo Karl-heinz,

eine Frage zu deinem Bild, wie hoch war dann die Brennweite?

Hallo Thomas,

deine Bilder machen mal wieder Lust auf Mond. Aber das ist mir zur Zeit draußen alles zu kalt.

Hallo allerseits,

bei den Sonnenaufnahmen ist das Fokussieren mit dem Newton ziemlich umständlich. Man kraucht in die Box mit dem Rechner (sonst sieht man ja nichts), versucht dann mit einer Hand den Auszug zu erreichen. Stößt irgend wo an und alles wackelt. Durch das Seeing am Tag ist so schon kaum der Fokus zu finden. Deshalb möchte ich das mit einem Schrittmotor steuern.

Als Motor soll ein 5V 4 Phasen Schrittmotor (Getriebe) mit dem Modul ULN2003zu Einsatz kommen. Die Steuerung über einen Arduino. Das kostet zusammen nicht mal 10 Euro. Schneller Vor- und Rücklauf. Ebenfalls langsamer Vor- und Rücklauf. Man kann eine Position abspeichern. Es wird angezeigt, ob man sich vor oder hinter der gespeicherten Position befindet. Weiterhin kann man automatisch zu diese Position fahren.

Ich stelle das Programm unten ein. Sicherlich kann man das eine oder andere anders machen, ist mein erstes Programm in C.

Das Programm:

// Übersetzung des Motors 1/64, 512 Schritte für eine Umdrehung

//Namen für Ausgabe Motor

int aus1=8;int aus2=9;int aus3=10;int aus4=11;

//Namen Lage zum gespeicherten Wert

int vor_speicher=12;int nach_speicher=13;

int ausgabe_motor [8][8] ={{1,0,0,0,1,0,0,1},

{1,1,0,0,0,0,0,1},

{0,1,0,0,0,0,1,1},

{0,1,1,0,0,0,1,0},

{0,0,1,0,0,1,1,0},

{0,0,1,1,0,1,0,0},

{0,0,0,1,1,1,0,0},

{1,0,0,1,1,0,0,0},};

//Namen für Eingänge

int schalter_schnell_vor=2;int schalter_schnell_ruek=3;int schalter_langsam_vor=4;

int schalter_langsam_ruek=5;int schalter_merken=6;int schalter_home=7;

//Variable

int zw=0;long stellung=0; long speicher=0; long maxwert=10000; int tempo=0; //maxwert begrenzt die Anzahl der möglichen Schritte

int schnell=2; int langsam=10;

//---------------------------------------------------------------------------------------

void setup() {

// Motorausgänge

pinMode (aus1,OUTPUT);pinMode (aus2,OUTPUT);pinMode (aus3,OUTPUT);pinMode (aus4,OUTPUT);

// Lage zum gespeicherten Wert

pinMode (vor_speicher,OUTPUT);pinMode (nach_speicher,OUTPUT);

//Tasteneingänge

pinMode(schalter_schnell_vor,INPUT);pinMode(schalter_schnell_ruek,INPUT);

pinMode(schalter_langsam_vor,INPUT);pinMode(schalter_langsam_ruek,INPUT);

pinMode(schalter_merken,INPUT);pinMode(schalter_home,INPUT);

//interner Pullup

digitalWrite (schalter_schnell_vor,HIGH);digitalWrite (schalter_schnell_ruek,HIGH);

digitalWrite (schalter_langsam_vor,HIGH);digitalWrite (schalter_langsam_ruek,HIGH);

digitalWrite (schalter_merken,HIGH);digitalWrite (schalter_home,HIGH);

}

//-----------------------------------------------------------------------------------

void loop() {

//Tastaturabfrage Bewegung

if(digitalRead(schalter_schnell_vor)==0){tempo=schnell;vor();}

if(digitalRead(schalter_schnell_ruek)==0){tempo=schnell;ruek();}

if(digitalRead(schalter_langsam_vor)==0){tempo=langsam;vor();}

if(digitalRead(schalter_langsam_ruek)==0){tempo=langsam;ruek();}

//Tastaturabfrage Speicher

if(digitalRead(schalter_merken)==0){speicher=stellung;}

//Tastaturabfrage Home

if(digitalRead(schalter_home)==0&&stellung<speicher)

{tempo=schnell;

do{vor();}

while(stellung!=speicher);

}

if(digitalRead(schalter_home)==0&&stellung>speicher)

{tempo=schnell;

do{ruek();}

while(stellung!=speicher);

}

//Tastaturabfrage Motor aus

if(digitalRead(schalter_schnell_vor)==1&&digitalRead(schalter_schnell_ruek)==1&&

digitalRead(schalter_langsam_vor)==1&&digitalRead(schalter_langsam_ruek)==1&&

digitalRead(schalter_home)==1)

//Motor aus

{delay(tempo);digitalWrite(aus1,0);digitalWrite(aus2,0);digitalWrite(aus3,0);digitalWrite(aus4,0);}

//Lage zum Speicher

if (stellung<=speicher){digitalWrite (vor_speicher,1);}

else {digitalWrite (vor_speicher,0);}

if (stellung>=speicher){digitalWrite (nach_speicher,1);}

else {digitalWrite (nach_speicher,0);}

}

// -------------------------- Unterprogramme ---------------------------------------------------

void vor(){

if (stellung<maxwert){

zw=0;

do{

digitalWrite(aus1,ausgabe_motor[zw][0]);digitalWrite(aus2,ausgabe_motor[zw][1]);

digitalWrite(aus3,ausgabe_motor[zw][2]);digitalWrite(aus4,ausgabe_motor[zw][3]);

delay(tempo);

zw++;

}while(zw<8);

stellung++;

}}

void ruek(){

if (stellung>0){

zw=0;

do{

digitalWrite(aus1,ausgabe_motor[zw][4]);digitalWrite(aus2,ausgabe_motor[zw][5]);

digitalWrite(aus3,ausgabe_motor[zw][6]);digitalWrite(aus4,ausgabe_motor[zw][7]);

delay(tempo);

zw++;

}while(zw<8);

stellung--;

}}

//HUK 2018

Hallo Detlev,

Das sind alles HDR-Bilder. Da braucht man schon eine Weile bis die Aufnahmen im Kasten sind. Mit Handschuhe geht das leider nicht. Zum Schluss habe ich meine Finger nicht mehr gespürt, aber als die dann wieder warm wurden . . .

Hallo allerseits,

trotz einem eisigen Wind habe ich mich heute mal raus getraut. Auf etwas Sonne für die Bilder hatte ich gehofft, aber Klärchen war anderer Auffassung. Im Nachhinein, vielleicht war es auch besser so. Ob ich die Kontraste bei Sonnenschein bewältigt hätte, da bin ich mir nicht sicher.

Auch von mir alles Gute zum Neuen Jahr und dass der Himmel, wenn es darauf ankommt, nicht mit Wolken verhangen ist!

Auf dem zweiten Bild ist ein Marder. Ich werde wohl Mal wieder eine Falle aufstellen müssen.

Hallo allerseits,

Leider interessieren sich nicht nur die Igel für die Häuser. Es kommen auch ungebetene Gäste:

Hallo Lars,

von alleine gehen die Igel nicht rein. Wie packen reichlich Blätter rein und dann kommt noch ein kleines Schälchen mit Igelfutter in die Schlafkammer. Das klappt immer.

Hallo allerseits,

nachdem sich die beiden Igel um des Haus gestritten haben, habe ich noch ein zweites gebaut. Es wurde in der zweiten Nacht angenommen und auch schon eingerichtet:

Einzug ins neuer Heim

Der hat die ganze Nacht geschuftet und die Kamera hat über 50 mal ausgelöst.