Rund übers Eck - Das große Signalwippen mit selbstgestricktem Arduino DCC Decoder !!

Bereich zur Vorstellung der eigenen Modellbahnanlage.

Gewünscht sind insbesondere Fotos, technische Daten, Gleispläne und evtl. auch Berichte über die Entstehung. Die Anlage sollte in einem "vorzeigbaren Zustand" sein, für reine Rohbauberichte ist das Forum "Anlagenbau".

Bitte startet in diesem Bereich für jede Anlage einen eigenen Thread!
Benutzeravatar

-me-
ICE-Sprinter
Beiträge: 5227
Registriert: Mo 28. Apr 2008, 07:37
Nenngröße: H0
Stromart: digital
Steuerung: CS 2 & iTrain 4
Gleise: Dreileiter C-Gleis
Wohnort: Hamm (Westfalen)
Alter: 51
Kontaktdaten:
Deutschland

Re: Rund übers Eck - die ultimative Schaltung für ABC-Bremsen

#176

Beitrag von -me- »

Hallo Martin,
warum nutzt du in Verbindung mit TC Bremsmodule?
Entschuldige, dass ich frage, aber ich denke, dass man mit den vorhandenen Rückmeldern auch einen Betrieb in TC ohne Bremsmodue hinbekommen würde. TC beherrscht doch alle möglichen Arten, eine Lok zum Stehen zu bekommen. Da geht doch auch die Bremsrampe (heißt bei iTrain so) und damit dürfte das doch einigermaßen kompatibel zu deinen Rückmeldern sein.
Ich kenne mich mit TC nur sehr wenig aus, habe das nur im Anfang meiner "Software-Orientierungsphase" ausprobiert, aber der Funktionsumfang sollte doch dem von iTrain entsprechen, und da habe ich anfangs auch mit den Rückmeldern meiner geplanten Rückmeldemodule gearbeitet.
Und das hat problemlos funktioniert.

Ansonsten scheinst du da was nettes erschaffen zu haben, bzw. es noch zu erschaffen. Da klinke ich mich mal ein.
Schöne Grüße vom Ponyhof.

Michael

Und hier geht es von Immental zum Ponyhof

Beleuchtung digtal schalten

SdaP Selbsthilfegruppe der anonymen Pflastersteinsüchtigen


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - die ultimative Schaltung für ABC-Bremsen

#177

Beitrag von Domapi »

Hallo Michael,

auf meiner Anlage kommt Traincontroller nur für die Nebenstrecke zum Einsatz und demnächst noch für den BW-Bereich.
Diese Anlagenteile verfügen über echte DCC-Rückmelder.

Die Hauptstrecke, im Prinzip ein verschlungener Hundeknochen - also quasi Kreisverkehr, ist aus historischen Gründen analog über Relais gesteuert (die selbst-entwickelte Steuerung hatte ich noch von meiner N-Spur-Anlage übrig).

Als ich vor ein paar Jahren wieder in die Modellbahn eingestiegen bin, war noch keine PC-Steuerung geplant. Ich hatte ehrlich gesagt auch kein Vertrauen, dass das reibungslos funktionieren kann.

Nachdem die analoge Steuerung ziemlich ausgeklügelt ist (mehrere zufallsgesteuerte Schattenbahnhöfe etc.) und hervorragend funktioniert, gibt es aktuell keine Notwendigkeit, diese auch noch auf TC9 umzustellen. Und das ABC-Bremsen funktioniert ja mittlerweile nahezu perfekt.

Falls ich nochmals eine so große Anlage bauen würde, wäre natürlich eine Softwaresteuerung mein Favorit. Meine Erfahrung mit Traincontroller sind durchwegs positiv, v.a. auch bei der Betriebssicherheit.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#178

Beitrag von Domapi »

Aufgrund der Urlaubszeit geht es nur schleppend voran in meinem Keller. Da freut man sich auch über eine paar Kleinigkeiten.

Ab und an muss man doch einmal an den Loks herumdoktern und Firmware-Updates durchführen, CVs im großen Stil anpassen bzw. Sicherungskopien machen. Das dauernde Umgestöpsel der Kabel hatte mich genervt - die Anschlüsse werden dadurch ja nicht besser.

Daher habe ich für das Programmiergleis provisorisch einen Drehschalter mit zwei Schaltebenen eingebaut, der das Gleis wahlweise mit der ECoS, mit dem ESU Lokprogrammer oder meinem Zimo MXULFA verbinden kann. Der Drehschalter kommt später dann in das endgültige Stellpult.

Bei dieser Gelegenheit habe ich gleich mal mein neues Dymo Etikettierungssystem ausprobiert. Endlich mal vernünftige Beschriftungen von Anschlüssen, Weichen usw. :!: Hilft gerade im Untergrund, sich besser zurechtzufinden.

Bild

Im Untergrund habe ich auch einige herkömmliche Schraubanschlussklemmen durch benutzerfreundliche wago-Klemmen (Serie 221) ersetzt. Damit entfällt das Schrauben und die Kontaktsicherheit ist meines Erachtens auch besser. Die Klemmen eignen sich auch gut zur Stromverteilung, wenn man z.B. zwei 5-polige in den dazu passenden Befestigungsrahmen montiert.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Benutzeravatar

N Bahnwurfn
InterCityExpress (ICE)
Beiträge: 2476
Registriert: Mo 28. Mai 2012, 16:07
Nenngröße: N
Stromart: DC
Steuerung: Analog
Gleise: Fleischmann Picolo
Wohnort: Berlin
Alter: 69
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#179

Beitrag von N Bahnwurfn »

Hallo Martin,

von dem ganzen digitalen Programierkram habe ich leider keine Ahnung :roll: , aber dein Dymo Etikettierungssystem interessiert mich. :)

Sind die beschrifteten Schilder auch gleich mit einer Klebefläche (von Rückseite Folie abziehen und anpappen) versehen und lassen sich so eventuell auch dauerhaft an Drähten befestigen, oder müssen sie mit handelsüblichem Alleskleber befestigt werden ?

MfG Peter


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#180

Beitrag von Domapi »

Die Etiketten haben hinten eine Kleberbeschichtung. Mittig um einen Draht gelegt und die beiden Klebeseiten zusammengelegt hält wunderbar. Wie dauerhaft kann ich noch nicht sagen.

