[Mape71]

OK, das heißt dann übersetzt, dass ich für 6ms einen Verbraucher zwischen die beiden DC Leitungen schalten muss - ist das korrekt? Den ACK Ausgang des Arduino kann ich dann ja auch wieder über einen Optokoppler raus schicken, der dann einen Transistor mit entsprechendem Widerstand ansteuert. Würde das prinzipiell so funktionieren?

Danke und Grüße

Marko

[digi_thomas2003]

Hallo Marko,

auf http://www.opendcc.de findest Du bei den Decodern u.a. entsprechende Schaltpläne.
Hier findest Du meinen Schaltplan, momentan auf einem Steckbrett aufgebaut, funktioniert einwandfrei. Ich habe dafür einen neuen Thread eröffnet, da es hier ja gezielt um BÜ-Ansteuerung geht.

Herzliche Grüße
Thomas

Edit: Überflüssigen Text entfernt

[digi_thomas2003]

Hallo Franz-Peter, Marko und alle Interessierten,

Zitat von MicroBahner

---

...
um die Drehrichtung eines Servos zu ändern, sollte es schon reichen, die Startwerte in Zeile 71-74 für den jeweiligen Servo zu vertauschen. Gespeichert wird ja nicht die Drehrichtung, sondern nur die Servopositionen für AUF bzw ZU. Die Drehrichtung ergibt sich dann daraus.
Nach der Änderung muss aber auch eine Grundinitiierung gemacht werden, sonst werden die geänderten Werte nicht übernommen (Sketch mit aktivem Justagetaster starten). Allerdings gibt es da noch ein Problem: Thomas schreibt bei der Grundinitiierung die Werte für Servo1 in die CV's für beide Servos:
...
Deshalb kann man die Drehrichtung nicht bei den beiden Servos umabhängig ändern.
Das sollte sich aber umgehen lassen, indem man die CV's direkt von der Zentrale beschreibt oder einen FactoryReset auslöst. Bei den Daten für den Factory-Reset sind die unterschiedlichen Werte berücksichtigt.
...

---

Das habe ich jetzt korrigiert, jetzt wird jede der vier CVs separat geschrieben.

Zitat von MicroBahner

---

...
Um zu erkennen, ob die richtigen Werte im CV stehen, könnte man in notifyDccAccState noch einen entsprechendne DB_PRINT Befehl einfügen, dann würden die CV's im Debugmode bei jedem öffnen/schliessen-Befehl ausgegeben.
...

---

Auch diese Anregung habe ich umgesetzt.

Zitat von MicroBahner

---

...
Bei der Justage mit den Tastern müsste das Programm auch noch angepasst werden, da wird die aktuelle Lage noch in µs ausgelesen, Thomas hat aber eigentlich alles auf Winkel umgestellt:
...

---

Diesen Fehler habe ich behoben.

Danke Franz-Peter für Deine Hinweise!!

Hier nun der aktuelle Code:

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
 

/* Schrankensteuerung mit Servo und DCC-Ansteuerung V0.6 30.11.2015
 *  Die Schrankensteuerung benötigt die 'MobaTools' - library ab der Version 0.6
 *  und die NmraDcc Lib (Standard-Version ohne Timer 0 Modifikation)
 *  
 *  V0.6: Kleine Korrekturen und Verbesserungen:
 *  - Beim Beschreiben der CVs mit den Default-Werten werden nun für jeden der beiden Servos die passenden Werte geschrieben
 *  - bei der Justage den Befehl readMicroseconds() durch read() ersetzt
 *  - bei notifyDccAccState einen DB_PRINT Befehl eingefügt, der den Inhalt der vier CVs im Debug-Mode ausgibt
 *
 *  V0.5: Speicherung der Position ZU und Position AUF in CVs
 *  Der Zustand (offen/geschlossen) in CV 46
 *  Die Position ZU in CV 47 + 48
 *  Die Position AUF in CV 49 + 50
 *  Lok-Adresse für POM-Programmierung eines Zubehördecoders in CV 44 und 45
 *
 *  V0.4: Umstellung von Ansteuerung auf Tastendruck auf DCC-Ansteuerung. Der Schranke wird eine DCC-Zubehör-
 *  Adresse (Weichendecoder) zuordnet, 'gerade' oder 'grün' schließen die Schranke, 'abzweig' oder 'rot' öffnen sie
 *  Die Justierung erfolgt zunächst weiterhin über die beiden separaten Taster
 *
 *  V0.3: Mit Justierung der Endlagen und Speichern der Werte im EEPROM, vorbereitet für 4 Schrankenbäume.
 *  Die gesamte Bewegungskontrolle der Schrankenbäume ist in ein eigenes Unterprogramm ausgelagert.
 *  Dies erleichtert die Umstellung auf einen anderen Antrieb, z.b. mit einem Schrittmotor.
 *  Die Endlagenjustierung ist ebenfalls in diesem UP enthalten und kann jederzeit während des Betriebes vorgenommen
 *  werden. Pro Schranke wird ein Taster benötigt. Wird während der Schrankenbewegung der Taster gedrückt und
 *  gehalten, so läuft die Schranke verlangsamt weiter, bis die Taste losgelassen wird. Das ist dann die neue
 *  Endlage. Dies funktioniert sowohl beim Öffnen, als auch beim Schliessen der Schranke.
 *
 *  V0.2: Version mit erweiterter Ablaufsteuerung: mit Vorlauf für Glocke und
 *  Wechselblinker.
 *
 *  Für eine bessere Übersicht und Erweiterbarkeit ist das Programm logisch in einzelen Blöcke aufgeteilt.
 *  Diese Blöcke sind im loop hintereinander angeordnet, arbeiten aber weitgehend unabhängig. Damit dies
 *  möglich ist, dürfen innerhalb der Blöcke keine Warteschleifen/Delays werwendet werden, die den
 *  Programmablauf temporär anhalten.
 *
 *  1.Block: Einschaltlogik.
 *  Hier wird bestimmt, ob die Schranke geschlossen oder geöffnet werden soll, über eine DCC-Zubehör-Adresse
 *  Ergebnis der Einschaltlogik ist ein Flag 'schrankeSchliessen'
 *
 *  2. Block Ablaufsteuerung Schrankenlogik
 *  zentraler Block, der den Ablauf des Schrankenschliessens bzw -öffnens steuert. Der Block agiert abhängig
 *  von dem Flag 'schrankeSchliessen' und dem momentanen Zustand der Schrankenlogik
 *  Hier werden auch die Flags gesetzt, mit denen die Glocke (glAktiv) und der Wechselblinker (wbAktiv)
 *  ein- bzw ausgeschaltet werden.
 *
 *  3. Block Ansteuerung der Glocke
 *  abhängig vom Flag 'glAktiv' wird der Impulsausgang für die Glocke ein- bzw ausgeschaltet. Je nach ange-
 *  schlossenem Audio-Modul muss gegebenenfalls auch darauf geachtet werden, dass der letzte Glockenschlag
 *  nicht abgeschnitten wird.
 *
 *  4. Block Wechselblinker
 *  abhängig vom Flag 'wbAktiv' wird der Wechselblinker ein- bw ausgeschaltet. Beim Einschalten sind kurz beide
 *  Blinker gleichzeitig an, bevor sie dann abwechselnd blinken.
 *
 *  Verwendete Anschlüsse:
 *  Pin2: DCC-Eingang
 *  Pin4: ACK-Ausgang
 *  Pin3 + Pin11: LED-Ausgänge
 *  Pin5 + Pin6: Servo-Ausgänge
 *  Pin9 + Pin10: Tastereingänge zum Justieren der Servos
 *  Pin7: Ausgang für die Ansteuerung der Glocke
 *
 *
 */
