[SET800]

Hallo,
weitere Frage zu Arduinos, mega oder leonardo?

Wie schnell arbeiten die ein Programm ab, den Teil loop ?

Klar so pauschal kann man das nicht sagen, deshalb präziserer:

1. Programmspeicher annährend voll und der wird mehr oder weniger linear abgearbeitet.

2. Innerhalb des Programms keine Schleifen mit Rücksprüngen oder "while".

3. Nicht die Funktion "wait" benutzt.

Ich frage wielange muß ein Eingang Signal haben damit er sicher vom Programm erkannt wird?
Oder sind die Eingänge als RS-FlipFlops geschaltet, setzen durch Eingangssignal, rücksetzen nach dem Auslesen durch das Programm?

danke.

[MicroBahner]

Zitat von SET800

---

Wie schnell arbeiten die ein Programm ab, den Teil loop ?
Klar so pauschal kann man das nicht sagen, deshalb präziserer:

---

Ja, das geht wirklich so pauschal nicht. Deine 3 'Präzisierungspunkte' sind auch ziemlich theoretisch, und daher in der Praxis untauglich. Die Zeiten für einen Loop-Durchlauf können extrem schwanken. Die ATMega basierten Arduinos brauchen für die meisten Maschinenbefehle (die 2 Byte lang sind) 62,5ns (bei 16MHz Takt). Es gibt aber auch einzelne Befehle die länger sind und/oder länger zur Abarbeitung benötigen. Da Du aber in 'C' programmierst, hast Du keinen direkten Einfluß auf die tatsächlich erzeugten Maschinenbefehle. Ausserdem hast Du im loop eigentlich immer if-Abfragen, so dass auch nicht immer der gesamte Code ausgeführt wird. D.h. die Durchlaufzeit ist bei jedem Durchlauf etwas anders. Als Beispiel: der loop des derzeit hier vorgestellten Decoders braucht in Ruhe, also wenn keine auszuwertenden DCC-Signale empfangen werden, ca 100-150µs. Wird ein Stellbefehl empfangen, so verlängert sich die Durchlaufzeit während der Servobewegung um ca. 60-70µs pro Servo (gemessene Werte).

Zitat von SET800

---

Oder sind die Eingänge als RS-FlipFlops geschaltet, setzen durch Eingangssignal, rücksetzen nach dem Auslesen durch das Programm?

---

Nein, wenn das Programm einen Port liest, erkennt es den dort momentan anstehenden Zustand.

P.S. Es wäre übrigens nett, wenn Du für so allgemeine Fragen zum Arduino einen eigenen Thread aufmachst. Auch da werde ich sie dir gerne beantworten (soweit mein Wissensstand reicht ) und da antworten dann vielleicht auch noch ein paar andere Experten.

[MicroBahner]

Zitat von franz_H0m

---

...dann brauche ich kein schlechtes Gewissen zu haben...

---

Das brauchst Du eh nicht. Solange es mir Spaß macht, mache ich es gerne. Und wenn mir der Spaß verfliegt, müsst ihr halt warten, bis er wiederkommt

[johnbobjamesson]

Zitat von MicroBahner

---

Hallo Claudio,
Wenn PoM mit der MS2 bei dir nicht geht, kann es eigentlich nur daran liegen, dass das Programm entweder nicht im PoM Mode startet, oder die Adresse falsch ist. Im Debugfenster muss in der 1. Zeile
PoM Start of Program
stehen.
Um noch die aktive PoM-Addresse auszugeben, musst du eine Programmzeile hinzufügen (an Besten als letzte Zeile im setup-Programm):

1
2
 

    DB_PRINT( "PoM-Addr: %d" , Dcc.getCV( (int) &CV->PomAddrLow )+256*Dcc.getCV( (int) &CV->PomAddrHigh ) ); 
 
 

Wenn das alles richtig ist, wüsste ich nicht, was der Unterschied zu meinem Aufbau ist, und da funktioniert es.

P.S. der CV-Wert muss sich auch tatsächlich ändern, sonst siehst Du nichts. Die Dcc-Lib prüft das, und wenn sich der CV-Wert nicht verändert hat, wird das EEPROM nicht geschrieben, und es gibt auch keine Rückmeldung an den Sketch.

---

Ich werde es testen. Mir ist beim Lesen die Überlegung gekommen, dass der Fehler vermutlich zwischen der MS2 und dem Schreibtischstuhl lag... Ich bin mir gerade nicht mehr sicher, ob ich der Lok nicht aus Versehen die BoardAdresse gegeben habe anstatt der POMAdresse aus dem Sketch... Das wäre peinlich.

Claudio

[franz_H0m]

Hej Franz-Peter,

Zitat von MicroBahner

---

Die MoBa-Tools enthalten eine Debug-Funktionalität.

---

Das wars! Natürlich war auch in meiner Version Deiner Library diese Zeile auskommentiert, aber ich hatte ja in meinem eigenen Sketch auch ein

1
 

#define DEBUG
 

stehen, und der ging dann auch auf Deine Library über. Da muss man daran denken und stattdessen DEBUG2 definieren, oder so.

Danke jedenfalls nochmal!

[MicroBahner]

Hallo Franz,
hmmm - das glaube ich jetzt mal nicht. Ein #define gilt nur in der Datei, in der es steht ( wobei die #includes da auch zu gehören, das sind aber nur die Header-Dateien in denen #defines üblicherweise nicht ausgewertet, sondern eher welche definiert werden ). Die MobaTools.cpp weis von dem #define DEBUG in deinem Sketch nichts, die wird komplett unabhängig davon übersetzt.
Ausserdem habe ich bei meinen Tests da an deinem Sketch nichts verändert, und bei mir hat es funktioniert. Die Ursache muss woanders liegen ...
Aber Hauptsache es funktioniert jetzt

[franz_H0m]

Hej Franz-Peter,

Zitat von MicroBahner

---

hmmm - das glaube ich jetzt mal nicht. Ein #define gilt nur in der Datei, in der es steht

---

Und natürlich hast Du recht ops: - aus irgendweinem verrückten Grund funktioniert es jetzt auch mit exakt dem gleichen Sketch, mit dem es vorher nicht funktioniert hat . Da muss irgendwas beim Programmieren schief gegangen sein .

Wieder was gelernt.

[Uwe HAL]

Hallo Franz-Peter,
ich bin seit längerem stiller Mitleser in diesem Threed. Nachdem ich bereits einige wenige Erfahrungen mit Atmel-Prozessoren und deren Programmierung (Bascom) gesammelt habe, wollte ich (einfach um den Hardwareaufwand zu minimieren) einen Arduino Nano als Basis für meine Programmierversuche verwenden. Das Ziel sollte sein, wenigstens vier Servos mit Tasten zu steuern. Soweit so gut, ich bekam von einem Bekannten einen Uno-Klon aus dem fernen Osten geschenkt und dann ging das Theater los. Bei meinem Bekannten haben wir der OnBoard LED ein Blinkmuster verpasst (PC mit Linux). Ich habe dann voller Euphorie den Nano an meinen Win 7 Rechner gesteckt und nichts ging erst mal. Nach langer Suche im Web habe ich dann die Treiber gefunden und nach ein paar Tagen experimentieren lies sich der Nano tatsächlich auch ansprechen.

Irgendwann kam dann Win10 auf meinen Rechner und schon war es vorbei mit der schönen Programmierung meines Nano Nichts half, alle Versuche eine Lösung zu finden schlugen fehl. Ich habe auch andere Rechner getestet (Win7, Win8.1) mit dem selben Ergebnis. Wenn ich den Nano an den Rechner gesteckt habe blinkte die LED in ihrem Muster und weiter funktionierte nichts.