Der Klebefilm haftet gut auf glatten Flächen. Bei Sperrholz- oder Korkoberflächen hält der Kleber eher schlecht.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Benutzeravatar

N Bahnwurfn
InterCityExpress (ICE)
Beiträge: 2476
Registriert: Mo 28. Mai 2012, 16:07
Nenngröße: N
Stromart: DC
Steuerung: Analog
Gleise: Fleischmann Picolo
Wohnort: Berlin
Alter: 69
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#181

Beitrag von N Bahnwurfn »

Hallo Martin,

danke für die Info. Ist genau das was ich suche. Was die Klebekraft auf Sperrholz betrifft ist sie vieleicht besser wenn das Holz gestrichen wird.
Da entsteht dann eine einigermaßen glatte Oberfläche. Mit Panzerband hat man jedenfalls einen guten Halt. Leider kann man das aber nur mit Kuli oder Edding beschriften und die bleichen mit der Zeit aus, bis nix mehr zu sehen ist.

MfG Peter


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#182

Beitrag von Domapi »

Es gibt offensichtlich auch Bänder mit höherer Klebekraft. Habe mir mal eines bestellt. Werde berichten.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Benutzeravatar

modellbahnelektronik
EuroCity (EC)
Beiträge: 1275
Registriert: Sa 6. Mai 2017, 08:07
Nenngröße: H0
Stromart: digital
Steuerung: Intellibox 2 / SpDrS60
Gleise: Roco / Tillig
Wohnort: Hagen
Alter: 42
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#183

Beitrag von modellbahnelektronik »

Moin

Da komme ich mal auf einen Gegenbesuch vorbei.
Habe gesehn du baust auch viel selber an Elektronik

Meine höchste Entwicklung ist eine Rechner SPS auf einem Microcontroller basierend
dieser steuert, oder mehrer Davon meine komplette Anlage.
Das ABC Verfahren war leider damals noch nicht so weit, deswegen habe ich mich für den Bremsbooster entschieden.

:gfm:

Grüsse
Patrick
- Moderner Hauptstreckenverkehr für Nah- und Güterverkehr
- Industrieanbindung
- SpDrS60-Stellwerk

Meine HO-Anlage: viewtopic.php?f=64&t=161649
Neue Planung: (ab 2021): https://stummiforum.de/viewtopic.php?f=24&t=177831


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Sommerlochfüller

#184

Beitrag von Domapi »

Diese DYMO-Bänder kleben besser und auch auf unbehandeltem Sperrholz:

https://www.amazon.de/gp/product/B000J6 ... UTF8&psc=1
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Rosarote Wochen!

#185

Beitrag von Domapi »

Im Sommer habe ich bei einer Baustelle rosarotes Styrodur gemopst, das nun endlich zur Mannlochabdeckung verarbeitet wurde.

Um dieses Areal zwischen Bahnhof und Klosterkirche geht es:

Bild

Hier brauche ich eine Einstiegsluke, damit ich besser an die weiter innen liegenden Bereiche herankomme.

Zunächst habe ich einen Außenkasten gebaut, der innen eine Auflagefläche für den Styrodurblock hat. Die Abmessungen mußte ich improvisieren, damit der Kasten in die vorhandenen Bauteile passt.

Dann habe ich eine Schablone aus Pappstreifen angefertigt, um damit die durchaus krummen Maße auf das Styrodur zu übertragen.

Bild

Anschließend kamen zwei Neuerwerbungen zum Einsatz, Thermoschneider, einmal Tischgerät und einmal Freihandschneider.

Bild

Damit lies sich der Block bequem zurechtschneiden und anschließend die Landschaftsform bearbeiten.

Aus ein paar Reststücken entstanden weitere Bereiche.

An den Boden des Blocks klebe ich später noch 2 Griffe, damit man den Landschaftsteil nach oben herausheben kann.

Bild

Bild

Bild

Bild

Ein erster Schritt für die Landschaftsgestaltung ist nun gemacht. :fool:
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Benutzeravatar

E-Lok-Muffel
InterCityExpress (ICE)
Beiträge: 2088
Registriert: Di 6. Jan 2015, 14:52
Nenngröße: H0
Stromart: AC
Steuerung: CS-2
Gleise: C-Gleis; DEO: K-Gl.
Wohnort: Ingelheim
Irland

Re: - Rosarote Wochen! -Muss das so steil?

#186

Beitrag von E-Lok-Muffel »

Hallo Martin,

...mit Deinen Sommer-Elektrik-Problemen musste ich Dich alleine lassen, weil ich damit selber auf Kriegsfuß stehe, jetzt wo wieder Landschaft sichtbarer wird, bin ich wieder bei Dir! 8)
...und da frage ich mich allen Ernstes, warum Du in der Ecke so hoch hinaus willst?
O.k. Burgberg mit steilen Bergflanken kann ich verstehen, Kapelle oder Kloster auf einem Hügel auch, aber müssen die einzelnen Plateaus für die Häuser wirklich auf Firsthöhe der darunterstehenden sein?
Wenn Du den Berg bebauen willst, warum machst Du ihn nicht flacher oder schaffst zumindest auf einer Ebene mehr Raum für die Bebauung und lässt dann die - noch steiler gewordenen - Hänge unbebaut...
Da die Gleise sowieso viel tiefer liegen und der Berg hohl ist, ist die absolute Höhe von Dir willkürlich gewählt, aber für meine Begriffe ist das zu hoch gegriffen und das ohne Not...

Mag sein dass die Fotos täuschen und die Perspektive im Moba-Zimmer eine völlig andere ist, ich bin jedenfalls gespannt, wie Du den Berg weiter gestaltest...

mit erwartungsvollen Grüßen
uLi
Meine MOBA-Mottos: "Freu(n)de beim Fahren" oder auch "De Zooch kütt"
mein Trööt: Im Rheintal ist es schön
und neu in der Planung: DEO

Beiträge können Ironie enthalten - und Schreibfehler!


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Rosarote Wochen!

#187

Beitrag von Domapi »

Hallo Uli,

der Berg passt perfekt, so wie er designed ist.

Wenn ich zwei Dinge ganz furchtbar finde, sind es zu kleine/ niedrige Maulwurfshügel, die jede Tunnelstrecke unglaubwürdig erscheinen lassen und Anlagen, auf denen viel zu viele Häuser stehen (mit Ausnahme einer Stadt).