#include <MobaTools.h>
#include <NmraDcc.h>
 
#define DCC_DECODER_VERSION_ID 5 // Versions-ID zur Speicherung in CV 7
#define DCC_ADDR          50     // Zubehör-Adresse, Weichendecoder
#define CV_DCC_POM_PROG   44     // CV 44 beinhaltet LSB der Digitaladresse, unter der der Decoder auf dem Hauptgleis programmiert werden kann (POM)
#define DEBUG ;                  // Wenn dieser Wert gesetzt ist, werden Debug ausgaben auf dem ser. Monitor ausgegeben
 
#define SCHRANKENZAHL   2        // Zahl der Schrankenbäume
 
// gegebenenfalls anzupassende Werte (weitere Werte können im Abschnitt 'Portzuordnungen und Konstante' angepasst werden)
#define PULS_ZU1    50           // Initiale Winkel für die Endpositionen. Die Werte können über die Justierung
#define PULS_AUF1   100          // angepasst werden. Die Drehrichung kann durch Vertauschen der Werte für ZU / AUF
#define PULS_ZU2    50           // umgedreht werden. Dies ist über die Justierung NICHT anpassbar.
#define PULS_AUF2   100
 
#define GLOCKE_ZYK  1000         // Glockenzyklus und Impulslänge muss an das angeschlossene Soundmodul
#define GLOCKE_PULS 200          // angepasst werden.
 
////////////////////////////////////////////////////////////////////////
//////////////// Portzuordnungen und Konstante /////////////////////////
// 1. Einschaltlogik --------------------------------------------------
const byte DccInputP = 2;            // IRQ-Pin 2 des Arduino
const byte DccAckPin = 4;            // Ausgang für das ACK
 
// 2. Ablaufsteuerung --------------------------------------------------
const byte ServoPort[SCHRANKENZAHL] = { 5, 6 };
const byte schrTempo[SCHRANKENZAHL] = { 5, 4 };
const int schrVerzZU[SCHRANKENZAHL] = { 10, 500 }; // Verzögerung für die Schrankenbewegung (ms)
// damit laufen die Schranken nicht exakt gleichzeitig los.
// bei 4 Schrankenbäumen kann dies genutzt werden, um die in Auto-Fahrtrichtung
// hinteren Schranken später schliessen zu lassen
const int vorlaufZu  = 6000;         // Vorlaufzeit: Glocke und Wechselblinker aktiv, Schranke noch ruhend
const int nachlaufZu = 2000;         // Nachlaufzeit: Schranke zu, Glocke nochaktiv
const byte Justage1P =  9;           // Taster zum Justieren von Servo1
const byte Justage2P = 10;           // Taster zum Justieren von Servo2
 
// 3. Glocke -------------------------------------------------------------
const byte glockeP   = 7;            // Impulsausgang zur Ansteuerung einer Glocke
const int glZykl     = GLOCKE_ZYK;   // Glockenrythmus
const int glImp      = GLOCKE_PULS;  // Impulslänge am Glockenausgang
 
// 4. Wechselblinker ----------------------------------------------------
const byte led1P     = 3;            // Ausgänge für den Wechselblinker ( Ports müssen PWM-fähig sein )
const byte led2P     = 11;
const int wbZykl     = 1100;         // Zykluszeit des Wechselblinkers
const int wbSoft     = 300;          // Auf/Abblendzeit der Lampen
 
// sonst. ----------------------------------------------------------------
 
////////////////////// globale Variable //////////////////////////////////////
// 1. Einschaltlogik ----------------------------------------------------
bool schrankeSchliessen;             // Wird über DCC Zubehördecoder angesteuert
 
NmraDcc  DCC;
DCC_MSG  Packet ;
 
// 2. Ablaufsteuerung ---------------------------------------------------
 
// Aufteilung der CV-Variablen (Standardadressen werden in der NmraDcc.h definiert)
// CV-Adresse für die Speicherung des BÜ-Zustandes
const word CvBueZustand = 46;        // CV 46, Werte: 50 = offen, 54 = geschlossen
 
// CV-Adressen für die Speicherung der Endlagen (Winkel des Servos)
const word CvPosZu = 47;             // CV 47, Werte zwischen 0 und 180, 255 gilt als ungültig (leeres EEPROM)
const word CvPosAuf = CvPosZu + (SCHRANKENZAHL);
 
static uint8_t FactoryDefaultCVIndex;
 
// Variable im RAM
int positionZu[SCHRANKENZAHL] = {PULS_ZU1, PULS_ZU2};     // Servopostionen, über Justiervorgang einstellbar
int positionAuf[SCHRANKENZAHL] = {PULS_AUF1, PULS_AUF2};  // Servopostionen, über Justiervorgang einstellbar
byte justageAktiv[SCHRANKENZAHL];
Servo8 Schranke[SCHRANKENZAHL];                           // Für die Schrankenservos
EggTimer SchrankeT[SCHRANKENZAHL];                        // Schrankenspezifische Zeiten
EggTimer VorlaufT;
 