Irgendwann habe ich es dann geschafft, einen Kurzschluss auf die Pins des Nano zu setzen, dann ging auch die LED nicht mehr. Also weg mit dem Ding und ein paar neue Nanos bestellt (4 Stck. für 9,80€). Nach drei Wochen Wartezeit waren die Teile dann gestern da. Ohne die Beinchen anzulöten habe ich dann schnell mal die Nanos mit dem USB-Kabel angeschlossen und was soll ich sagen, alles funktioniert bestimmungsgemäß und das bei allen Nanos. Ich denke mein alter Nano hatte einen defekt im ch340, denn der 368 schien ja funktioniert zu haben. Egal jetzt funktioniert es.

Ich habe dann mal auf die Schnelle einen Servo an den Nano gebastelt, die MobaTools geladen und einfach mal das erste Beispielprogramm probiert. Alles verlief wie gewünscht Ganz große Klasse, was du da bereits geschaffen hast, vielen vielen Dank dafür. Ich werde im ersten Step die Servos zur Weichensteuerung analog betreiben. Wie ich das umsetze werde ich hier ab und an berichten.

Liebe Grüße Uwe

[MicroBahner]

Hallo Uwe,
da war dein Einstieg in die Arduino-Welt ja recht steinig . Umso besser wenn es jetzt funktioniert.
Danke für's Lob, ich freue mich über jeden, der meine MoBaTools verwenden kann, denn dafür sind sie gemacht

Ich werde demnächst auch hier wieder weitermachen. Zurück aus dem Urlaub stehen aber jetzt erstmal Renovierungen in 1:1 an . Wird also noch etwas dauern....

[johnbobjamesson]

Zitat von MicroBahner

---

Zurück aus dem Urlaub stehen aber jetzt erstmal Renovierungen in 1:1 an

---

Oh erinnere mich nicht daran, im Sommer wird mein Leben nicht aus Styrodur für Modelbahnbrücken sondern der Frage bestehen, ob ich den Dielenboden nicht lieber zu lasse, damit ich gar nicht erst sehe, wie die Balken und die Schüttung drunter aussehen. ... )

[Mape71]

Hallo zusammen,

auch wenn sich sicher alles immer wieder verbessern lässt - mit diesen Effekten für Spur N bin ich persönlich schon recht glücklich. Daher hier mal zwischendurch ein kleines Dankeschön -vor allem an Franz-Peter für den unermüdlichen Einsatz (trotzdem hoffe ich die 1:1 Renovierung ist schnell durch).

Viele Grüße

Marko

http://youtu.be/O92GHVw8SOY

[Uwe HAL]

Hallo liebe Stummis,
ich hoffe alle haben den gestrigen Feiertag gut überstanden Ich habe die Zeit genutzt und habe meine analoge Weichensteuerung programmiert. Ich habe mich für eine Ein-Tasten-Lösung entschieden, auf dem Gleisbildstellpult habe ich also pro Weiche einen Taster der abwechseln gerade und abzweigend schaltet. Am Arduino wird also pro Weiche ein Taster, ein Servo und ein Relais zur Herzstückpolarisierung und/oder Rückmeldung angeschlossen. Im Schattenbahnhof werden 7 Weichen montiert, dafür reicht eine Arduino Nano vollkommen aus. Um mir das Leben zu vereinfachen, habe ich mir bei ebay ein Shield bestellt auf das ich den Nano stecken kann und das gleichzeitig direkte Servoanschlüsse bietet, desweiteren habe ich Relais bestellt, die bereits auf Platinchen gelötet sind und direkte Anschlüsse für den Arduino bieten. Somit brauchte ich alles nur noch mit kurzen Kabeln verbinden und schon konnte es losgehen. Die Programmierung gestaltete sich recht einfach, bei der Ein-Tasten-Lösung muss man nur beachten, dass die Taster ordnungsgemäß entprellt werden.

Nochmals Dank an Franz-Peter für die Vorarbeit und die MobaTools, die Servos laufen ruhig, langsam und ruckelfrei. Diese Lösung kostet für acht Weichen keine 10 Euro inkl. der Relais, aber ohne Servos und leistet mindestens genauso viel wie professionelle Lösungen, die wenigstens 4-mal soviel kosten.

Bilder und Quelltext kann ich bei Bedarf gern hier einstellen.

Gruß Uwe

[Uwe HAL]

Hallo zusammen,

auf Grund mehrerer Anfragen ist hier der Sketch für die analoge Steuerung von bis zu 7 Servos

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
 

#include <MobaTools.h>
 
/* Beschaltung des Arduino wie folgt:
    - als Pins für die Taster sind die Pin A0 bis A6 vorgesehen 
    - die Servos für die Weichenantriebe werden an Pin 7 bis 13 angeschlossen
    - für die Relais verbleiben die Pins 0 bis 6
    somit ist sichergestellt, dass 7 Weichen betrieben werden können, zu beachten
    ist weiterhin, dass die Relais eine separate Stromversorgung benötigen, ich 
    persönlich empfehle ein entsprechenden Shield zu benutzen, der genügend 
    Servo-Anschlüsse und eine separate Stromversorgung beinhaltet
*/
  
//Variablendeklaration
 
#define ANZAHL 3    // Anzahl Weichenantriebe, Relais und Taster
 
const int WeichenPin[ANZAHL] = {8,9,10};       // Pins für die Weichenantriebe
const int ButtonPin[ANZAHL] = {A0,A1,A2};      // Pins für die Taster
const int Relais[ANZAHL] = {5,6,7};            // Pins für die Relais
const int WeichenPos1[ANZAHL] = {40,40,40};    // linke Position der Servos
const int WeichenPos2[ANZAHL] = {120,120,120}; // rechte Position der Servos
const int Speed[ANZAHL] = {8,8,8};             // festlegen der Verfahrgeschwindigkeit der Servos
const long debounceDelay = 300;                // Wartezeit ehe ein Tastendruck zählt
 
int i ; 
int buttonState[ANZAHL] = {HIGH,HIGH,HIGH}; //High = Taster nicht gedrückt, LOW = Taster gedrückt
int ServoState[ANZAHL] = {1,1,1}; //ServoStatus negativ = rechts, positiv = links
long lastDebounceTime[ANZAHL] = {0,0,0};  // Zeit des letzten Tastendrucks
 
Servo8 Servos[ANZAHL];
 
 
void setup() {
 
 for (i=0; i<ANZAHL; i++) {
   Servos[i].attach(WeichenPin[i]);
   Servos[i].setSpeed(Speed[i]);
   pinMode(ButtonPin[i], INPUT);
   digitalWrite(ButtonPin[i], HIGH);   //internen PULLUP einschalten
   pinMode(Relais[i], OUTPUT);
   }
 
}//Ende void setup
 
 
void loop() {
 
  for ( i=0; i<ANZAHL; i++ ) { 
 
     buttonState[i] = digitalRead(ButtonPin[i]);  //Abfrage ob ein Taster gedrückt wurde
        
     if ( (millis() - lastDebounceTime[i]) > debounceDelay) {  //Kontrolle, ob Tastendruck gültig
 
       //Wenn Tastendruck gültig und Servo in Position 1 steht
       if ( (buttonState[i] == LOW) && (ServoState[i] < 0) ) {
         Servos[i].write(WeichenPos1[i]);
         digitalWrite(Relais[i], LOW);
         ServoState[i] = -ServoState[i]; //speichern der Servostellung im RAM
         lastDebounceTime[i] = millis(); //speichere Zeit des letzten Tastendrucks
     }
     else if ( (buttonState[i] == LOW) && (ServoState[i] > 0) ) {
         Servos[i].write(WeichenPos2[i]);
         digitalWrite(Relais[i], HIGH);
         ServoState[i] = -ServoState[i]; //speichern der Servostellung im RAM
         lastDebounceTime[i] = millis(); //speichere Zeit des letzten Tastendrucks
         }
      }
   }
  
}//Ende void loop
 
 