Meine Anlagen haben zudem immer eine gewisse Höhenstaffelung von vorne nach hinten, das sorgt für Tiefe und der Betrachter sieht einen größeren Ausschnitt auf einen Blick.
Zuletzt geändert von Domapi am Fr 13. Dez 2019, 09:56, insgesamt 2-mal geändert.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275


4fangnix
RegionalExpress (RE)
Beiträge: 58
Registriert: So 18. Okt 2015, 12:26
Nenngröße: H0
Stromart: digital
Steuerung: Rocrail / DCC BiDiB
Gleise: C-Gleis
Wohnort: Weiterstadt
Deutschland

Re: Rund übers Eck - Rosarote Wochen!

#188

Beitrag von 4fangnix »

Hallo Martin,

von der MobaLedLib-Seite kommend - Du hast da einen total interessanten Bericht hinbekommen. Respekt hierfür.
Ich habe die Seiten vorerst nur überflogen, bin aber sehr angetan und bleibe dran.

Schöne Grüße
Armin
Rocrail, 1x OpenDCC GBMboost, 1x BiDiB RF-Basis (OpenCar), 5x GBM16T, 2x LightControl, 2x OneControl, 5x Mobalist, DMX-RGB-Dimmer, MobaLedLib mit >60 Stück WS2811/WS2812 RGB-LED, Intellibox - Märklin C- und K-Gleis, Bahn im Aufbau.

Benutzeravatar

KaBeEs246
InterCity (IC)
Beiträge: 632
Registriert: Mi 22. Mär 2017, 20:49
Nenngröße: H0
Stromart: AC
Gleise: C-Gleis
Wohnort: Ruhrgebiet
Deutschland

Re: Rund übers Eck - Rosarote Wochen!

#189

Beitrag von KaBeEs246 »

Domapi hat geschrieben:
Di 19. Nov 2019, 18:13
Wenn ich zwei Dinge ganz furchtbar finde, sind es zu kleine/ niedrige Maulwurfshügel, die jede Tunnelstrecke unglaubwürdig erscheinen lassen und Anlagen, auf denen viel zu viele Häuser stehen (mit Ausnahme einer Stadt).
Meine Anlagen haben zudem immer eine gewisse Höhenstaffelung von vorne nach hinten, das sorgt für Tiefe und der Betrachter sieht einen größeren Ausschnitt auf einen Blick.
Hallo Martin,
die absolute Höhe finde ich auch in Ordnung, sonst führt der Tunnel ja direkt durch die Keller der Häuser.
Was mich etwas stört, ist die Höhenstaffelung der Plateaus. Das sieht aber jetzt wahrscheinlich schlimmer aus, als später, wenn alles ausgestaltet ist. Und solche in der Höhe gestaffelten Straßenzüge gibt es in der Realität ebenfalls.

Gruß von Ruhr und Nette

Hans


Saryk
InterRegioExpress (IRE)
Beiträge: 463
Registriert: So 27. Okt 2019, 21:38
Nenngröße: H0
Stromart: digital
Kontaktdaten:
Deutschland

Re: - Rosarote Wochen! -Muss das so steil?

#190

Beitrag von Saryk »

KaBeEs246 hat geschrieben:
Mi 27. Nov 2019, 22:16
Was mich etwas stört, ist die Höhenstaffelung der Plateaus. Das sieht aber jetzt wahrscheinlich schlimmer aus, als später, wenn alles ausgestaltet ist. Und solche in der Höhe gestaffelten Straßenzüge gibt es in der Realität ebenfalls.
E-Lok-Muffel hat geschrieben:
Mo 18. Nov 2019, 12:13
O.k. Burgberg mit steilen Bergflanken kann ich verstehen, Kapelle oder Kloster auf einem Hügel auch, aber müssen die einzelnen Plateaus für die Häuser wirklich auf Firsthöhe der darunterstehenden sein?
Hallo Martin,
ich klinke mich jetzt mal 'ein' (und nicht wieder aus!)

Meinen Beiden Vorrednern muss ich zu stimmen. Lösungsansatz hierfür wären ca. 4 - 5cm mehr höhe des im Bild linken Plateaus. So kommt es etwas glaubhafter rüber. - wenn du noch Styrodur übrig hast, leg einfach mal ein oder zwei 3cm platen auf das Plateau und lass das auf dich wirken.

hat gekiekt,
Sarah
kiek nich so!
Ungarn, per Bahn || Ideenkiste


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Das große Signalsterben !

#191

Beitrag von Domapi »

Auf meiner Anlage setze ich Viessmann Formsignale ein (die Modelle aus der 4500 Serie).

Die laufen einige Zeit recht schön, auch vergleichsweise langsam. Mit der Zeit (meist nach Ablauf der Garantie/Gewährleistung) setzt dann die geplante Obsoleszenz ein und das große Signalsterben beginnt. Manche verlieren ihre Langsamkeit und schalten schlagartig um, manche gehen nur noch sporadisch, bis sich gar nichts mehr tut. :bigeek:

So habe ich mehrere Signale austauschen müssen. Ein Blick in ebay und ob der dort aufgerufenen Preise für gebrauchte Viessmänner habe ich dann doch die defekten Signale „entkernt“ und auf Servobetrieb umgebaut. Seitdem ist Ruhe.

Mittlerweile hat ESU im neuesten Firmwareupdate des Switchpiloten auch ein Nachwippen integriert, das ganz vernünftig aussieht.
Was will man mehr!

Noch besser beherrscht das neue Viessmann Formsignal mit eingebautem Dekoder und Antrieb (4700) das Nachwippen. Sensationell, was die da alles in dem winzigen Stellfuß an Elektronik bzw. Mechanik untergebracht haben. Diese Modell sind echt zu empfehlen. Hoffentlich hält das etwas länger als die alten Teile :fool:

Um die geänderten Signale an meine analoge Automatiksteuerung anschließen zu können, mußte ich eine kleine Adapterplatine zusammenlöten, die die Tasteranschlüsse des Switchpiloten entsprechend ansteuert, damit die Servos ihre Positionen anfahren. Gut, wenn man immer ein paar Relais und einen Schwung Elektronik-Bauteile zuhause rumliegen hat.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Das große Signalwippen mit Arduino DCC Decoder !

#192

Beitrag von Domapi »