// Aufrufparameter für das Unterprogramm 'Schrankenbewegung':
#define SB_INIT         0            // Servoansteuerung initiieren
#define SB_START_AUF    1            // Schranke öffnen starten
#define SB_START_ZU     2            // Schranke schliessen starten 
#define SB_ENDE         3            // Bewegung überwachen und Ende erkennen. Ggfs. Endlagen justieren
 
// Zustand, in dem sich die Ablaufsteuerung gerade befindet
byte bueZustand;                     // Aktueller Zustand
byte bueVorZustand;                  // vorheriger Zustand des Bue ( noch nicht verwendet)
#define     OFFEN               50
#define     VORLAUF_ZU          51   // Wechselblinker und Glocke, aber noch keine Bewegung 
#define     SCHRANKE_SCHLIESST  52   // Bewegung Schrankenbaum zu
#define     NACHLAUF_ZU         53   // Beide Schrankenbäume in Endpos, Glocke läutet noch.
#define     GESCHLOSSEN         54   // Schranke geschlossen
#define     SCHRANKE_OEFFNET    56   // Bewegung Schrankenbaum auf
 
// CV Speicher Struktur
struct CVPair
{
  uint16_t  CV;
  uint8_t   Value;
};
 
// CV Default-Werte
CVPair FactoryDefaultCVs [] =
{
  {CV_ACCESSORY_DECODER_ADDRESS_LSB, DCC_ADDR},
  {CV_ACCESSORY_DECODER_ADDRESS_MSB, 0},
  {CV_VERSION_ID, DCC_DECODER_VERSION_ID},
  {CV_MANUFACTURER_ID, MAN_ID_DIY},
  {CV_29_CONFIG, 192},
  {CV_DCC_POM_PROG, DCC_ADDR},
  {CV_DCC_POM_PROG + 1, 0 },
  {CvBueZustand, OFFEN},
  {CvPosZu, PULS_ZU1},
  {CvPosZu + 1, PULS_ZU2},
  {CvPosAuf, PULS_AUF1},
  {CvPosAuf + 1, PULS_AUF2},
};
 
// 3. Glocke -------------------------------------------------------------
EggTimer glockeT;
byte glAktiv = false;                // Flag ob Glocke aktiv ist
 
// 4. Wechselblinker ------------------------------------------------------
SoftLed Wblinker[2];                 // 2 Leds für den Wechselblinker
EggTimer BlinkerT;
byte wbAktiv = false;                // Flag ob Wechselblinker aktiv ist
byte ledState = LOW;                 // Status Wechselblinker
// Zustand Wechselblinker
byte wblZustand = 0;
#define   WBL_AUS     0
#define   WBL_START   1              // Beim Start sind kurz beide Lampen an
#define   WBL_BLINKT  2
 
// sonst. -----------------------------------------------------------------
// für debugging
#ifdef DEBUG
#define DB_PRINT( ... ) sprintf( dbgbuf,"Dbg: " __VA_ARGS__ ) ; Serial.println( dbgbuf )
byte debug;
char dbgbuf[80];
#else
#define DB_PRINT ;
#endif
 
//###################### Ende der Definitionen ##############################
//###########################################################################
 
void setup()
{
  byte i;
#ifdef DEBUG
  Serial.begin(38400); //Debugging
  Serial.println( "start of Program" );
#endif
  // 1. Einschaltlogik ----------------------------------------------------
  DCC.pin(digitalPinToInterrupt(DccInputP), DccInputP, 1);              // Dcc-Signal mit Pullup
  DCC.init( MAN_ID_DIY, DCC_DECODER_VERSION_ID,
            FLAGS_OUTPUT_ADDRESS_MODE | FLAGS_DCC_ACCESSORY_DECODER,
            CV_DCC_POM_PROG );                                             // Zubehördecoder, 11bit-Adresse
 
  /////////////////////////////////////
  // DCC-Adresse setzen
  if ( DCC.getCV( 1 ) == 255 ) {              // wenn keine gültige Adresse gespeichert ist
    DCC.setCV( 1, DCC_ADDR % 256 );
    DCC.setCV( 9, DCC_ADDR / 256 );
  }
  if ( DCC.getCV( CV_DCC_POM_PROG ) == 255 ) {   // wenn keine gültige Adresse gespeichert ist
    DCC.setCV( CV_DCC_POM_PROG, DCC_ADDR );
    DCC.setCV( CV_DCC_POM_PROG + 1, 0 );
  }
 
#ifdef DEBUG
  // CV-Werte ausgeben
  DB_PRINT( "CV1:%d, CV9:%d, CV29:%d, CV7=%d, CV8=%d", DCC.getCV(1), DCC.getCV(9), DCC.getCV(29), DCC.getCV(7), DCC.getCV(8) );
#endif
 
  pinMode(DccAckPin, OUTPUT);
  digitalWrite( DccAckPin, LOW );     // Der ACK Pin wird auf LOW gesetzt,damit ein definierter Zustand vorhanden ist
 
  // 2. Ablaufsteuerung ---------------------------------------------------
  pinMode(Justage1P, INPUT_PULLUP);   // Zur Justage der Endlage Schranke 1
  pinMode(Justage2P, INPUT_PULLUP);   // dto, Schranke 2
 
  //////////////////////  Grundinitiierung  ////////////////////////////
  // Testen ob gültige Werte in den CVs abgelegt sind. Wenn nicht, Grundinitiierung mit default-Werten
  // Initiiert wird auch, wenn während des Programmstarts einer der Justageschalter betätigt ist
  if ( DCC.getCV( CvPosZu ) == 255 ||
       digitalRead( Justage1P) == LOW ||
       digitalRead( Justage2P) == LOW  ) {
    // Grundinitiierung
    DB_PRINT( "CV Initiierung" );
    // Endlagen auf Default-Werte setzen
    DCC.setCV( CvPosZu, PULS_ZU1 );
    DCC.setCV( CvPosAuf, PULS_AUF1 );
    DCC.setCV( CvPosZu + 1, PULS_ZU2 );
    DCC.setCV( CvPosAuf + 1, PULS_AUF2 );
    DCC.setCV(CvBueZustand, OFFEN);
  }
 
  /////////////////////////////////////
  // Positionswerte aus CV lesen
  for ( i = 0; i < SCHRANKENZAHL; i++ ) {
    positionZu[i]  = DCC.getCV( CvPosZu + i );
    positionAuf[i] = DCC.getCV( CvPosAuf + i );
    DB_PRINT( "Setup // Schr.%d - PosZu=%d PosAuf=%d", i, positionZu[i], positionAuf[i] );
    DB_PRINT( "Zustand: %d", DCC.getCV( CvBueZustand ));
  }
 
#ifdef DEBUG
  // CV-Werte ausgeben
  DB_PRINT( "CV1:%d, CV29:%d, CV7:%d, CV8:%d", DCC.getCV(1), DCC.getCV(29), DCC.getCV(7), DCC.getCV(8) );
#endif
 
  /////////////////////////////////////////
  /////// Antriebs-Initiierung ////////////
  Schrankenbewegung( SB_INIT );
 
  // Anfangsstellung der Schranke setzen
  bueZustand = DCC.getCV( CvBueZustand );
  if ( bueZustand == GESCHLOSSEN ) {
    Schrankenbewegung( SB_START_ZU );
    while ( !Schrankenbewegung( SB_ENDE ) );
    wbAktiv = true;
  } else {
    Schrankenbewegung( SB_START_AUF );
    while ( !Schrankenbewegung( SB_ENDE ) );
  }
  // 3. Glocke -------------------------------------------------------------
  pinMode( glockeP, OUTPUT );
 
  // 4. Wechselblinker ------------------------------------------------------
  Wblinker[0].attach(led1P);         // Portzuordnung für den WEchselblinker
  Wblinker[1].attach(led2P);
  Wblinker[0].riseTime(wbSoft);      // Weiches Auf/Abblenden der Lampen
  Wblinker[1].riseTime(wbSoft);
 
  // sonst. -----------------------------------------------------------------
 
} // End Setup
//############################### ENDE SETUP ##################################
//#############################################################################
 