Als Shield benutze ich so etwas: http://www.ebay.de/itm/Prototype-Shield-...nbZvgl7KVMat25g
und als Relaisplatinen habe ich mir diese zugelegt : http://www.ebay.de/itm/8-Kanal-Relais-Mo...MEAAOSwh-1W4oM4

Ich hoffe ich konnte ein wenig weiter helfen, wenn etwas unklar ist fragt einfach. Ich bin aber kein Programmierspezialist, was ich kann, habe ich mir angelesen und durch viel probieren herausgefunden. Trotzdem werde ich versuchen Fragen zu beantworten.


Gruß Uwe

[Ingolf]

Hallo Stummis,

ich lese hier im Forum schon eine ganze Weile mit, meine Hochachtung dem "Schöpfer" der Mobatools !!

Kurz zu meiner Person, ich bin Ü 60, beschäftige mich seit ca 1,5 Jahren mit der MoBa, darüber kommt man ja unweigerlich zu den Arduinos.
Habe für den Club schon fast 50 Weichen Servo-Steuerungen gebaut, auch eine Z21 mit dem Arduino Mega nach Phillipp Gahtow. Ist mir soweit
gelungen.

Jetzt zu meinem Anliegen. Es soll eine Ausschlackanlage mit Servo-Antrieb (Faller 120242) angeschlossen werden. Die Schlackehunte soll natürlich
schön langsam nach oben gezogen, anschließend langsam wieder nach unten gelassen werden. Dies funktioniert mit dem Servo-Sketch der MoBa-
Tools ganz hervorragend, bis auf ein Detail. Ich habe das ganze nach dem Video von Tauberspatz aufgebaut. Schalte ich die Steuerung ein läuft die
erste Drehbewegung des Servos mit max Speed ab. (Hunte unten, ich drücke auf oder Hunte oben und ich drücke runter).
Danach funktioniert alles tadellos. Kann ich so nicht einbauen, da mir bei max Speed der Bindfaden, der die Hunte zieht, von der Umlenkrolle des
Servos springt.
Hat jemand eine Idee ????

2 andere Probleme habe ich schon bei meinen Weichen-Steuerungen lösen können.
Das Einschaltzucken des Servos wird verhindert durch einen 4,7 K -Widerstand zwischen dem Ausgang des Arduino und +5V.
Das Zucken des Servos in der Nullstellung (und nur dort tritt es bei meinen "Billig"-Servos auf), verhindere ich, indem ich den Servo nicht bis 0
sondern vielleicht nur bis 10 zurückfahren lasse. Brauche ich 90 Grad also z.B. zwischen 10 und 100 Grad, ggf. Horn drehen.
Vielleicht hilft es jemandem.

Grüße Ingo

[franz_H0m]

Hallo Ingo,

nach dem Einschalten kann die Steuerung nicht wissen, wie der Servo steht - die erste Fahrt ist damit immer mit maximaler Geschwindigkeit. Wenn allerdings der Servo bei z.B. 10 steht und die erste Fahrt zu 10 geht, dann bewegt sich der Servo nicht, und weiss danach trotzdem wo er ist.

Wenn Deine Hunte also unten sind, sollte es eigentlich reichen, einmal auf "unten" zu drücken, dann weiss die Steuerung wie die Servos stehen und der Rest läuft nach Plan.

Man kann natürlich auch die letzte Position speichern, so mache ich das bei meinen Weichen.

Grüsse,

Franz

[MicroBahner]

Hallo liebe Stummies und Arduino-Interessierte
nachdem die 1:1 Renovierungen größtenteils 'durch' sind, will ich mich auch mal wieder hier melden .

@Uwe: danke für deinen Beitrag und das Einstellen deines Sketches. Schön einfach und doch sinnvoll zu verwenden. Das kann sicher der eine oder andere auch so einsetzen .

@Ingo: Franz hat es ja schon geschrieben. Das Problem bei den Servos ist, dass das Programm beim Einschalten nicht erkennen kann, wo das Servo steht. Damit ist die erste Bewegung immer 'Full Speed'. Es sei denn, der erste 'write' Aufruf entspricht der tatsächlichen Position des Servos. Dazu muss man - wie auch Franz schon geschrieben hat - sich immer die Servopostion merken, so dass beim Einschalten dann als erstes das 'richtige' write kommando ausgegeben werden kann. Ist leider ein prinzipielles Problem, dass innerhalb der MoBaTools nicht gelöst werden kann.
Nun hast Du deine Mechanik ja offensichtlich schon aufgebaut. Alternative - besonders bei so empfindlicher Mechanik - wäre sonst noch das ganz über einen kleinen Schrittmotor zu betreiben. Ließe sich ganz analog zu meiner Schrankensteuerung aufbauen. Der Schrittmotor hat in diesem Fall den Vorteil, dass es dort kein schnelles Bewegen beim Einschalten gibt. Ausserdem läuft er bei langsamen Bewegungen nochmal deutlich gleichmäßiger als das Servo. Nachteil ist allerdings, dass man in der Mechanik einen Referenzpunkt einbauen muss. Die MoBaTools unterstützen die Schrittmotoransteuerung jedenfalls auch.


Vom CV-konfigurierbaren Zubehördecoder wird's demnächst auch eine neue Version geben. Ist grundsätzlich fertig, ich muss sie nur noch ordentlich testen. Eingebaut sind der PoM-Betrieb ohne Programmierschalter und das Abspeichern der jeweils letzten Servostellungen (also auch das oben angesprochene Problem ).


N.B. Für die NmraDcc Lib habe ich eine alternative DCC-Signalauswertung geschrieben, um sie u.a. besser an die MoBaTools anzupassen (Die PWM-Ausgänge 5 und 6 bleiben nutzbar). Ausserdem ist die Portierung zu anderen Arduino-Plattformen damit einfacher. Alex Shepherd, der Entwickler der NmraDcc-Lib hat die Änderungen bereits eingearbeitet, nur muss das noch in der Breite getestet werden. Diese Version kann hier heruntergeladen werden. Wäre schön, wenn der eine oder andere seine Sketches auch mit dieser Version betreibt und die Ergebnisse hier kundtut . Perfekt ist es, wenn kein Unterschied zu der bisherigen NmraDcc-Lib erkennbar ist.

[Ingolf]

Hallo Stummi-Freunde,

erst einmal Dank für Eure Erläuterungen.

Franz, könntest Du mir den Sketch Deiner Weichensteuerung zukommen lassen ??
Selbst bin ich nicht in der Lage, so etwas zusammenzustellen, ein paar Anpassungen kriege ich evtl noch hin.
Der Sketch könnte dafür geeignet sein, mein Servo fährt ja auch nur zwischen 2 Positionen hin und her, ich muß nur den Max-Speed-Schwenk nach
dem Einschalten los werden.

Ansonsten wünsche ich Euch schon mal frohe Pfingsten !

Grüße Ingo

[franz_H0m]

Hallo Ingo,

hast Du den Code aus dem allerersten Beitrag genommen? Ich habe da mal die Funktionen reingeschrieben, mit denen die Positionen ins EEPROM geschrieben und beim Start wieder ausgelesen werden.

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
 

#include <MobaTools.h>
#include <EEPROM.h>
 

// Die Taster müssen so angeschlossen sein, dass der Eingang bei gedrücktem
// Taster auf LOW (=0) geht. Ansonsten muss im loop auf HIGH abgefragt werden
const int tasterPin1 = 2;    // Taster1 Pin 2
const int tasterPin2 = 3;    // Taster2  Pin 3
const int servoPin =  9;     // Anschluß für den Servo, möglich sind 9 oder 10
// bei Werten, die sich im Programm nie verändern, sollte immer 'const' vorangestellt
// werden
 