Vor ein paar Wochen hat mich der MobaLEDLib-Entwickler Hardi auf den Arduino gebracht.
Jetzt habe ich mich etwas intensiver mit der Arduino-Welt beschäftigt und herausgekommen ist ein DCC-Arduino Dekoder, der Formsignale stellen kann.

Jetzt kommt bestimmt gleich: Boah, wie langweilig, das kann doch jeder ! :bigeek:

Das neue daran ist (zumindest habe ich woanders keinen passenden Sketch gefunden): Mein Dekoder kann die Signalflügel nachwippen lassen. :mrgreen:

Aktuell funktioniert die unabhängige Bedienung von 4 Servos über jeweils zwei Taster oder über entsprechende DCC-Befehle.

Wen´s interessiert, hier der Sketch (dort finden sich auch weitere Beschreibungen):

Code: Alles auswählen

/**************************************************************************************************************************************************
    Servo-Ansteuerung mit Nachwippen für Formsignale
    V_1.2
    domapi
    18.12.2019
***************************************************************************************************************************************************
    Features:
    - Mehrere Servos (aktuell bis zu 4) lassen sich unabhängig voneinander über jeweils 2 Taster pro Servo oder über DCC-Kommandos steuern.
    - Der Sketch verwendet keine Delay-Funktionen, alles wird über millis() ge-timed.
    - Mehrere Servos können parallel laufen!
    - Einstellbar sind pro Servo (aktuell muss hier der Code angepasst werden):
        - Endpositionen 
        - Geschwindigkeit (gilt aktuell für beide Richtungen)
        - Anzahl Nachwipp-Bewegungen
        - Geschwindigkeit und Stärke des Nachwippens

    ToDos:

    - evtl. Unterroutinen/Fkt. definieren
    - Check, ob Position A > B ist, einbauen und dann ggf. die Positionen tauschen. Aktuell muss A < B sein, sonst gibt es Fehler im Ablauf
    - DCC: CVs lesen, schreiben
    - Alle Einstellungen als CVs vorsehen


    Hardware:
    ---------
    - Servos direkt an 0V, +5V und an den jeweiligen nano-Pin für das PWM-Signal anschließen
    - Bis zu 2 Servos können direkt über USB versorgt werden, andernfalls separates 5V-Netzteil verwenden
      (oder Brückengleichrichter und 7805 Spannungsregler)
    - Je ein Widerstand 4,7 k zwischen +5 V und Servo-PWM-Leitung hilft manchmal gegen Einschaltzucken
      und/oder "Bewegungszucken"
    - Taster direkt zwischen GND und den jeweiligen Arduino-Pin anschließen, interne Pullup-Widerstände werden genutzt. Taster schalten auf LOW/GND.
    - Auswertung DCC-Signal über 6N137 Optokoppler, Schutzdiode (1N4148) und Vorwiderstand (1k).
      Pin 6 mit 10kOhm an 5V reicht aus. Pin 7 muss nicht an 5V angeschlossen sein, er kann unbelegt bleiben.
    - ACK-Signal ggf. später ´mal über Optokoppler und Transistor anschließen


    Arduino Nano:
    //                      +-----+
    //         +------------| USB |------------+
    //         |            +-----+            |
    // LED     | [ ]D13/SCK        MISO/D12[ ] |   Servo [2]    PWM-Pin des Servos
    //         | [ ]3.3V           MOSI/D11[ ]~|   Servo [1]
    //         | [ ]V.ref     ___    SS/D10[ ]~|   Taste_B[4]   Tasten alle an GND/LOW
    //Servo[3] | [ ]A0       / N \       D9[ ]~|   Taste_A[4]
    //Servo[4] | [ ]A1      /  A  \      D8[ ] |   Taste_B[3]
    //         | [ ]A2      \  N  /      D7[ ] |   Taste_A[3]
    //         | [ ]A3       \_0_/       D6[ ]~|   Taste_B[2]
    //         | [ ]A4/SDA               D5[ ]~|   Taste_A[2]
    //         | [ ]A5/SCL               D4[ ] |   Taste_B[1]
    //         | [ ]A6              INT1/D3[ ]~|   Taste_A[1]
    //         | [ ]A7              INT0/D2[ ] |   DCC-Eingang über Optokoppler Pin 6
    //         | [ ]5V                  GND[ ] |
    //         | [ ]RST                 RST[ ] |
    //         | [ ]GND   5V MOSI GND   TX1[ ] |
    //         | [ ]Vin   [ ] [ ] [ ]   RX1[ ] |
    //         |          [ ] [ ] [ ]          |
    //         |          MISO SCK RST         |
    //         | NANO-V3                       |
    //         +-------------------------------+


*/
//=====================================================================================================
// Libraries einbinden, machen das Leben leichter
#include <Servo.h>
#include <EEPROM.h>
#include <NmraDcc.h>
//===========================================================================================================================
//#define POS_DEBUG 1       // Auskommentieren, wenn keine Ausgabe der Positionen auf den seriellen Monitor erfolgen soll
// Die Positionen des Servos lassen sich übrigens prima im seriellen Plotter als Kurve darstellen!
#define DCC_Stuff 1         // in finaler Version auskommentieren

//----------------------------------------------------------------------------------------------------------------------------
// Definitionen aus der NMRADCC-Bibliothek
//----------------------------------------------------------------------------------------------------------------------------
NmraDcc  Dcc;
DCC_MSG  Packet;

struct CVPair
{
    int    CV;
    byte   Value;
};

CVPair FactoryDefaultCVs [] =
{
    {CV_ACCESSORY_DECODER_ADDRESS_LSB, 57},
    {CV_ACCESSORY_DECODER_ADDRESS_MSB, 0},
};

byte FactoryDefaultCVIndex = 0;

void notifyCVResetFactoryDefault()
{
    // Make FactoryDefaultCVIndex non-zero and equal to num CV's to be reset
    // to flag to the loop() function that a reset to Factory Defaults needs to be done
    FactoryDefaultCVIndex = sizeof(FactoryDefaultCVs) / sizeof(CVPair);
};

const int DccAckPin = A3; // Hier kann später das Acknowledgement-Signal erzeugt werden (über einene Optokoppler CNY17 und einen Transistor)