void loop()
{
  // 1. Einschaltlogik ----------------------------------------------------
  //////////////  Eingang zur Steuerung des Bahnübergangs /////////////////
  DCC.process();
  // schrankeSchliessen wird in notifyDccFunc gesetzt
 
  // 2. Ablaufsteuerung ---------------------------------------------------
  justageAktiv[0] = ( digitalRead( Justage1P ) == LOW ) ;
  justageAktiv[1] = ( digitalRead( Justage2P ) == LOW ) ;
 
  //////////// Ablaufsteuerung des Bue - Haupt-Zustandsautomat ///////////////////
  switch ( bueZustand ) {
    case OFFEN:
      // Schranke ist geöffnet, warten auf Eingang
      if ( schrankeSchliessen ) {
        // Schranke soll sich schliessen, Glocke und Wechselblinker startet.
        wbAktiv = true;     // Wechselblinker einschalten
        glAktiv = true;     // Glocke einschalten. Diesen Befehl auskommentieren wenn die Glocke erst
        // mit der Schrankenbewegung starten soll
        VorlaufT.setTime( vorlaufZu );
        bueZustand = VORLAUF_ZU;
        DB_PRINT("Zustandswechsel: %d", bueZustand );
      }
      break; //----------------------------------------------------------
    case VORLAUF_ZU:
      // Warten bis die Vorlaufzeit abgelaufen ist, dann die Schrankenbewegung starten
      if ( !VorlaufT.running() ) {
        // Vorlaufzeit abgelaufen, Schrankenbewegung starten.
        // spätestens hier muss auch die Glocke aktiviert werden
        glAktiv = true;    // wurde sie schon aktivert, machts auch nichts ;-)
        wbAktiv = true;
        Schrankenbewegung(SB_START_ZU);    // Überwachung initiieren
        bueZustand = SCHRANKE_SCHLIESST;
      }
      break; //----------------------------------------------------------
    case SCHRANKE_SCHLIESST:
      // Schrankenbaum schliesst sich.
      if ( ( Schrankenbewegung( SB_ENDE ) ) ) {
        // beide Schrankenbäume haben ihre Endposition erreicht
        VorlaufT.setTime( nachlaufZu );
        bueZustand = NACHLAUF_ZU;
      }
      break; //----------------------------------------------------------
    case NACHLAUF_ZU:
      // Schrankenbaum geschlossen, kurzer Nachlauf für Glocke.
      if ( !VorlaufT.running() ) {
        glAktiv = false;
        bueZustand = GESCHLOSSEN;
        DCC.setCV( CvBueZustand, bueZustand );
      }
      break; //----------------------------------------------------------
    case GESCHLOSSEN:
      // Schranke ist zu, warten auf Eingang
      if ( schrankeSchliessen == false ) {
        // Schranke soll sich öffnen, Bewegung einleiten
        Schrankenbewegung(SB_START_AUF);    // Überwachung initiieren
        wbAktiv = false;                    // Wechselblinker ausschalten
        bueZustand = SCHRANKE_OEFFNET;
      }
      break; //----------------------------------------------------------
    case SCHRANKE_OEFFNET:
      // Schrankenbaum öffnet sich, warten bis offen
      if ( schrankeSchliessen == true ) {
        // Notfall: beim Öffnen der Schranke kommt wieder der Befehl Schranke schliessen
        bueZustand = VORLAUF_ZU; // Da der Vorlauftimer nicht läuft, schliesst die Schranke sofort
 
      }
      if (  Schrankenbewegung( SB_ENDE ) ) {
        // beide Schrankenbäume haben ihre Endposition erreicht
        bueZustand = OFFEN;
        DCC.setCV( CvBueZustand, bueZustand );
      }
      break; //----------------------------------------------------------
  } ////////////// Ende Zustandsautomat Bahnübergang /////////////////////
 
  // 3. Glocke -------------------------------------------------------------
  ////////////////// Glockenimpuls erzeugen ////////////////////////////////
  if ( glAktiv ) {
    if ( !glockeT.running() ) {
      // Glockentimer abgelaufen, Impuls erzeugen
      if ( digitalRead( glockeP ) == HIGH ) {
        // Port ist gesetzt, abschalten
        digitalWrite( glockeP, LOW );
        glockeT.setTime( glZykl - glImp );
      } else {
        // Port ist aus, einschalten
        digitalWrite( glockeP, HIGH );
        glockeT.setTime( glImp );
      }
    }
  } else {
    // Glocke inaktiv, Ausgang abschalten wenn Timer nicht mehr läuft
    if ( !glockeT.running() ) {
      // Die Timerabfrage stellt sicher, dass auch der letzte Impuls immer in
      // voller Länge ausgegeben wird
      digitalWrite( glockeP, LOW );
    }
  }
 
  // 4. Wechselblinker ------------------------------------------------------
  /////////////// Wechselblinker (Zustandsautomat ) //////////////////
  switch (wblZustand) {
    case WBL_AUS:
      // Beide Lampen sind aus, warten auf einschalten
      if ( wbAktiv ) {
        // Beide Leds einschalten, Timer für gemeinsames Startleuchten
        Wblinker[0].on();
        Wblinker[1].on();
        BlinkerT.setTime( wbSoft / 2 );
        wblZustand = WBL_START;
      }
      break;
    case WBL_START:
      // Startphase: Nach Zeitablauf erste Led wieder aus
      if ( !BlinkerT.running() ) {
        // Übergang zur normalen Blinkphase
        ledState = HIGH;
        Wblinker[1].off();
        BlinkerT.setTime(wbSoft);
        wblZustand = WBL_BLINKT;
      }
      break;
    case WBL_BLINKT:
      if ( !BlinkerT.running() ) {
        BlinkerT.setTime(wbZykl / 2);
        if ( ledState == LOW ) {
          Wblinker[0].on();
          Wblinker[1].off();
          ledState = HIGH;
        } else {
          ledState = LOW;
          Wblinker[1].on();
          Wblinker[0].off();
        }
      }
      if ( !wbAktiv ) {
        // Wechselblinker abschalten
        Wblinker[0].off();
        Wblinker[1].off();
        wblZustand = WBL_AUS;
      }
      break;
 
  } /////////// Ende switch Wechselblinker ////////////////////////
 
  /* Prüfen, ob die default CV-Werte benötigt werden */
  if ( FactoryDefaultCVIndex && DCC.isSetCVReady())
  {
    FactoryDefaultCVIndex--; // Zunächst verringern, da es zu Beginn die Größe des Arrays ist
    DCC.setCV( FactoryDefaultCVs[FactoryDefaultCVIndex].CV,
               FactoryDefaultCVs[FactoryDefaultCVIndex].Value);
  }
} // End Loop
//#################### ENDE LOOP ##################################################
//#################################################################################
 