int tasterStatus1, tasterStatus2;
Servo2 meinServo;
 
void setup() {
    pinMode(tasterPin1, INPUT_PULLUP); //tasterPin1 (Pin 2)
    pinMode(tasterPin2, INPUT_PULLUP); //tasterPin2 (Pin 3)
    meinServo.attach(servoPin); //Servo an Pin 9
    meinServo.setSpeed( 5 );    // Das ist ein neuer Aufruf, mit dem die Geschwindigkeit
                                // eingestellt wird. Je größer die Zahl, umso größer
                                // die Geschwindigkeit. Bei 0 (defaultwert) verhält es
                                //sich wie bei der Standard Bibliothek
    meinServo.write(EEPROM.read(0)); //"bewege" Servo zur letzten im EEPROM gespeicherten Position
}
 
void loop() {
    tasterStatus1 = digitalRead(tasterPin1);
    tasterStatus2 = digitalRead(tasterPin2);
 
    if (tasterStatus1 == LOW ) {
        meinServo.write(40); //wird langsam  drehen
        EEPROM.write(0, 40); //schreibe Zielposition ins EEPROM
        delay(100);
    }
 
    if (tasterStatus2 == LOW) {
        meinServo.write(150); //wird langsam drehen
        EEPROM.write(0, 150); //schreibe Zielposition ins EEPROM
        delay(100);
    }
 
    delay(20);
 
}
 

Ich habe den Sketch getestet und er tut was er soll. Man muss jetzt die Servopositionen an zwei Stellen ändern. Das kann man noch eleganter machen, aber ich wollte so nah wie möglich an dem ursprünglichen Beispiel bleiben.

Wenn allerdings der Servo bewegt wird, wenn der Strom aus ist, oder der Strom ausgeht, während eine Bewegung stattfindet, dann wird der Servo beim Einschalten immer noch eine schnelle Bewegung machen.

PS: Meine Weichensteuerung: https://github.com/fhennies/Weichensteue...ter/GW1/GW1.ino

[Ingolf]

Franz, - GANZ -GROSSE - KLASSE - !!!

So funktioniert es, habe es gleich ausprobiert.
Der kleine Sketch ist auch für mich überschaubar, selbst hätte ich mir einen abgebrochen.
Über den großen Sketch brauchen wir gar nicht zu reden.

Hab schönen Dank für Deine Hilfe,
ich wünsche Dir und allen Stummianern ein frohes Pfingsfest !

Grüße Ingo

[MicroBahner]

Hallo,
erstmal Danke an Franz dass er Ingo so schnell geholfen hat. Ich hätte es vielleicht wieder zu kompliziert gemacht ops: .
So ist es eine ganz einfache Lösung und offensichtlich für Ingo vollkommen ausreichend

Ich wurde soeben auch darauf aufmerksam gemacht, dass die Links im 1. Post zur MoBa-Lib und zur Dokumentation nicht mehr funktionieren. Da die MoBa-Tools mittlerweile auf GitHub hinterlegt sind, habe ich die Links entsprechend geändert.
Jetzt sollte wieder alles funktionieren.

Auch von mir allen ein schönes Pfingstfest.

[MicroBahner]

Hallo,
es gibt eine neue Version des Zubehördecoders.(V2Beta1 ).
Wesentliche neue Punkte sind:

• Per Compilerschalter kann eingestellt werden, ob der PoM-Modus immer aktiv ist, oder ob es einen Programmierschalter gibt.

• Einstellungen, die auch vom Aufbau der HW abhängig sind, werden per defines, bzw const am Anfang des Programms festgelegt. Die sonstigen Eigenschaften der Ausgänge werden per CV eingestellt.

• Es können neben Servos auch Weichen mit Doppelspulenantrieben angesteuert werden. Impulsdauer und minimale Impulspause ist CV-konfigurierbar.

• Die letzte Stellung der Weiche wird im CV gespeichert und bei einem Neustart berücksichtigt. Werden die Servos nicht manuell bewegt oder fällt die Spannung nicht während der Bewegung aus, bewegen sich die Servos damit auch nach dem Programmstart immer mit der eingestellten Geschwindigkeit.

• Standardmäßig ist Adressierung auf 'output adressing' eingestellt (CV29 Bit6=1). Die Adresse in CV1/9 wird damit als Weichenadresse interpretiert und der Adressblock des Decoders kann an jeder beliebigen Adresse beginnen. Wird das Bit in CV29 gelöscht (Decoder addressing) steht in CV1/9 die Boardadresse und die erste Weichenadresse kann nur in 4er Sprüngen definiert werden.

• Pro Weiche steht ein Block von 5 CV-Werten ab CV50 zur Verfügung:

1
2
3
4
5
6
7
8
9
10
11
 

        byte Mode;     // Betriebsart des Ausgangs
        byte Par1;    // Servo: Position AUS ( 0...180 Grad )
                      // DoppelspuleAuto: Einschaltzeit ( 10ms-Schritte )
                      // FBlinken:        Einschaltphase des Blinkens ( 10ms Schritte )
        byte Par2;    // Servo: Position EIN ( 0...180 Grad )
                      // DoppelspuleAuto: Einschaltzeit Ausgang 2 ( 10ms-Schritte )
                      // FBlinken:        Ausschaltphase des Blinkens ( 10ms Schritte )
        byte Par3;    // Servo: Speed
        byte State;   // aktueller Status des Ausgangs (Ein/Aus)
                      // Nach einem Neustart werden die Funktionsausgänge entsprechend eingestellt.
 
 

• Bei eingeschaltetem Debug-Mode werden beim Programmstart alle relevanten CV-Werte ausgegeben.

• Ein ausführliches Manual steht noch auf der todo-Liste ops:

Der 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
 

#include <NmraDcc.h>
#include <MobaTools.h>
 
/*  Demo: ein universeller Dcc-Zubehördecoder 
 *   Version 0.1 - erstmal nur Servos
 *   Version 0.2 - alternativ auch ohne Programmierschalter nutzbar. PoM ist dann immer aktiv,
 *                  Addressen nur über den Sketch änderbar.
 *                  Adressierung als Board- oder Outputadressierung je nach CV29:6 (1=Outputaddr.)
 *                  Ansteuerung von Doppelspulenantrieben 
 *  ----------------------------------------
 * Eigenschaften:
 * Bis zu 8 (aufeinanderfolgende) Zubehöradressen ansteuerbar
 * 1. Adresse per Programmierung einstellbar
 * 
 * 2 Ausgänge / Zubehöradresse
 * Einstellbare Funktionalität:
 *  - Servo mit Umschaltrelais zur Weichenpolarisierung
 *  - Doppelspulenantriebe
 *  - statische Ausgänge   (noch nicht realisert)
 *  - blinkende Ausgänge   (noch nicht realisert)
 *  
 *  Die Funnktionalität wird über CV-Programmierung festgelegt. Bei Servoausgängen
 *  sind die Endlagen per CV-Wert einstellbar
*/
#define DCC_DECODER_VERSION_ID 02
 
//------------------------------------------ //
// die NmraDcc - Library gibt es unter https://github.com/mrrwa/NmraDcc/archive/master.zip
// oder, ohne Benutzung des Timer0 (PWM an Pin 5 und 6 funktioniert):
// https://github.com/MicroBahner/NmraDcc/archive/Without-use-of-HW-timers.zip
 
// vvvvvvvvvvvvvv  gegebenenfalls anzupassende Konstante vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
 
// -------------feste Programmeinstellungen ( nicht über CV änderbar) -----------------------
// Eine Änderung dieser Parameter hat i.d.Regel auch Änderungen an der HW zur Folge
 
#define VAR_ALLWAYSPOM  0   // 0: PoM muss über den Programmierschalter aktiviert werden
                            // 1: PoM ist immer aktiv, keine automatische Addressvergabe. 
                            //    PoM-Adresse wird immer aus den Factory-Defaults geladen.