// This function is called by the NmraDcc library when a DCC ACK needs to be sent
// Calling this function should cause an increased 60ma current drain on the power supply for 6ms to ACK a CV Read
void notifyCVAck(void)
{

#ifdef DCC_Stuff
    Serial.println("notifyCVAck") ;
#endif
    digitalWrite( DccAckPin, HIGH );
    delay( 6 );
    digitalWrite( DccAckPin, LOW );
}
//----------------------------------------------------------------------------------------------------------------------------
// Variablen und Konstanten für die Bewegung der Servos

const int servos = 4;                                       // Anzahl der angeschlossenen Servos, aktuell 4 Stück

Servo Servo[servos];                                        // Definition der Servos als Array
int servo_pins[servos] = {11, 12, A0, A1};                  // an diese Arduino-Pins werden die Servo-PWM-Leitungen angeschlossen

// Servopositionen und -Geschwindigkeit; kommen später mal ins EEPROM als CVs

byte pos_A[servos] = {89, 106, 90, 90};                       // rechte Endposition der Servos (Draufsicht)
byte pos_B[servos] = {135, 130, 120, 120};                   // linke Endposition der Servos
byte pos[servos];                                            // Aktuelle Servoposition
byte Geschwindigkeit[servos] = {20, 20, 5, 5};     // Anzahl ms zwischen zwei aufeinanderfolgenden Positionen bei Bewegung

//-----------------------------------------------------------------------------------------------------------------------------
//Parameter für das Wippen

byte Wippen[servos][10] =                                   // hier zehn Werte für 10 mal Nachwippen maximal, Angabe pro Servo in Grad ab der Endposition
{
    {14, 11, 9, 5, 4, 3, 2, 2, 1, 1},                       // bestimmt die Stärke das Nachwippens
    {8, 7, 6, 5, 4, 3, 3, 3, 2, 1},                     // normalerweise nimmt die Weite des Ausschlags mit der Zeit ab
    {14, 11, 9, 5, 4, 3, 2, 2, 1, 1},
    {14, 11, 9, 5, 4, 3, 2, 2, 1, 1},
}  ;

byte anzahl_wippen[servos] = {6, 4, 5, 5};                 // Anzahl pro Servo, wie oft nachgewippt werden soll
// Nimmt im Sketch dann die letzten x Werte aus dem Array "Wippen" oben

byte v_wippen[servos] = {30, 20, 25, 25};                   // Geschwindigkeit des Nachwippens, sollte etwas langsamer als die Servogeschwindigkeit sein

byte state[servos];                                         // State machine für Servobewegung
byte wipp_state[servos];                                    // State machine für Nachwipp-Bewegung

unsigned long t_aktuell = 0;                                // Aktueller Zeitstempel, wird für die millis()-Auswertung benötigt
unsigned long t_alt[servos];                                // Vorheriger Zeitstempel, wird für die millis()-Auswertung benötigt

int i = 0;                                                  // Zähler für Wipp-Bewegungen
int j[servos];

//----------------------------------------------------------------------------------------------------------------------------
// Variablen für das Blinken der Status-LED

const byte LedPin = LED_BUILTIN;                            // ist die eingebaute LED sn Pin 13 im Nano ;-)
unsigned long t_LED = 0;
int LED_on = 50;
int LED_off = 950;                                          // Off-Zeit bei Stillstand --> langsames Blinken
int LED_off_schnell = 150;                                  // Off-Zeit bei Servobewegung --> schnelles Blinken
byte LED_Status = LOW;
boolean servo_in_motion = false;                            // "true", sobald ein Servo in Bewegung ist

//----------------------------------------------------------------------------------------------------------------------------
//Variablen zur Tastenabfrage
//zunächst die benötigten Nano-Pins

const byte Taste_A[servos] = {3, 5, 7, 9};
const byte Taste_B[servos] = {4, 6, 8, 10};

//dann ein paar Arrays, werden im Setup() unten gefüllt

byte Status_Taste_A[servos];                                // Status der Taste: LOW = gedrückt, HIGH = offen
byte Status_Taste_B[servos];
byte letzter_Status_Taste_A[servos];                        // letzter Status
byte letzter_Status_Taste_B[servos];
unsigned long t_A[servos];                                  // letzter Zeitpunkt des Tastendrucks für´s Entprellen
unsigned long t_B[servos];

//Variablen nur einmal notwendig
const int Entprellen_ms = 50;
int Aktueller_Tastenstatus;


//----------------------------------------------------------------------------------------------------------------------------
// Routine aus dem Accessory-Decoder Beispiel der NRMA-Bibliothek
//----------------------------------------------------------------------------------------------------------------------------
// This function is called whenever a normal DCC Turnout Packet is received and we're in Output Addressing Mode
void notifyDccAccTurnoutOutput( uint16_t Addr, uint8_t Direction, uint8_t OutputPower )
{
    // die Zentrale sendet für Magnetartikel (accessories) immer ein Paket bestehend aus Adresse, Richtung und ein/aus.
    // Zunächst wird eine Richtung eingeschaltet, dazu wird das DCC-Telegramm ggf. mehrfach wiederholt
    // Bei der ECOS wird nach einer einstellbaren Zeit pro "Magnetartikel" ein Ausschaltbefehl hinterhergeschickt
    // wir reagieren nur aufs Einschalten

    // Nur auf DCC-Kommandos für das Einschalten reagieren
    if (OutputPower == 1)
    {
        // Für alle Servos die Adresse prüfen und ggf. Bewegung starten. 1. Adresse ist derzeit die 57 fest verdrahtet.
        for (i = 0; i < servos; i++)
        {
            if (Addr == 57 + i)
            {
                if (Direction == 0 && state[i] != 3 && pos[i] != pos_A[i])
                {
                    state[i] = 3; // Bewegung nur dann starten, wenn nicht schon aktiv und nur wenn Endposition nicht erreicht
                    Servo[i].attach(servo_pins[i]);
#ifdef DCC_Stuff
                    Serial.print(millis());
                    Serial.print(" Signal-/Weichen-Adresse: ") ;
                    Serial.print(Addr, DEC) ;                           // ist die Signal-/Weichenadresse, z.B. "57", entspricht 1:1 dem Wert aus der ESU ECoS
                    Serial.print("  Richtung: ");
                    if (Direction == 0) Serial.print(" rot ");
                    if (Direction == 1) Serial.print(" grün");
                    if (OutputPower == 0) Serial.println(" Off");
                    if (OutputPower == 1) Serial.println(" On");
#endif
                }
                if (Direction == 1 && state[i] != 1 && pos[i] != pos_B[i])
                {
                    state[i] = 1;
                    Servo[i].attach(servo_pins[i]);
#ifdef DCC_Stuff
                    Serial.print(millis());
                    Serial.print(" Signal-/Weichen-Adresse: ") ;
                    Serial.print(Addr, DEC) ;                           // ist die Signal-/Weichenadresse, z.B. "57" entspricht 1:1 dem Wert aus der ESU ECoS
                    Serial.print("  Richtung: ");
                    if (Direction == 0) Serial.print(" rot ");
                    if (Direction == 1) Serial.print(" grün");
                    if (OutputPower == 0) Serial.println(" Off");
                    if (OutputPower == 1) Serial.println(" On");
#endif
                }
            }

        }
    }
}