byte Schrankenbewegung( byte mode ) {
  // Bewegungsvorgang der Schranken überwachen, gegebenenfalls auch die Endlage
  // justieren. Das Unterprogramm wird im Loop während der Bewegung zyklisch aufgerufen
  // Der Funktionswert ist 'true', wenn die Bewegung aller Schranken abgeschlossen ist,
  // sonst immer 'false'
  // mode:SB_INIT         Grundinitiierung
  //      SB_START_ZU     Schliessen der Schranken einleiten
  //      SB_START_AUF    Öffnen der Schranken einleiten
  //      SB_ENDE         Bewegung überwachen, meldet 'true' wenn alle Bewegungen abgeschlossen
  //                      sind
  // -------------------------------------------------------------------------
  //
  static enum { WAIT, NORMAL, JUSTAGE_AKTIV, JUSTAGE_ENDE, WIPPEN  } ssZustand[SCHRANKENZAHL] ;
  static int startPos[SCHRANKENZAHL] ;  // Position der Schranke zu Bewegungsbeginn
  static enum { AUF, ZU } richtung;
 
  byte bewegung = 0, sn;
  int tmp;
  for ( sn = 0; sn < SCHRANKENZAHL; sn++ ) {
    // für alle Schranken durchlaufen
    switch ( mode ) {
      case SB_INIT: // Initiierung der Schranken
        Schranke[sn].attach(ServoPort[sn], 1); //Servos an Pin 5 / 6 mit AutoOff
        Schranke[sn].setSpeed( schrTempo[sn] );
        bewegung = 1;
        break; //---------------------------------------------
      case SB_START_ZU:  // Schliessen der Schranken einleiten
        richtung = ZU;
        Schranke[sn].setSpeed( schrTempo[sn]);
        SchrankeT[sn].setTime( schrVerzZU[sn] ); //Wartezeit bis Schrankenbewegung
        DB_PRINT( "Start Wartezeit %d mit %d ms", sn, schrVerzZU[sn] );
        ssZustand[sn] = WAIT;
        bewegung = 1;
        break; //---------------------------------------------
      case SB_START_AUF: // Öffnen der Schranken einleiten
        richtung = AUF;
        Schranke[sn].setSpeed( schrTempo[sn]);
        Schranke[sn].write( DCC.getCV( CvPosAuf + sn ));
        ssZustand[sn] = NORMAL;
        startPos[sn] = Schranke[sn].read();
        DB_PRINT( "Schranke %d, Position: %d, Richtung= %d", sn, startPos[sn], richtung );
        bewegung = 1;
        break; //---------------------------------------------
      case SB_ENDE:     // Bewegung überwachen, auf Ende prüfen
        // Schrankenbewegung
        switch ( ssZustand[sn] ) {
          case WAIT: // Verzögerungszeit bis zum Schrankenstart abwarten
            // Wird nur beim Schliessen der Schranke durchlaufen
            if ( SchrankeT[sn].running() == false ) {
              // Zeit abgelaufen, Bewegung starten
              Schranke[sn].write( DCC.getCV( CvPosZu + sn ));
              ssZustand[sn] = NORMAL;
              startPos[sn] = Schranke[sn].read();
              DB_PRINT( "Schranke %d, Position: %d, Richtung= %d", sn, startPos[sn], richtung );
              ssZustand[sn] = NORMAL;
            }
            bewegung = 1;
            break; //......................................
          case NORMAL:
            bewegung += Schranke[sn].moving();
            if ( justageAktiv[sn] ) {
              // Justageschalter betätigt, Speed auf 1, Servobewegung um 10% weitersetzen,
              // sodass die neue Endposition auch hinter der alten liegen kann.
              Schranke[sn].setSpeed( 1 );
              ssZustand[sn] = JUSTAGE_AKTIV;
              if ( richtung == ZU )   tmp = (positionZu[sn] * 3 - positionAuf[sn]) / 2;
              else                    tmp = (positionAuf[sn] * 3 - positionZu[sn]) / 2;
              DB_PRINT( "Schranke %d, Justage Endpso=%d", sn, tmp  );
              Schranke[sn].write( tmp  );
            }
            // if ( bewegung < 5 ) ssZustand[SchrNr] = WIPPEN;
            break; // .....................................
          case WIPPEN:
            // to be defined ;-)
            break; //......................................
          case JUSTAGE_AKTIV:
            bewegung += 1; // keine Endemeldung während der Justage
            if ( !justageAktiv[sn] ) {
              // Justageschalter wurde wieder losgelassen. Momentane Servo-Position
              // als neuen Endpunkt speichern und Servo anhalten
              tmp = Schranke[sn].read();
              DB_PRINT( "Schranke %d, Justage ende, Pos = %d", sn, tmp );
              Schranke[sn].write( tmp );
              if ( richtung == ZU ) {
                positionZu[sn] = tmp;
                DCC.setCV( CvPosZu + sn, tmp );
              } else {
                positionAuf[sn] = tmp;
                DCC.setCV( CvPosAuf + sn, tmp );
              }
              ssZustand[sn] = JUSTAGE_ENDE;
            }
            break; //......................................
          case JUSTAGE_ENDE:
            bewegung += Schranke[sn].moving();
 
            break; //......................................
        } // ..... Ende switch 'Schrankenzustand' ......
 
        break; //---------------------------------------------
      default:
        // falscher Programmaufruf, keine Reaktion
        ;
    } // --- Ende Switch 'mode' --------
  } // ........Ende forschleife der Schranken........
 
  if ( bewegung == 0 ) DB_PRINT( "Endpositionen erreicht");
  return ( bewegung == 0 );
}
 