#define VAR_INIADDR     0   // 0: Decoder und PoM-Adresse werden nur dann aus den Factory-defaults geladen,
//  noch nicht realisiert   //    wenn CV47 einen ungültigen Wert enthält
                            // 1; Decoder und PoM-Adress werden bei jedem Programmstart aus den Factory
                            //    defaults geladen
 
//#define DEBUG ;             // Wenn dieser Wert gesetzt ist, werden Debug ausgaben auf dem ser. Monitor ausgegeben
 
#
// Pin-Festlegungen
#ifndef VAR_ALLWASPOM 
const byte progPin      =   0 ;    // PoM-Programmierung nur möglich, wenn auf 0 (ungenutzt, wenn ALLWAYSPOM)
const byte modePin      =   1;  // leuchtet im Programier(Pom) Modus. Da dies auch der serielle
                                // Ausgang ist, funktinoert die Led nicht im Debug-Modus
#endif
const byte dccPin       =   2;
const byte ackPin       =   4;
const byte out1Pins[]   =   {   3,   5,   9,   7,  12,  A0,  A2};  // output-pins der Funktionen
const byte out2Pins[]   =   {  11,   6,  10,   8,  13,  A1,  A3};
// Mögliche Funktionstypen je Ausgang. Derzeit sind nur die Servofunktionen implementiert
#define FOFF        0 // Funktionsausgang abgeschaltet
#define FSERVO      1 // Standardservoausgang (Impulse liegen dauerhaft an)
#define FCOIL       2 // Magnetartikel
#define FSTATIC     3 // Der Ausgang wird statisch ein bzw ausgeschaltet
#define FBLINK      4 // Der Ausgang Blinkt
#define FMAX        4  
const byte iniTyp[]         = { FSERVO, FSERVO, FSERVO, FCOIL, FCOIL, FCOIL, FCOIL, FCOIL };
const byte WeichenZahl = sizeof(out1Pins);
 
//---------------- Initiierungswerte ( Factory-Defaults, per CV änderbar ) ------------------------
#define AUTOADDR    1   // Automatische Addresserkennung nach Erstinitiierung oder wonn PoM-Schalter aktiv
#define ROCOADDR    2   // 0: Outputadresse 4 ist Weichenadress 1
                        // 1: Outputadresse 0 ist Weichenadress 1
const byte iniMode          = 0x50 | AUTOADDR;  // default-Betriebsmodus
const byte DccAddr          =  1;    // DCC-Decoderadresse
const byte PomAddr          = 50;    // Adresse für die Pom-Programmierung
// Standardwerte für Servoausgang
const byte iniServoGerade   = 0;     // = Par1;
const byte iniServoAbzw     = 180;   // = Par2;
const byte inispeed = 8;             // = Par3;
#define SAUTOOFF 0x01
const byte iniAutoOff       = SAUTOOFF;     // = (Mode) automatische Pulsabschaltung
// Standardwerte für Puls-Ausgang (Doppelspule)
const byte iniPulseOn       = 50;    // = (Par1) 500ms Impuls
const byte iniPulseOff      = 20;    // = (Par2) mindestens 2Sec Pause zwischen 2 Pulsen
#define CAUTOOFF 0x01
const byte iniPulseAuto     =  CAUTOOFF;    // = (Mode) automatische Pulsbegrenzung eingeschaltet
 
//^^^^^^^^^^^^^^^^^^ Ende der anpassbaren Konstantenwerte ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// CV Default-Werte der Standardadressen:
struct CVPair {
  uint16_t  CV;
  uint8_t   Value;
};
CVPair FactoryDefaultCVs [] =
{
  {CV_ACCESSORY_DECODER_ADDRESS_LSB, DccAddr%256},
  {CV_ACCESSORY_DECODER_ADDRESS_MSB, DccAddr/256},
  {CV_VERSION_ID, DCC_DECODER_VERSION_ID},
  {CV_MANUFACTURER_ID, MAN_ID_DIY},
  {CV_29_CONFIG, CV29_ACCESSORY_DECODER | CV29_OUTPUT_ADDRESS_MODE},
};
 
// allgemeine defines ---------------------------------------------------------
#define servoPins out1Pins  // Portnamen fürs Servofunktion
#define relaisPins out2Pins
#define coil1Pins out1Pins  // Portnamen für Magnetartikelfunktion
#define coil2Pins out2Pins
 

//-------------------------------Definition der CV-Adressen ---------------------------------------
#define CV_START    47  // Startadresse des Decoderspezifischen CV-Blocks
typedef struct {        // Definition der Struktur des decoderspezifischen CV-Blocks
    byte modeVal;       // =0x5? wenn die CV-Werte initiiert sind. Bits 0..3 für Betriebsarten
    byte PomAddrLow;      // Adresse für die POM-Programmierung
    byte PomAddrHigh;
    struct {
        byte Mode;     // Betriebsart des Ausgangs
        byte Par1;    // Servo: Position AUS ( 0...180 Grad )
                      // DoppelspuleAuto: Einschaltzeit ( 10ms-Schritte )
                      // FBlinken:        Einschaltphase des Blinkens ( 10ms Schritte )
        byte Par2;    // Servo: Position EIN ( 0...180 Grad )
                      // DoppelspuleAuto: Einschaltzeit Ausgang 2 ( 10ms-Schritte )
                      // FBlinken:        Ausschaltphase des Blinkens ( 10ms Schritte )
        byte Par3;    // Servo: Speed
        byte State;   // aktueller Status des Ausgangs (Ein/Aus)
                      // Nach einem Neustart werden die Funktionsausgänge entsprechend eingestellt.
    } Fkt [WeichenZahl];
} CvVar_t;
 
const CvVar_t *CV = (CvVar_t *) CV_START; //Pointer auf die decoderspezifischen CV-Werte im EEProm
 

// ----------------------- Variable ---------------------------------------------------
byte opMode;                    // Bit 0..3 aus modeVal
byte rocoOffs;                  // 0 bei ROCO-Adressierung, 4 sonst
byte isOutputAddr;              // Flag ob Output-Adressing
word weichenAddr;               // Addresse der 1. Weiche (des gesamten Blocks)
byte weicheSoll[WeichenZahl];  // Solllage der Weichen
byte weicheIst[WeichenZahl];   // Istlagen der Weichen
#define GERADE  0x0
#define ABZW    0x1
#define MOVING  0x2               // nur für Ist-Zustand, Bit 1 gesetzt während Umlauf
 
//int geradePulse[WeichenZahl] ;  // Pulslänge geradeaus
//int abzweigPulse[WeichenZahl];  // Pulslänge abzweigend
 
byte relaisOut[WeichenZahl];    // Ausgabewerte für die Relais ( 0/1, entspricht Sollwert )
 
byte progMode;      // Merker ob Decoder im Programmiermodus
#define NORMALMODE  0
#define ADDRMODE    1   // Warte auf 1. Telgramm zur Bestimmung der ersten Weichenadresse
#define PROGMODE    2   // Adresse empfangen, POM-Programmierung möglich
 
Servo8 weicheS[WeichenZahl];
EggTimer AckImpuls;
EggTimer ledTimer;  // zum Blinken der Programmierled
// Pulsetimer für Doppelspulenantriebe
EggTimer pulseOffT[WeichenZahl];
EggTimer pulseOnT[WeichenZahl];
NmraDcc Dcc;
 

// für debugging ------------------------------------------------------------
#ifdef DEBUG
#define DB_PRINT( ... ) { sprintf( dbgbuf,"Dbg: " __VA_ARGS__ ) ; Serial.println( dbgbuf ); }
byte debug;
char dbgbuf[80];
#define SET_PROGLED
#define CLR_PROGLED
#else
#define DB_PRINT ;
#define SET_PROGLED digitalWrite( modePin, HIGH )
#define CLR_PROGLED digitalWrite( modePin, LOW )
#endif
 