//=====================================================================================================
void setup()
{
    pinMode(LedPin, OUTPUT);

#ifdef POS_DEBUG
    Serial.begin(115200);
#endif

#ifdef DCC_Stuff
    Serial.begin(115200);
#endif

    // Configure the DCC CV Programing ACK pin for an output
    pinMode( DccAckPin, OUTPUT );

    // Setup which External Interrupt, the Pin it's associated with that we're using and enable the Pull-Up
    Dcc.pin(0, 2, 1);

    // Call the main DCC Init function to enable the DCC Receiver
    Dcc.init( MAN_ID_DIY, 10, CV29_ACCESSORY_DECODER | CV29_OUTPUT_ADDRESS_MODE, 0 );

    Serial.println("Domapi`s DCC Servodekoder mit Nachwippen V_1.2");
    Serial.println("Ready for DCC commands ...");


    for (i = 0; i < servos; i++)
    {
        Status_Taste_A[i] = HIGH;
        Status_Taste_B[i] = HIGH;

        letzter_Status_Taste_A[i] = HIGH;
        letzter_Status_Taste_B[i] = HIGH;

        t_A[i] = 0;
        t_B[i] = 0;
        t_alt[i] = 0;

        pinMode(Taste_A[i], INPUT_PULLUP);              // alle Tasten nutzen die internen Pullup-Widerstände, spart Bauteile und Lötaufwand ;-)
        pinMode(Taste_B[i], INPUT_PULLUP);

        pos[i] = EEPROM.read(i);                        // letzte Position einlesen

#ifdef POS_DEBUG
        Serial.println (pos[i]);
#endif
        Servo[i].attach(servo_pins[i]); // Servo-Pins festlegen
        Servo[i].write(pos[i]);
        delay(50);
        Servo[i].detach();
    }
}
//=====================================================================================================
void loop()
{
    // You MUST call the NmraDcc.process() method frequently from the Arduino loop() function for correct library operation
    Dcc.process();

    // Das brauchen wir aktuell auch nicht:
    //    if ( FactoryDefaultCVIndex && Dcc.isSetCVReady())
    //    {
    //        FactoryDefaultCVIndex--; // Decrement first as initially it is the size of the array
    //        Dcc.setCV( FactoryDefaultCVs[FactoryDefaultCVIndex].CV, FactoryDefaultCVs[FactoryDefaultCVIndex].Value);
    //    }

    // Aktuelle Zeit speichern
    t_aktuell = millis();

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

    LED_blinken(); //läßt die LED kurz aufblinken, wenn die Steuerung aktiv ist. Schnelles Blinken, wenn ein Servo bewegt wird.

    //-----------------------------------------------------------------------------------------------------
    // Tasten für alle Servos abfragen und entprellen
    //-----------------------------------------------------------------------------------------------------
    // Tastendruck in die entgegengesetzte Richtung beendet die erste Bewegung und fährt den Servo zurück
    // Dauerkontakt führt die Bewegung aus, startet sie dann aber nicht erneut!

    //-----------------------------------------------------------------------------------------------------
    // Taste Position A,fährt Servo von B --> A
    // Stellt Signal auf ROT
    //-----------------------------------------------------------------------------------------------------
    for (i = 0; i < servos; i++)
    {
        Aktueller_Tastenstatus = digitalRead(Taste_B[i]);
        if ( Aktueller_Tastenstatus != letzter_Status_Taste_B[i])     // Taste gedrückt?
        {
            t_B[i] = t_aktuell;                                       // Zeitpunkt merken
        }
        if (t_aktuell - t_B[i] > Entprellen_ms)                       // schon die Entprellzeit abgelaufen?
        {
            if (Aktueller_Tastenstatus != Status_Taste_B[i])          // immer noch gedrückt?
            {
                Status_Taste_B[i] = Aktueller_Tastenstatus;
                if (Status_Taste_B[i] == LOW)
                {
                    if (state[i] != 3 && pos[i] != pos_A[i])
                    {
                        state[i] = 3;
                        Servo[i].attach(servo_pins[i]);
                    }
                }
            }
        }
        letzter_Status_Taste_B[i] = Aktueller_Tastenstatus;
    }
    //-----------------------------------------------------------------------------------------------------
    // Taste Position B, fährt Servo von A --> B
    // stellt Signal auf GRÜN
    //-----------------------------------------------------------------------------------------------------
    for (i = 0; i < servos; i++)
    {
        Aktueller_Tastenstatus = digitalRead(Taste_A[i]);
        if ( Aktueller_Tastenstatus != letzter_Status_Taste_A[i])     // Taste gedrückt?
        {
            t_A[i] = t_aktuell;                                       // Zeitpunkt merken
        }
        if (t_aktuell - t_A[i] > Entprellen_ms)                       // schon die Entprellzeit abgelaufen?
        {
            if (Aktueller_Tastenstatus != Status_Taste_A[i])          // immer noch gedrückt?
            {
                Status_Taste_A[i] = Aktueller_Tastenstatus;
                if (Status_Taste_A[i] == LOW)
                {
                    if (state[i] != 1 && pos[i] != pos_B[i])          // Bewegung nur dann starten, wenn noch nicht aktiv!
                    {
                        state[i] = 1;
                        Servo[i].attach(servo_pins[i]);
                    }
                }
            }
        }
        letzter_Status_Taste_A[i] = Aktueller_Tastenstatus;
    }

    servo_in_motion = false;
    // Prüfen, ob irgendein Servo gerade eine Bewegung ausführt. Dann soll die LED schnell blinken.
    for (i = 0; i < servos; i++)
    {
        if (state[i] > 0)
        {
            servo_in_motion = true;
            break;                      // Sobald der erste Servo gefunden wurde, kann man die Schleife verlassen!!! Spart echt Zeit ;-)
        }
    }

    // Nun alle Servos parallel mit den nötigen Positionsinfos ansteuern
    // Quasi Multitasking. Die Dekoder werden nacheinander immer ein Stückchen weiter positioniert.
    // Jeder Servo bekommt seine Zeitscheibe ...
    // Jeder Servo durchläuft 4 states: 0 = Nix tun, 1 = Bewegung A --> B, 2 = Nachwippen in Pos. B, 3 = Bewegung B --> A, 4 = Nachwippen Pos. A
    // Beim Nachwippen gibt´s nochmal einen weitern state: wipp_state: 1 = Rückwärtsbewegung, 2 = Vorwärtsbewegung

    for (i = 0; i < servos; i++)
    {
        switch (state[i])
        {
            //-----------------------------------------------------------------------------------------------------
            case 1:
                // Bewegung von A --> B aktiv
                if (t_aktuell - t_alt[i] > Geschwindigkeit[i])
                {
                    t_alt[i] = t_aktuell;
                    // wenn Zeit abgelaufen, wieder eine Position weiter bewegen
                    pos[i]++;
                    if (pos[i] <= pos_B[i])
                    {
                        Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                        Serial.println (pos[i]);
#endif
                    }
                    else
                    {
                        pos[i] = pos_B[i];
                        if (anzahl_wippen[i] == 0)
                        {
                            state[i] = 0;
                            Servo[i].detach(); //Servoimpuls abschalten, wenn Bewegung beendet
                            EEPROM.write(i, pos[i]);
                        }
                        else
                        {
                            state[i] = 2;
                            wipp_state[i] = 1;
                            j[i] = 10 - anzahl_wippen[i];
                        }
                    }
                }
                break;

            //-----------------------------------------------------------------------------------------------------
            case 2:
                // Nachwippen an Position B
                // Die Geschwindigkeit beim Nachwippen jedesmal verringern in Abhängigkeit von i
                if (t_aktuell - t_alt[i] > v_wippen[i] + 2 * j[i])
                {
                    t_alt[i] = t_aktuell;

                    //------------------------------------------------------------------------------------------------
                    switch (wipp_state[i])
                    {
                        case 1:
                            // wenn Zeit abgelaufen, wieder eine Position zurück bewegen
                            if (pos[i] >= pos_B[i] - Wippen[i][j[i]])
                            {
                                pos[i]--;
                                Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                                Serial.println (pos[i]);
#endif
                            }
                            else
                            {
                                wipp_state[i] = 2;
                            }
                            break;

                        //-----------------------------------------------------------------------------------------------------
                        case 2:
                            // wenn Zeit abgelaufen, wieder eine Position vor bewegen
                            if (pos[i] < pos_B[i])
                            {
                                pos[i]++;
                                Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                                Serial.println (pos[i]);
#endif
                            }
                            else
                            {
                                wipp_state[i] = 1;
                                if (j[i] < 9)
                                {
                                    j[i]++;
                                }
                                else
                                {
                                    j[i] = 10 - anzahl_wippen[i];
                                    state[i] = 0;
                                    EEPROM.write(i, pos[i]);
                                    Servo[i].detach(); //Servoimpuls abschalten, wenn Bewegung beendet
                                }
                            }
                            break;
                    }
                }
                break;

            //-----------------------------------------------------------------------------------------------------
            case 3:
                // Bewegung von B --> A aktiv
                if (t_aktuell - t_alt[i] > Geschwindigkeit[i])
                {
                    t_alt[i] = t_aktuell;
                    // wenn Zeit abgelaufen, wieder eine Position weiter bewegen
                    pos[i]--;
                    if (pos[i] >= pos_A[i])
                    {
                        Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                        Serial.println (pos[i]);
#endif
                    }
                    else
                    {
                        pos[i] = pos_A[i];
                        if (anzahl_wippen[i] == 0)
                        {
                            state[i] = 0;
                            Servo[i].detach(); //Servoimpuls abschalten, wenn Bewegung beendet
                            EEPROM.write(i, pos[i]);
                        }
                        else
                        {
                            state[i] = 4;
                            wipp_state[i] = 1;
                            j[i] = 10 - anzahl_wippen[i];
                        }
                    }
                }
                break;
            //-----------------------------------------------------------------------------------------------------
            case 4:
                // Nachwippen an Position A
                if (t_aktuell - t_alt[i] > v_wippen[i] + 2 * j[i])
                {
                    t_alt[i] = t_aktuell;

                    switch (wipp_state[i])
                    {
                        //-----------------------------------------------------------------------------------------------------
                        case 1:
                            // wenn Zeit abgelaufen, wieder eine Position zurück bewegen
                            if (pos[i] <= pos_A[i] + Wippen[i][j[i]])
                            {
                                pos[i]++;
                                Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                                Serial.println (pos[i]);
#endif
                            }
                            else
                            {
                                wipp_state[i] = 2;
                            }
                            break;
                        //-----------------------------------------------------------------------------------------------------
                        case 2:
                            // wenn Zeit abgelaufen, wieder eine Position weiter bewegen
                            if (pos[i] > pos_A[i])
                            {
                                pos[i]--;
                                Servo[i].write(pos[i]);
#ifdef POS_DEBUG
                                Serial.println (pos[i]);
#endif
                            }
                            else
                            {
                                wipp_state[i] = 1;
                                if (j[i] < 9)
                                {
                                    j[i]++;
                                }
                                else
                                {
                                    j[i] = 10 - anzahl_wippen[i];
                                    state[i] = 0;
                                    Servo[i].detach();
                                    EEPROM.write(i, pos[i]);
                                }
                            }
                            break;
                    }
                }
                break;
        }
    }
}