//###################################################################################
//###################### DCC - Funktionen ###########################################
// Auswertung des Zubehördecoders
void notifyDccAccState( uint16_t Addr, uint16_t BoardAddr, uint8_t OutputAddr, uint8_t State)
{
  if (Addr == DCC.getAddr()) {
    schrankeSchliessen = ((OutputAddr & 0x1) != 0);
    DB_PRINT( " Adresse: %u, Status %x", Addr, schrankeSchliessen );
    DB_PRINT( " CV 47: %d, CV 48: %d, CV 49: %d, CV 50: %d", DCC.getCV(47),DCC.getCV(48),DCC.getCV(49),DCC.getCV(50) );
  }
}
 
// Diese Funktion wird von der Nmra-Lib aufgerufen, wenn ein DCC ACK gesendet werden muss
// z.B. beim Programmieren des Decoders über die Digitalzentrale
void notifyCVAck(void)
{
  digitalWrite( DccAckPin, HIGH );
  delay( 6 );
  digitalWrite( DccAckPin, LOW );
}
 
// Ein Decoder Reset wird angefordert
void notifyCVResetFactoryDefault()
{
  // Setze FactoryDefaultCVIndex ungleich Null und auf die Anzahl der CVs, die zurückgesetzt werden müssen
  // damit die Funktion im loop erkennt, dass ein Reset durchzuführen ist
  FactoryDefaultCVIndex = sizeof(FactoryDefaultCVs) / sizeof(CVPair);
}
 

 
 

Über weitere Anregungen freue ich mich sehr!

Vielleicht noch ein Hinweis:
Der Schaltplan für den Hardware-Aufbau findet sich in diesem Thread.
Der Arduino-Ausgang für das ACK-Signal ist Pin 4. Sollen die CVs des Decoders ausgelesen werden (am Programmiergleis), wird dieser Aufbau benötigt.
Der Decoder kann auch über POM programmiert werden, eingestellt ist die Lok-Adresse 50.

Und nun viel Spaß und Erfolg!

Herzliche Grüße
Thomas

[Mape71]

Hallo Thomas, hallo Franz-Peter,
vielen Dank für die Unterstützung. Ich habe alles mal auf eine Lochrasterplatine gebaut und schon unter die Anlage gebaut. Die Schranken funktionieren super und die Endlagen und Drehrichtungen ließen sich über die CVs programmieren. Andreaskreuze musste ich bestellen, Ende der Woche sollten die aber auch hier sein. Über einen Hinweis bezüglich dem Sound Modul für die Glocke freue ich mich - dann wäre der Übergang komplett fertig[emoji1]
Vielen Dank und Grüße

Marko

[MicroBahner]

Zitat von Mape71

---

Die Schranken funktionieren super und die Endlagen und Drehrichtungen ließen sich über die CVs programmieren.

---

Hallo Marko,
das ist doch mal 'ne super Nachricht
Als Soundmodul habe ich dieses eingesetzt. Leider gibt es das nur noch als Restposten. Den Chip gibt's aber noch, und das Referenzdesign im Datenblatt entspricht ziemlich exakt dem Bausatz - könnte man also auch komplett selbst basteln. Ich habe einen 8Ohm Lautsprecher dranhängen - sogar noch mit 10Ohm Vorwiderstand, da es sonst zu laut war. Es gibt auch noch einen leistungsfähigeren Chip, der wohl im Velleman Nachfolgemodell verbaut ist. Für den Bü kann er eigentlich schon zuviel, ist aber kaum teurer - die SMD-Variante kostet sogar dasselbe wie der kleine Chip. Von daher wäre es dann auch egal.

[digi_thomas2003]

Hallo Marko,

prima, dass Du es jetzt zum Laufen bekommen hast!
Ein Soundmodul habe ich aktuell noch nicht im Einsatz, aber ich könnte mir vorstellen, auch ein Modul mit einer SD-Karte einzusetzen. Die SD-Karte könnte dann bequem am PC bespielt werden um dann ins Soundmodul eingesetzt zu werden. Eventuell sogar ein ArduinoShield?
Nur mal so eine Idee...

Herzliche Grüße
Thomas

[Mape71]

Hallo miteinander,

Danke für die Hinweise. Ich habe auch schon mal ein wenig umhergeschaut und habe für 20 Euro bei ELV ein Soundmodul entdeckt. Dort habe ich dann mal schnell bestellt, bevor ich die neuen Posts gesehen hatte.

http://www.elv.de/mp3-sound-modul-msm-2-komplettbausatz.html

Ist glaube ich generell so ähnlich wie die Empfehlung von Franz-Peter - und wenn es nicht geht baue ich mir eine neue Türklingel daraus Es lassen sich dann insgesamt 10 MP3s ansteuern, d.h. Ich könnte das Modul auch noch für den zweiten Bahnübergang und die Drehscheibe nutzen - und evtl. auch noch für Bahnsteigansagen. Alle Sounds kommen dann auf eine SD Karte. Mal schauen.

Dazu habe ich noch CNY17 Optokoppler bestellt, die ich dann an den Ausgang des Arduinos anschließe.