//###################### Ende der Definitionen ##############################
//###########################################################################
void setup() {
    // Betriebsart auslesen
    if ( (Dcc.getCV( (int) &CV->modeVal)&0xf0) != ( iniMode&0xf0 ) ) {
        // In modeVal steht kein sinnvoller Wert,
        // alles initiieren mit den Defaultwerten
        // Wird über DCC ein 'factory-Reset' empfangen wird dieser Wert zurückgesetzt, was beim nächsten
        // Start ebenfalls zum initiieren führt.
 
        // Standard-CV's
        for ( byte i=0; i<(sizeof(FactoryDefaultCVs) / sizeof(CVPair)); i++ ) {
                Dcc.setCV( FactoryDefaultCVs[i].CV, FactoryDefaultCVs[i].Value);
        }
        // Decoderspezifische CV's
        Dcc.setCV( (int) &CV->PomAddrLow, PomAddr%256 );
        Dcc.setCV( (int) &CV->PomAddrHigh, PomAddr/256 );
        for ( byte i = 0; i<WeichenZahl; i++ ) {
            switch ( iniTyp[i] ) {
              case FSERVO :
                Dcc.setCV( (int) &CV->Fkt[i].Mode, iniAutoOff );
                Dcc.setCV( (int) &CV->Fkt[i].Par1, iniServoGerade );
                Dcc.setCV( (int) &CV->Fkt[i].Par2, iniServoAbzw );
                Dcc.setCV( (int) &CV->Fkt[i].Par3, inispeed );
                Dcc.setCV( (int) &CV->Fkt[i].State, 0 );
                break;
              case FCOIL:
                Dcc.setCV( (int) &CV->Fkt[i].Mode, iniPulseAuto );
                Dcc.setCV( (int) &CV->Fkt[i].Par1, iniPulseOn );
                Dcc.setCV( (int) &CV->Fkt[i].Par2, iniPulseOff );
                Dcc.setCV( (int) &CV->Fkt[i].Par3, 0 );
                Dcc.setCV( (int) &CV->Fkt[i].State, 0 );
                break;
            }
        }
        Dcc.setCV( (int) &CV->modeVal, iniMode );
    }
    // Betriebsart auslesen
    opMode = Dcc.getCV( (int) &CV->modeVal) &0x0f;
    rocoOffs = ( opMode & ROCOADDR ) ? 4 : 0;
 
    #if  VAR_ALLWAYSPOM != 0 
        // Pom-Modus ist immer aktiv, Programmierschalter und LED werden nicht genutzt
        progMode=PROGMODE;
    #else
        // PoM-Mode nur bei aktiviertem Programmierschalter
        pinMode( A4,OUTPUT);
        pinMode( modePin, OUTPUT );
        digitalWrite( modePin, LOW );
        // Auf Programmmiermodus prüfen
        pinMode ( progPin, INPUT_PULLUP);
        if ( digitalRead( progPin) == LOW ) {
            if ( opMode & AUTOADDR ) {
                progMode= ADDRMODE; // mit automatischer Adresserkennung
            } else {
                progMode = PROGMODE; // ohne automatische Adresserkennung
            }
        } else
            progMode = NORMALMODE;
            
        delay( 1000 );
    #endif
    
    #ifdef DEBUG
      pinMode( modePin, INPUT );
      Serial.begin(115200); //Debugging
      if ( progMode == NORMALMODE )
        Serial.println( "Normal Start of Program" );
      else
        Serial.println( "PoM Start of Program" );
    #endif
    
    pinMode( ackPin, OUTPUT );
    Dcc.pin( digitalPinToInterrupt(dccPin), dccPin, 1); 
    if ( progMode == NORMALMODE ) {
        Dcc.init( MAN_ID_DIY, DCC_DECODER_VERSION_ID, FLAGS_DCC_ACCESSORY_DECODER, (uint8_t)((uint16_t) 0) );
        CLR_PROGLED;
    } else {
        Dcc.init( MAN_ID_DIY, DCC_DECODER_VERSION_ID, FLAGS_DCC_ACCESSORY_DECODER, (uint8_t)((uint16_t) &CV->PomAddrLow) );
        #if  VAR_ALLWAYSPOM == 0 
        SET_PROGLED;
        #endif
    }
    
    //--- Ende Grundinitiierung ---------------------------------
 
    setWeichenAddr();
        
    DBprintCV(); // im Debug-Mode alle CV-Werte ausgeben
    
    for ( byte i=0; i<WeichenZahl; i++ ) {
        // Funktionen initiieren
        weicheIst[i] = Dcc.getCV( (int) &CV->Fkt[i].State );
        weicheSoll[i] = weicheIst[i];
        switch (iniTyp[i] )  {
          case FSERVO:
            weicheS[i].attach( servoPins[i], Dcc.getCV(  (int) &CV->Fkt[i].Mode) & SAUTOOFF );
            weicheS[i].setSpeed( Dcc.getCV(  (int) &CV->Fkt[i].Par3 ) );
            pinMode( relaisPins[i], OUTPUT );
            // Servowerte und Relaisausgang initiieren und ausgeben
            if ( weicheSoll[i] == GERADE ) {
                weicheS[i].write( Dcc.getCV( (int) &CV->Fkt[i].Par1 ) );
            } else {
                weicheS[i].write( Dcc.getCV( (int) &CV->Fkt[i].Par2 ) );
            }
            weicheIst[i] = weicheSoll[i];
            relaisOut[i] = weicheIst[i];
            digitalWrite( relaisPins[i], relaisOut[i] );
            break;
          case FCOIL:
            pinMode( coil1Pins[i], OUTPUT );
            pinMode( coil2Pins[i], OUTPUT );
            digitalWrite( coil1Pins[i], LOW );
            digitalWrite( coil2Pins[i], LOW );
            break;
            
        }
    }
}
////////////////////////////////////////////////////////////////
void loop() {
    if (digitalRead( A4)) digitalWrite(A4,LOW); else digitalWrite(A4,HIGH); // Test Zykluszeit
    
    Dcc.process(); // Hier werden die empfangenen Telegramme analysiert und der Sollwert gesetzt
    
    #ifdef DEBUG
    // Merker CV für CV-Ausgabe rücksetzen (MerkerCV ist 1.CV hinter dem CV-Block für die ausgangskonfiguration)
    Dcc.setCV( (int) &CV->Fkt[WeichenZahl].Mode , 0xff );
    #endif
    
    // Ausgänge ansteuern
    for ( byte i=0; i<WeichenZahl; i++ ) {
        switch ( iniTyp[i]  ) {
          case FSERVO: // Servoausgänge ansteuern ----------------------------------------------
            if ( weicheIst[i] & MOVING ) {
                // Weiche wird gerade ungestellt, Schaltpunkt Relais und Bewegungsende überwachen
                if ( weicheS[i].moving() < 50 ) relaisOut[i] = weicheIst[i]& 0x1;
                if ( weicheS[i].moving() == 0 ) {
                    // Bewegung abgeschlossen, 'MOVING'-Bit löschen und Lage in CV speichern
                    weicheIst[i] &= 0x1; 
                    Dcc.setCV( (int) &CV->Fkt[i].State, weicheIst[i] );
                }
            } else if ( weicheSoll[i] != weicheIst[i] ) {
                // Weiche muss umgestellt werden
                DB_PRINT( "WeicheIx=%d stellen, Ist=%d,Soll=%d", i, weicheIst[i], weicheSoll[i] );
                weicheIst[i] = weicheSoll[i] | MOVING; // Istwert auf Sollwert und MOVING-Bit setzen.
                if ( weicheSoll[i] == GERADE ) {
                    weicheS[i].write( Dcc.getCV( (int) &CV->Fkt[i].Par1 ) );
                } else {
                    weicheS[i].write( Dcc.getCV( (int) &CV->Fkt[i].Par2 ) );
                }
            }
            // Relaisausgänge setzen
            digitalWrite( relaisPins[i], relaisOut[i] );
            break;
 
          case FCOIL: //Doppelspulenantriebe ------------------------------------------------------
            if ( ! pulseOffT[i].running() && ! (weicheIst[i]&MOVING) ) {
                // Aktionen am Ausgang nur wenn kein aktiver Impuls und der Pausentimer nicht läuft
                if ( weicheIst[i] != weicheSoll[i] ) {
                    // Weiche soll geschaltet werden
                    //DB_PRINT(" i=%d, Ist=%d, Soll=%d", i, weicheIst[i], weicheSoll[i] );
                    if ( weicheIst[i] ) {
                        // Out1 aktiv setzen
                        digitalWrite( coil1Pins[i], HIGH );
                        digitalWrite( coil2Pins[i], LOW );
                        //DB_PRINT( "Pin%d HIGH, Pin%d LOW", coil1Pins[i], coil2Pins[i] );
                    } else {
                        // Out2 aktiv setzen
                        digitalWrite( coil2Pins[i], HIGH );
                        digitalWrite( coil1Pins[i], LOW );
                        //DB_PRINT( "Pin%d LOW, Pin%d HIGH", coil1Pins[i], coil2Pins[i] );
                    }
                    pulseOnT[i].setTime( Dcc.getCV( (int) &CV->Fkt[i].Par1 ) * 10 );
                    weicheIst[i] = weicheSoll[i] | MOVING;
                    Dcc.setCV( (int) &CV->Fkt[i].State, weicheSoll[i] );
                }
                
            }
            // Timer für Spulenantriebe abfragen
            if ( iniTyp[i] == FCOIL ) {
                // prüfen ab Impuls abgeschaltet werden muss
                // (Timer läuft nicht mehr, aber MOVING-Bit noch gesetzt)
                if ( !pulseOnT[i].running() && (weicheIst[i]&MOVING) ) {
                    digitalWrite( coil2Pins[i], LOW );
                    digitalWrite( coil1Pins[i], LOW );
                    weicheIst[i]&= ~MOVING;
                    //DB_PRINT( "Pin%d LOW, Pin%d LOW", coil1Pins[i], coil2Pins[i] );
                    pulseOffT[i].setTime( Dcc.getCV( (int) &CV->Fkt[i].Par2 ) * 100 );
                }
                
            }
            break;
        } // - Ende Switch Funktionstypen-------------------------------------------
    } // Ende Schleife über die Funktionen (Weichen)---------------
 

 
    // Ackimpuls abschalten--------------------------
    if ( !AckImpuls.running() ) digitalWrite( ackPin, LOW );
 
    #if VAR_ALLWAYSPOM == 0
    // Programmierled blinkt im Programmiermode nach dem Empfang einer Adresse
    if ( ! ledTimer.running() && progMode == PROGMODE) {
        ledTimer.setTime( 500 );
        if ( digitalRead( modePin ) ) 
            CLR_PROGLED;
        else
            SET_PROGLED;
    }
    #endif
}
//////////////////////////////////////////////////////////////
// Unterprogramme, die von der DCC Library aufgerufen werden:
//------------------------------------------------
// Die folgende Funktion wird von Dcc.process() aufgerufen, wenn ein Weichentelegramm empfangen wurde
void notifyDccAccState( uint16_t Addr, uint16_t BoardAddr, uint8_t OutputAddr, uint8_t State ){
    // Weichenadresse berechnen
    word wAddr = Addr+rocoOffs; // Roco zählt ab 0, alle anderen lassen die ersten 4 Weichenadressen frei
    // Im Programmiermodus bestimmt das erste empfangen Programm die erste Weichenadresse
    if ( progMode == ADDRMODE ) {
        // Adresse berechnen und speichern
        if (isOutputAddr ) {
            weichenAddr = wAddr;
            Dcc.setCV( CV_ACCESSORY_DECODER_ADDRESS_LSB, wAddr%256 );
            Dcc.setCV( CV_ACCESSORY_DECODER_ADDRESS_MSB, wAddr/256 );
        } else {
            Dcc.setCV( CV_ACCESSORY_DECODER_ADDRESS_LSB, BoardAddr%64 );
            Dcc.setCV( CV_ACCESSORY_DECODER_ADDRESS_MSB, BoardAddr/64 );
            weichenAddr = (Dcc.getAddr( )-1)*4 +1 + rocoOffs;
        }
        progMode = PROGMODE;
        DB_PRINT( "Neu: Boardaddr: %d, 1.Weichenaddr: %d", BoardAddr, weichenAddr );
    }
    // Testen ob eigene Weichenadresse
    //DB_PRINT( "DecAddr=%d, Weichenadresse: %d , Ausgang: %d, State: %d", BoardAddr, wAddr, OutputAddr, State );
    for ( byte i = 0; i < WeichenZahl; i++ ) {
        if (  wAddr == weichenAddr+i ) {
            // ist eigene Adresse, Sollwert setzen
            weicheSoll[i] =  OutputAddr & 0x1;
            DB_PRINT( "Weiche %d, Index %d, Soll %d, Ist %d", wAddr, i, weicheSoll[i],  weicheIst[i] );
            break; // Schleifendurchlauf abbrechen, es kann nur eine Weiche sein
        }
    }
}
//---------------------------------------------------
// wird aufgerufen, wenn die Zentrale ein CV ausliest. Es wird ein 60mA Stromimpuls erzeugt
void notifyCVAck ( void ) {
    // Ack-Impuls starten
    //DB_PRINT( "Ack-Pulse" );
    AckImpuls.setTime( 6 );
    digitalWrite( ackPin, HIGH );
}
//-----------------------------------------------------
// Wird aufgerufen, nachdem ein CV-Wert verändert wurde
void notifyCVChange( uint16_t CvAddr, uint8_t Value ) {
    // Es wurde ein CV verändert. Ist dies eine aktive Servoposition, dann die Servoposition
    // entsprechend anpassen
    DB_PRINT( "neu: CV%d=%d", CvAddr, Value );
    for ( byte i=0; i<WeichenZahl; i++ ) {
        // prüfen ob Ausgang einen Servo ansteuert:
        switch ( Dcc.getCV( (uint16_t) &CV->Fkt[i].Mode ) ) {
          case FSERVO:
            // gehört der veränderte CV zu diesem Servo?
            if (  (CvAddr == (uint16_t) &CV->Fkt[i].Par1 && weicheSoll[i] == GERADE) ||
                  (CvAddr == (uint16_t) &CV->Fkt[i].Par2 && weicheSoll[i] == ABZW ) ){
                // Es handelt sich um die aktuelle Position des Servos,
                // Servo neu positionieren
                DB_PRINT( "Ausg.%d , Pos. %d neu einstellen", i, weicheSoll[i] );
                 weicheS[i].write( Value );
            } else if ( CvAddr == (uint16_t) &CV->Fkt[i].Par3 ) {
                // die Geschwindigkeit des Servo wurde verändert
                weicheS[i].setSpeed( Value );
            }
        }
    }
    #ifdef DEBUG
        // prüfen ob die CV-Adresse HINTER den Weichenadressen verändert wurde. Wenn ja,
        // alle CV-Werte ausgeben und Wert wieder auf 0xff setzen
        if ( CvAddr ==  (int) &CV->Fkt[WeichenZahl].Mode && Value !=0xff ) {
            DBprintCV();
        }
    #endif
 
    // prüfen ob die Weichenadresse verändert wurde. Dies kann durch Ändern der
    // Adressierungsart in CV29 oder direkt durch Ändern der Decoderadresse geschehen.
    // Wird die Decoderadresse geändert muss zuerst das MSB (CV9) verändert werden. Mit dem
    // Ändern des LSB (CV1) wird dann die Weichenadresse neu berechnet
    if ( CvAddr ==  29 || CvAddr ==  1 ) setWeichenAddr();
 
    // Prüfen ob die Betriebsart des Decoders verändert wurde
    if ( CvAddr == (int) &CV->modeVal ) {
        // Die Betriebsart wurde verändert -> Neustart
        delay( 500 );
        softReset();
    }
}    
//-----------------------------------------------------
void notifyCVResetFactoryDefault(void) {
    // Auf Standardwerte zurücksetzen und Neustart
    Dcc.setCV( (int) &CV->modeVal, 255 );
    delay( 500 );
    softReset();
}
//------------------------------------------------------
#ifdef DEBUG
void notifyDccReset( uint8_t hardReset ) {
    if ( hardReset > 0 ) DB_PRINT("Reset empfangen, Value: %d", hardReset);
    // wird bei CV-Auslesen gesendet
}
#endif
//--------------------------------------------------------
 
