[-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.

[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.

[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.



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.

[N Bahnwurfn]

Hallo Martin,

von dem ganzen digitalen Programierkram habe ich leider keine Ahnung , 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

[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.

[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

[Domapi]

Es gibt offensichtlich auch Bänder mit höherer Klebekraft. Habe mir mal eines bestellt. Werde berichten.

[PATs in 1zu87]

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.



Grüsse
Patrick

[Domapi]

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

https://www.amazon.de/gp/product/B000J6C...0?ie=UTF8&psc=1

[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:



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.



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



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.









Ein erster Schritt für die Landschaftsgestaltung ist nun gemacht.

[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!
...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

[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.

[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

[KaBeEs246]

Zitat

---

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]

Zitat

---

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.

---

Zitat

---

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

[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.

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

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.

[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 !

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

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):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
 

/**************************************************************************************************************************************************
    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:



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.

[derOlli]

Hallo Martin,

Zitat

---

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.

[Domapi]

Hier das Wipp-Video:

[youtu-be]https://youtu.be/ZPQ2sZZwCMc[/youtu-be]

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

[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.

Zitat von kalaharix im Beitrag MobaLedLib: 768 LEDs, Servos, Sound, …………… Neu: Version 3.0.0

---

Moin,

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

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:

[youtu-be]https://youtu.be/5J5MMXWsCoM[/youtu-be]

[Domapi]

Dank Covid-19 und der Tatsache, dass man das Haus nicht mehr verlassen darf, bin ich an meinen Keller gefesselt und es geht endlich ˋmal etwas weiter. Es lebe Social distancing Endlich muss Mann sich nicht mehr rechtfertigen, nicht unter Leute zu gehen und darf seine Zeit eigenbrötlerisch und sozial inkompatibel im Keller verbringen.

Da die Eventisierung unserer Gesellschaft gerade eine erheblichen Rückgang erlebt und nicht en Vogue ist, hier wenigstens einige Bilder meiner Kellerfortschritte: Mögen sie zur Unterhaltung der aktuellen Corona-Eingeschränkten dienen

Die Landschaft am Klosterberg wurde mittlerweile grob gestaltet. Ein paar Feinheiten wie Zäune, Mauern und Geländer fehlen noch.









Jetzt bräuchte ich nur noch ein paar Materialien für die Gestaltung des Weinbergs hinter dem Bahnhof. Blöd nur, dass alle nicht-systemrelevanten Läden geschlossen haben. Gott-sei-Dank gibt es ja online-Versender. Die machen jetzt das Geschäft ihres Lebens. Ich habe mich schon mit Amazon-Aktien eingedeckt ...

Den Weinberg in der Mitte kann man nun bequem nach oben herausnehmen. Das Spaltmaß an den Rändern ist relativ gering und nach der Begrünung ist der Übergang nicht mehr sichtbar.

[derOlli]

Hallo Martin,

das Spaltmaß an den Übergängen hast du Super hinbekommen.
Ich habe bei mir an einigen Stellen so meine Probleme.

[Domapi]

Es ist eigentlich gar nicht so dramatisch.

Einfach ein Stück transparente Folie in den Spalt stecken und oben ca. 1 cm rausragen lassen. Dann den Spalt von beiden Seiten mit Moltofill vorsichtig zuspachteln.

Wenn die Folie flexibel ist, bekommt man gut links und rechts der Folie die gleiche Höhe der Landschaft hin. Nach dem Trockenen lässt sich die Folie problemlos entfernen und etwaige Unebenheiten können mit Schleifpapier eingeebnet werden.

Sobald die Begrünung drauf ist, sieht man nichts mehr.

Klappt auch gut bei Felsen. Hier muss man nach dem Trocknen die Felsen herausritzen und für saubere Übergänge sorgen.

[derOlli]

Hallo Martin,

Danke für den Tipp. Mal sehen ob ich das auch kann

[KaBeEs246]

Hallo Martin,

die Höhenstaffelung hast du gut hinbekommen.
Dein Verzicht darauf, dass sich eine durchgehende Straße in Serpentinen den Hügel hinaufwindet, ist dafür wohl ursächlich.
Die Spalte sind in der Tat schon jetzt kaum zu finden und oberflächlich kann man die mit der letzten Schicht Grün oder was auch immer zum Verschwinden bringen.

Gruß von Ruhr und Nette
Hans