Wenn es gut läuft (und das Wetter so schön schlecht bleibt) kann ich zum kommenden WE berichten.

Danke und viele Grüße

Marko

Wenn's

[MicroBahner]

Hallo Marko,
na das Modul kann doch schon eine ganze Menge für's Geld . Preis-Leistung sicher besser als bei meinen Vorschlägen.

Zitat von Mape71

---

Es lassen sich dann insgesamt 10 MP3s ansteuern, d.h. Ich könnte das Modul auch noch für den zweiten Bahnübergang und die Drehscheibe nutzen - und evtl. auch noch für Bahnsteigansagen

---

Da bin ich mal gespannt. Ich befürchte, dass immer nur ein Sound gleichzeitig funktioniert - da wird das mit dem Parallebetrieb gegebenenfalls problematisch. Bin auf deine Erfahrungen gespannt - wenn das Ding die Sounds tatsächlich parallel abspielen kann, wäre das natürlich Klasse - vor allem für den Preis.

P.S. hab mal kurz in den Bewertungen bei ELV gestöbert: Es geht tatsächlich immer nur ein Sound gleichzeitig. Für den Preis kann man aber eigentlich auch nichts anderes erwarten .

[Mape71]

Hallo zusammen,

erst noch einmal ein herzliches Dankeschön an alle, die hier geholfen haben. Dies meint vor allem Franz-Peter und Thomas. Mein bestehender Bahnübergang wurde komplett renoviert und funktioniert nun mit den Servos nahezu perfekt - vor allem in Hinblick, dass es sich hier um Spur N handelt. Hier das Video vom vollendeten Werk:
http://youtu.be/sYCu_LUyUvc

Wenn es noch Verbesserungsvorschläge gibt immer gerne her damit (mir selbst fehlt der reale Vergleich mit dem Vorbild).
Kurz noch zum Soundmodul: funktioniert prima, es ist aber immer nur 1 Sound gleichzeitig möglich. Für 20 Euro aber aus meiner Sicht vertretbar- kann ich also empfehlen.

Viele Grüße

Marko

[digi_thomas2003]

Hallo Marko,

danke für die Rückmeldung! Das freut mich, dass der BÜ nun zufriedenstellend angesteuert wird.
Ich selber bin noch auf der Suche nach brauchbaren Schranken für H0...

Herzliche Grüße
Thomas

[Mape71]

Hallo Thomas,

wenn ich H0 bauen würde, dann hätte ich die Schranken von Weinert genommen. Die wirken sehr filigran, haben eine Anlenkmechanik mit dabei, und vor allem einen Behang. Leider gibt's die nicht für N.

Viele Grüße

Marko

[Schachtelbahner]

Zitat von digi_thomas2003

---

Hallo Marko,

danke für die Rückmeldung! Das freut mich, dass der BÜ nun zufriedenstellend angesteuert wird.
Ich selber bin noch auf der Suche nach brauchbaren Schranken für H0...

Herzliche Grüße
Thomas

---

Hallo Thomas,

eine brauchbare Schranke kann man selber ganz nach Wunsch bauen, mit Behang. Ist nicht so schwer wie man vorher denkt.

@Markus, mit dem Ergebnis kannst Du sehr zufrieden sein.

[MicroBahner]

Hallo Marko,
jetzt habe ich mir auch mal dein Video vom vollendeten Werk angeschaut. Sieht doch super aus . Wie Kurt schon sagte, kannst Du damit sehr zufrieden sein - hast Du toll hingekriegt .

Aber einen Zug bei geschlossener Schranke hättest Du schon noch spendieren können

[railfan2401]

Hallo Franz-Peter, hallo Thomas,

nach reichlich Anleitung in diesem thread und redlichen Bemühungen meinerseits, habe auch ich es geschafft die Schrankensteuerung auf DCC-Basis zu verwirklichen, allerdings mit Servos, wie Thomas es vorgemacht hat.

@ Thomas: Dein Sketch läuft bei mir einwandfrei, nur klappt es mit dem PoM nicht. Versuche ich die Einstellungen über die Lokadresse zu ändern, tut sich gar nichts. Auch die Kontrolle über das Programmiergleis (Zubehördecoder) zeigt keine Veränderung an. Was mache ich da falsch bzw. gibt es etwas besonderes zu beachten? Liegt es u.U. daran, dass ich statt des CNY17 einen 4N28 verwendet habe?

Nachdem die Arduinos äußerst preiswert sind, habe ich auch die Glocke damit verwirklicht. Anleitungen hierzu:
http://highlowtech.org/?p=1963 Simple Arduino Audio Samples
http://bryanduxbury.com/2012/01/20/one-t...duino-projects/

[digi_thomas2003]

Hallo Burkhardt,

Zitat von railfan2401

---

...
@ Thomas: Dein Sketch läuft bei mir einwandfrei, nur klappt es mit dem PoM nicht. Versuche ich die Einstellungen über die Lokadresse zu ändern, tut sich gar nichts. Auch die Kontrolle über das Programmiergleis (Zubehördecoder) zeigt keine Veränderung an. Was mache ich da falsch bzw. gibt es etwas besonderes zu beachten? Liegt es u.U. daran, dass ich statt des CNY17 einen 4N28 verwendet habe?
...

---

es gibt wohl in der Tat mit manchen Zentralen Probleme beim Programmieren der CVs. Das liegt aber an der NmraDcc-Library und/oder der Zentrale und nicht an der Schaltung (zumindest nach heutigem Kenntnisstand).
Ich selber habe es mit zwei Zentralen getestet:
Tams MasterControl: PoM funktioniert, Lesen + Schreiben auf Programmiergleis funktioniert auch
Intellibox I (SW 1.501): PoM funktioniert, Lesen + Schreiben auf Programmiergleis hingegen nicht

Warum das so ist, habe ich noch nicht ganz rausgefunden. Es scheint so, als ob die IB die Anzahl der erforderlichen DCC-Befehle zum Programmieren nicht ganz DCC-Spec-konform schickt. Da aber die Programmierung von anderen Decodern auf dem Programmiergleis der IB funktioniert, muß es da wirklich noch was geben, evtl. müsste die Lib angepasst werden. Ist aber wie gesagt noch in Untersuchung.

Welche Zentrale verwendest Du?

Herzliche Grüße
Thomas

[railfan2401]

Hallo Thomas,