/////////////////////////////////////////////////////////////////////////
// Allgemeine Unterprogramme 
void setWeichenAddr(void) {
    // Adressmodus aus CV29 auslesen
    isOutputAddr = Dcc.getCV( CV_29_CONFIG ) & CV29_OUTPUT_ADDRESS_MODE;
    // Adresse der 1. Weiche aus Decoderaddresse berechnen
    if ( isOutputAddr ) 
        weichenAddr = Dcc.getAddr( );
    else
        weichenAddr = (Dcc.getAddr( )-1)*4 +1 + rocoOffs ;
}
//--------------------------------------------------------
void softReset(void){
;asm volatile ("  jmp 0");
}
//-----------------------------------------------------------
#ifdef DEBUG
void DBprintCV(void) {
    // für Debug-Zwecke den gesamten genutzten CV-Speicher ausgeben
    // Standard-Adressen
    DB_PRINT ("--------- Debug-Ausgabe CV-Werte ---------" );
    DB_PRINT ("Version: %d, ManufactId: %d", Dcc.getCV( CV_VERSION_ID ), Dcc.getCV( CV_MANUFACTURER_ID ) );
    DB_PRINT ("Konfig   (CV29)  : 0x%X", Dcc.getCV( CV_29_CONFIG ) );
    DB_PRINT ("Adresse: (CV1/9) : %d", Dcc.getCV( CV_ACCESSORY_DECODER_ADDRESS_LSB )+Dcc.getCV( CV_ACCESSORY_DECODER_ADDRESS_MSB )*256);
    DB_PRINT ("1.Weichenaddresse: %d", weichenAddr );
    
    // Decoder-Konfiguration global
    DB_PRINT ( "Initierungswert: 0x%x (%d) ", Dcc.getCV( (int) &CV->modeVal ), Dcc.getCV( (int) &CV->modeVal ) );
    DB_PRINT ( "PoM-Adresse    : %d"   , Dcc.getCV( (int) &CV->PomAddrLow) + 256* Dcc.getCV( (int) &CV->PomAddrHigh ) );
    
    // Output-Konfiguration
    DB_PRINT( "Wadr | Typ | CV's  | Mode | Par1 | Par2 | Par3 | Status |");
    for( byte i=0; i<WeichenZahl; i++ ) {
        DB_PRINT( "%4d |%4d | %2d-%2d | %4d | %4d | %4d | %4d | %3d ", weichenAddr+i, iniTyp[i],
                                                                 &CV->Fkt[i].Mode,  &CV->Fkt[i].State,
                                                                 Dcc.getCV( (int)  &CV->Fkt[i].Mode ),
                                                                 Dcc.getCV( (int)  &CV->Fkt[i].Par1 ),
                                                                 Dcc.getCV( (int)  &CV->Fkt[i].Par2 ),
                                                                 Dcc.getCV( (int)  &CV->Fkt[i].Par3 ),
                                                                 Dcc.getCV( (int)  &CV->Fkt[i].State ) );
    }
    
}
#else
void DBprintCV(void) {
    
}
#endif
 
 