//=====================================================================================================
// Unterprogramme
//=====================================================================================================
void LED_blinken ()
{
    // LED blinken lassen
    if (LED_Status == LOW)
    {
        if (servo_in_motion)
        {
            if (t_aktuell - t_LED > LED_off_schnell)
            {
                digitalWrite(LedPin, HIGH);
                t_LED = t_aktuell;
                LED_Status = HIGH;
            }
        }
        else
        {
            if (t_aktuell - t_LED > LED_off)
            {
                digitalWrite(LedPin, HIGH);
                t_LED = t_aktuell;
                LED_Status = HIGH;
            }
        }
    }
    else
    {
        if (t_aktuell - t_LED > LED_on)
        {
            digitalWrite(LedPin, LOW);
            t_LED = t_aktuell;
            LED_Status = LOW;
        }
    }
}

//----------------------------------------------------------------------------------------------------------------------------
// Weitere NMRA-DCC-Routinen, die aktuell nicht gebraucht werden
//----------------------------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------------------------
// Uncomment to print all DCC Packets
//void notifyDccMsg( DCC_MSG * Msg)
//{
//    Serial.print("notifyDccMsg: ") ;
//    for (uint8_t i = 0; i < Msg->Size; i++)
//    {
//        Serial.print(Msg->Data[i], BIN);
//        Serial.write(' ');
//    }
//    Serial.println();
//}
//
//----------------------------------------------------------------------------------------------------------------------------
//// This function is called whenever a normal DCC Turnout Packet is received and we're in Board Addressing Mode
//void notifyDccAccTurnoutBoard( uint16_t BoardAddr, uint8_t OutputPair, uint8_t Direction, uint8_t OutputPower )
//{
//  Serial.print("notifyDccAccTurnoutBoard: ") ;
//  Serial.print(BoardAddr, DEC) ;
//  Serial.print(',');
//  Serial.print(OutputPair, DEC) ;
//  Serial.print(',');
//  Serial.print(Direction, DEC) ;
//  Serial.print(',');
//  Serial.println(OutputPower, HEX) ;
//}
//
//----------------------------------------------------------------------------------------------------------------------------
//// This function is called whenever a DCC Signal Aspect Packet is received
//void notifyDccSigOutputState( uint16_t Addr, uint8_t State)
//{
//  Serial.print("notifyDccSigOutputState: ") ;
//  Serial.print(Addr, DEC) ;
//  Serial.print(',');
//  Serial.println(State, HEX) ;
//}
Hier ein Bild meines Versuchsaufbaus:

Bild

Links eine etwas größere Signalapplikation für Demozwecke, rechts ein umgebautes Viessmann-Signal.
Der linke Nano steuert das ganze. Der rechts ist bloß noch von einem anderen Sketch verblieben und hier funktionslos.
Oben sind ein paar Taster sowie der Optokoppler zur DCC-Signalauswertung.

An einem Video arbeite ich noch.

Eigentlich wollte ich ja dieses Nachwippen mit einem Microchip Microcontroller programmiert in Assembler realisieren. Mit Arduino und C++ sowie ein paar bereits existierenden Bibliotheken geht es jedoch sehr viel schneller. Wobei - ganz ehrlich - die C++ Syntax und ich stehen permanent auf Kriegsfuß: Dreierlei verschiedene Klammertypen, mal kommt ein Semikolon ans Zeilenende, dann wieder nicht. Aber egal das Ergebnis zählt.

Mir gefällt das Wippen auf jeden Fall besser als das der aktuellen Viessmann-Signale oder der ESU Switchpilot Servo Dekoder :!:

Mal sehen, ob ich den Dekoder noch weiter entwickle.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Benutzeravatar

derOlli
CityNightLine (CNL)
Beiträge: 1746
Registriert: Di 14. Jan 2014, 08:35
Nenngröße: H0
Stromart: digital
Steuerung: RocRail, OpenDCC
Gleise: Tillig / PECO
Wohnort: Berlin
Alter: 51
Deutschland

Re: Rund übers Eck - Das große Signalwippen mit selbstgestricktem Arduino DCC Decoder !!

#193

Beitrag von derOlli »

Hallo Martin, :D
Domapi hat geschrieben:
Sa 21. Dez 2019, 15:43
An einem Video arbeite ich noch.
Na da bin ich jetzt mal gespannt. Bisher habe ich noch keine Signale auf der Platte. Aber wenn werden es auch Flügelsignale.
Bin mal auf dein Ergebnis gespannt.
Gruß von Olli


Über einen Besuch in meinem Kellerland würde ich mich freuen:
http://www.stummiforum.de/viewtopic.php?f=64&t=110273

Neu: Hier geht es zu meinem Video vom FiddleYard. Einfach auf das Bild klicken. :D

Bild


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Das große Signalwippen mit selbstgestricktem Arduino DCC Decoder !!

#194

Beitrag von Domapi »

Hier das Wipp-Video:



Zunächst Steuerung des linken Signaldummies, dann des umgebauten Viessmann-Signals einmal über die Taster und dann über DCC-Kommandos durch die ECoS.
Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275


Threadersteller
Domapi
InterCity (IC)
Beiträge: 690
Registriert: Di 22. Sep 2015, 07:12
Nenngröße: H0
Stromart: digital
Steuerung: DCC & ECOS & TC9 Gold
Gleise: Roco/Tillig/Weinert
Wohnort: Nämberch
Deutschland

Re: Rund übers Eck - Das große Signalwippen mit selbstgestricktem Arduino DCC Decoder !!

#195

Beitrag von Domapi »

In einem anderen Thread, siehe viewtopic.php?f=7&t=165060&start=891#p2058488 und folgende Beiträge, wurde angeregt, das „Umgreifen“ des Stellwerkers abzubilden.
kalaharix hat geschrieben:
Mo 6. Jan 2020, 20:55
Moin,

das Nachwippen sieht schon sehr gut aus, jetzt fehlt noch das Umgreifen :D

In einem mechanischen Stellwerk, also bei über Seilzüge bewegte Signale, ist der Ablauf meist so:

Der Stellwerke zieht den Signalhebel zu sich und etwa bei halbem Stellweg greift er um und drückt den Hebel nach unten. Der Signalflügel verharrt also kurz im 45° Winkel. Das aber nur bei in Fahrtstellung beim Haltfall "fällt" der Flügel in einem auf HP0.

Das wäre doch noch eine nette Erweiterung.
So könnte das aussehen:

Viele Grüße
Martin

Der Weg ist das Ziel !

Mein noch namenloser Trennungsbahnhof: https://www.stummiforum.de/viewtopic.php?f=64&t=152275

Antworten

Zurück zu „Meine Anlage“