vielen Dank für Deine schnelle Antwort. Meine Zentrale ist von Lenz, aktuelle Version (ich glaube 3.6?). Man sollte davon ausgehen können, dass diese DCC konform ist. Allerdings habe ich kein RailCom, aber das dürfte wohl keine Rolle spielen.

P.S. Ich habe mir übrigens zwei Schaltungen aufgebaut. Einmal Deine, die Du aus diesem thread ausgelagert hast und dann eine weitere, die sich ganz eng an OpenDCC (Wolfgang Kufer) anlehnt. Beide versagen bei PoM.

[Mape71]

Hallo zusammen,

da es aktuell recht ruhig in diesem Thema ist komme ich doch mal wieder mit einer neuen "Anforderung" um die Ecke Nachdem mein Bahnübergang nach wie vor toll funktioniert und aktuell gerade die zweite Version davon entsteht beschäftige ich mich parallel auch mit dem Thema Formsignale - und dort insbesondere mit den zweiflügeligen, welche die drei Signalbilder HP0, HP1 und HP2 zeigen können. Ich hatte mit überlegt dafür auch die Schrankensteuerung zu verwenden, dabei aber komplett übersehen, dass ich nicht nur die Endlagen und Drehrichtungen für beide Servos einstellen muss (was ja mit dem Schrankensketch geht), sondern natürlich auch die Servos getrennt voneinander - je nach gewünschtem Signalbild, steuern muss. Somit benötige ich aus meiner Sicht zwei Adressen, um dies komplett abbilden zu können.
Ich selbst vermag es nicht den Sketch umzubauen, so dass das möglich ist - aber eventuell ist das Thema Steuerung von Formsignalen mit Servo oder Schrittmotor ja auch von generellem Interesse, so dass wir eine Weile auf dem Thema weiter machen können.
Also, wenn jemand von den Experten hier Lust hat das Thema weiter zu treiben, zumindest als Tester kann ich mich anbieten Wie auch schon bei den Schranken biete ich auch gerne als Gegenleistung STL-Files für den 3D Drucker, wo Servo und Arduino dann unter der Platte befestigt werden können.

Viele Grüße und Danke vorab

Marko

[MicroBahner]

Hallo Marko,
die Bewegung eines Signalflügels hat zwar gewisse Ähnlichkeit mit der Bewegung des Schrankenbaumes - ansonsten denke ich dass in der Schrankensteuerung doch sehr viele Elemente enthalten sind, die man bei einer Signalsteuerung nicht braucht.
Als Ausgangspunkt für den Signalantrieb würde ich deshalb eher den Servodecoder sehen, den ich im Thread zu den MobaTools vorgestellt habe. Da lassen sich die Servos dann auch über unterschiedliche Adressen getrennt ansteuern.
Ob man da jetzt noch Komfort - z.B. zur Justierung der Endlagen und Speicherung in CV's - einbauen will ist natürlich Geschmackssache. Grundsätzlich kann man das auch im eingebauten Zustand über die USB-Schnittstelle in den defines ändern. So hat das ja auch Ulli(garti62) gemacht.

[Mape71]

Hallo Franz-Peter,

vielen Dank für die Rückmeldung, mit der Du sicher vollkommen recht hast. In der Tat waren es diese "Komfortmerkmale" wie z.B. das Programmieren der Endlagen über CVs die mich da bewegt haben. Für größere Spurweiten wäre es dann evtl. auch das Nachwippen der Signalflügel, was sich realisieren ließe. Das Glockensignal könnte für eine Bahnhofsdurchsage genutzt werden, oder auch Geräusche wie das Schließen der Waggontüren etc.
Ich werde aber erst mal Deiner Anregung folgen den erwähnten Servodecoder zu verwenden - denn die primäre Aufgabe der Flügelsteuerung wird damit sehr gut erfüllt. Falls es eine Weiterentwicklung geben sollte, ist das ja einfach auch später zu implementieren - wenn's einen Tester braucht bin ich gerne da.


Viele Grüße

Marko

[MicroBahner]

Zitat von Mape71

---

In der Tat waren es diese "Komfortmerkmale" wie z.B. das Programmieren der Endlagen über CVs die mich da bewegt haben.

---

Da könnte man ja auch den Servodecoder noch etwas aufbohren - macht meiner Meinung nach mehr Sinn als den Bü abzuspecken

[Mape71]

...das ist bestimmt auch möglich, ich vermag nicht zu beurteilen, was da der bessere Weg ist - dazu fehlt es mir an Verstand[emoji24] Ich freue mich über alles, was meine Anlage besser oder schöner macht[emoji12] - und nicht von der Stange aus dem Laden ist (wobei das eine das andere häufig ausschließt, von den Basics wie Fahrzeuge, Gleise, Gebäude etc. mal abgesehen.

Viele Grüße

Marko

[MicroBahner]

Na ja, der bisherige Servodecoder ist schon sehr einfach gestrickt. Wenn man den etwas aufbohrt, haben vielleicht auch noch andere was davon.
Wär' halt die Frage, wo man anfängt beim 'Aufbohren' - Endlagenjustierung mit CV Speicherung? - Polarisationsrelais für Weichensteuerung? - ??? - andere Ideen?
aber sicher nicht alles auf einmal

[Mape71]

Hallo Franz Peter,

also für mich wäre ein Ausbau als von der Zentrale über CVs konfigurierbarer Schaltartikeldecoder ein toller erster Schritt. Dabei sollten Endlagen und Drehrichtungen, sowie Servogeschwindigkeit für 2 Servos über die CVs konfigurierbar sein. Das scheint mir eine tolle Grundlage für alle weiteren Entwicklungen.
Dies aber nur meine Meinung.

Viele Grüße

Marko

[UweS]

Hallo,

ja, dass wäre auch für mich ein Thema.
Ich würde auch sagen 2 Servos damit steuern wäre ok.

[MicroBahner]

Hallo,
dann wäre also der Ausbau des Decoders auf Programmierung per CV der nächste Schritt. Mehr als 2 Servos wird er aber sicher können - das geht ja jetzt schon und es gibt eigentlich keine Grund das künstlich zu begrenzen. Wird aber ein bisschen dauern, da ich derzeit wieder mehr an meinem Eisberg werkel und dann gibt es ja auch noch ein Leben neben der MoBa ...
Das wird dann aber auch nicht hier sondern im MoBa-Tools Thread stattfinden.