Der Code steht jetzt auch auf GitHub zum Download zur Verfügung.

[FarFarAway]

Lange nichts mehr los hier.

Aber erst mal ein herzliches Hallo in die Runde.

Habe mit interesse den ganzen Thread durchgelesen und mich dazu entschlossen in die Adruino Welt einzusteigen. Also herzlichen Dank fuer die Infektion!

Da meine Garage noch immer voll KrimsKrams steht ist noch keine Anlage vorhanden. Aber diverse Komponenten sind schon angeschafft. Ich habe schon ein paar GBMs aus dem OpenDCC Projekt, aber die Schaltdekoder sind schon ne ganz schoener preislicher Hammer.

Eine eigene Entwicklung werde ich dann auch beizeiten beisteuern, wenn es dann an die Automatisierung meiner selbstgebauten Segmentdrehscheibe mit Verriegelungngeht.
Antreiben moechte ich diese mit einem Schrittmotor. Als Adresse nehme moechte ich dann eine Lokadresse verwenden undnden anzusteuernden Abgang als Geschwindigkeit setzen. fuer jeden Abzweig muss dann ein CV eingerichtet werden, der die Schritte vom definierten Nullpunkt enthaelt. Also wohl eher 2 CVs da groesser als 256. Hoffe unter 65536...
Vor jeder Bewegung muss per Servo die Verriegelung geloest und nach dem Buehnenverschub auch wieder geschlossen werden.

Dies muss dann der Steuerungs-Software mitgeteilt werden was dann wohl am einfachsten per Belegtmelder erfolgen kann.

Natuerlich soll die Buehne langsam anfahren und dann schneller werden. Beim Anhalten dann in umgekehrter Reihenfolge fuers Bremsen.

Mit CVs fuer die Schritte einer ganzen Umrundung koennten wir dann eine komplette Drehscheibensteuerung zusammen basteln.

Cheers,
Klaus

[Bodo]

Hallo Klaus,

das wird ein sehr interessantes Projekt . Mir spukt auch immer noch eine Wagendrehscheibe im Kopf herum - die hätte ähnliche Anforderungen, nur dass der Servo dann eher den Wagen blockieren als die Scheibe verriegeln müsste ... Ich werde mich aber ganz sicher zuerst mit der Mechanik beschäftigen, bevor ich wieder nur eine Prinzip-Lösung rumliegen habe ...

Viele Grüße, Bodo

[EddiO]

Hallo Klaus,

du kannst auch auf dem OpenDCC Homepage dir mal die Steuerung für eine Drehscheibe angucken http://www.opendcc.de/elektronik/drehsch...rehscheibe.html .

Diese wird über den BiDi-Bus verbunden und bietet auch eine Rückmeldung an die Zentrale mit RailCom und Fahrrichtungerkennung der Lok.

Ich versuche momentan (aus Zeitmangel noch verschoben) noch einen Arduino an den BiDi Bus zu binden, so dass man den Arduino nicht nur als Zubehördecoder sondern auch als Rückmelder verwenden kann.

Edgar

[MicroBahner]

Hallo Klaus,
eine Drehscheibensteuerung mit Schrittmotor wäre auch sicher ein interessantes Projekt. Ist aber ebenso sicher nicht ganz simpel - auch von der Mechanik her, wie Bodo schon angedeutet hat.
Das Anfahren und Bremsen beim Schrittmotor hatte ich für meine MobaTools auch schonmal angedacht. Ist ja auch für den Schrittmotor besser, denn wenn mann den gleich mit schnellen Schritten ansteuert, kann er sich am Anfang schonmal 'verschlucken'. Wenn da Interesse besteht, könnte ich mir das tatsächlich mal vornehmen .