[MicroBahner]

Hallo,
wenn wir den Arduino für die MoBa einsetzten, so gibt es einige Aufgaben, die immer wieder vorkommen:
Ein Servo langsam bewegen, eine Led weich auf- oder abblenden oder auch ganz einfach Zeitverzögerungen ohne den Arduino dabei zu blockieren.
Ich möchte hier eine Bibliothek vorstellen, die diese Aufgaben erleichtert. Mit einfachen Sketches möchte ich die Anwendung dieser Bibliothek zeigen.
Zug um Zug soll hier die Anwendung der Bibliothek gezeigt werden und es wird auch immer mal wieder ein Update geben.

Die Bibliothek enthält Funktionen um
- Servos langsam zu bewegen ( max 16 Servos )
- Schrittmotoren anzusteuern ohen den Sketch zu blockieren ( max 4 Schrittmotore )
- Leds weich auf- und abzublenden ( an jedem digitalen Ausgang möglich )
- Zeitverzögerungen ohne 'delay' und damit ohne Blockieren des loop zu realisieren

Wie man diese nutzt, möchte ich hier Zug um Zug in einfachen Sketches vorstellen.

Inhaltsverzeichnis der bisher vorgestellten Demo's:
Update 14.12.16:Die ersten 3 Beispiele waren mit den aktuellen MobaTools nicht lauffähig. Das ist jetzt korrigiert ( die alten Versionen gibt es ja nicht mehr)
Baustellenblinker
Multitasking
einfacher DCC Weichendecoder
Schweisslicht(von Marko)
DCC-Decoder(von Bodo)
DKW-Weichendecoder( von Ulli )
DCC-Multifunktionsdecoder
universeller DCC-Zubehördecoder
Universeller DCC-Zubehördecoder V2 Beta

Der DCC-Zubehördecoder hat sich schon seit längerem 'verselbständigt' und hat einen eigenen Thread hier im Forum.
Die aktuellen Sourcen und die Dokumentation können direkt von Github heruntergeladen werden.


--------------------------------------------------------------------------------------------------------------------------
Servos langsam bewegen

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
 

#include <MobaTools.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
}
 
void loop() {
    tasterStatus1 = digitalRead(tasterPin1);
    tasterStatus2 = digitalRead(tasterPin2);
 
    if (tasterStatus1 == LOW ) {
        meinServo.write(40); //wird langsam  drehen
        delay(100);
    }
 
    if (tasterStatus2 == LOW) {
        meinServo.write(150); //wird langsam drehen
        delay(100);
    }
 
    delay(20);
 
}
 

Mit diesem kleinen Sketch kann man sehen, wie ein Servo ganz einfach langsam bewegt werden kann:
sobald einTaster gedrückt wird, bewegt sich das Servo langsam in die eine bzw. andere Richtung.
Wer das nun ausprobiern will, wird aber erstmal eine Fehlermeldung bekommen. Klar, der Arduino weis ja noch nichts von einer MoBa-Bibliothek. Die muss erst installiert werden.
11.12.18: Die MobaTools können jetzt auch direkt über den Bibliotheksverwalter der IDE installiert werden:
Im Menue: Sketch->Bibliothek einbinden->Bibliotheken verwalten... ( oder Ctrl+Shift+I ).
Dann im Suchfeld oben rechts 'mobatools' eingeben. Da gibt's dann automatisch auch immer die neueste Version.

Es geht natürlich auch noch mit dem Herunterladen der Datei:

>> MoBaToolsV2.6.1.zip<<

Falls es Probleme gibt, die alte Version existert auch noch:
>> MoBaToolsV2.5.1.zip<<

und speichert sie in einem Verzeichnis - z.B. dem Downloadverzeichnis - ab.
Mit der Arduino IDE kann nun die Bibliothek installiert werden:
Mit dem Menüpunkt: Sketch->Include Library->Add.ZIP Library öffnet sich ein Explorerfenster. Dort zum Downloadverzeichnis navigieren, die Datei 'MoBaTools.zip' auswählen und auf Öffnen klicken.
Nun sollte der obige Sketch übersetzbar sein, und kann ausprobiert werden.
Wer nur erstmal die Doku lesen will: MobaTools-260-de.pdf
Die Library enthält auch kleine Demos, die aus der IDE über 'Datei'->'Beispiele' aufgerufen werden können.

Bei Fragen ,Problemen oder Anregungen - nur zu. Es gibt keine dummen Fragen, nur dumme Antworten


P.S. Die Servo-Funktionen der Standard Library und die hier vorgestellten können nicht parallel genutzt werden, das sie dieselben Hardwarekomponenten benutzen. Edit: gilt auch für das weiche Led auf/abblenden.
Die MoBaTools sind kompatibel mit Arduino Uno, mini, nano, Leonardo und micro. Ich hatte aber noch keine Möglichkeit, sie auf den 8MHz Versionen zu testen.
=================================
Versionsinfo:
hier gibts Informationen zu Aktualisierungen. Das Zip-File hier im Post entspricht immer der letzten Version. Vor einem update muss die bisherige Version im Library-Verzeichnis gelöscht werden (Ausser beim Update über den Bibliotheksmanager).
V2.6.1 - 17.12.2023

• Bugfix wenn auf UNO R4 WiFi Stepper und WiFi gleichzeitig genutzt wird
• 2 weitere Beispiele:
  MoToButtons: 4x5 Matrix über I2C mit PCF8575
  MoToStepper: Steppersteuerung über Browser auf dem UNO R4 WiFi

V2.6.0 - 2.12.2023

• UNO R4 Minima and UNO Rev4 Wifi werden unterstützt
• stepper.read() kann die aktuelle Winkelposition nun auch in Winkelbruchteilen zurückmelden ( z.B. 1/10° ). Im Prinzip so wie auch bei der Winkelvorgabe in stepper.write().

V2.5.0 - 12.9.2023

• Das ESP32 2.x core package wird nun unterstützt. Das führte bisher zu diversen Fehlermeldungen ( Die neuen ESP32S2, ESP32S3, ESP32C3 werden aber noch nicht unterstützt )
• ATmega4809 wird unterstützt ( Nano Every, UNO WiFi Rev2 (
• .setSpeedSteps(0) ist nun erlaubt, und ermöglicht den stepper zu stoopen, ohne die ursprüngliche Zielposition zu verlieren
• .getSpeedSteps() zeigt nun auch die Drehrichtung an ( negative Werte bedeuten rückwartsdrehen )
• .attachEnable( int delayTime ) erlaubt das Abschalten von 4-pinSteppern (FULLSTEP/HALFSTEP) ohne speziellen enable pin

V2.4.0 - 28.5.2021

• ESP32 wird nun unterstützt
• Auf dem ESP32 werden die Servopulse per HW erzeugt, was sie deutlich stabiler macht.
• ATTinys werden unterstützt, die einen 16-Bit Timer 1 und eine USI oder SPI Hardware haben
• Durch interne Optimierungen sind die Stepraten für STM32F1 und ESP32 nun deutlich höher ( bis 30kHz )
• zusätzliche Funktionalität bei MoToTimer

V2.3.1 - 7.11.2020

• Fehler in MoToStepper beseitigt: doSteps(0) hat nicht funktioniert, wenn die Rampenlänge 0 war. Dann wurde nicht gestoppt, sondern die Drehrichtung umgekehrt.

V2.3.0 - 31.7.2020

• Neue Klasse 'MoToTimebase' mit der Ereignisse in regelmäßigen Abständen ausgelöst werden können. Dies ist genauer, als wenn man dies mit MoToTimer selbst macht.
• MoToButtons: Ein 'longPress' wird jetzt sofort ausgelöst, wenn die Taste entsprechend lang gedrückt wird, nicht erst bein Loslassen.
• MoToStepper: Wenn der Nullpunkt gesetzt wird, kann jetzt auch die Zahl der Steps/Umdrehung neu gesetzt werden.
• Es gibt ein paar zusätzliche Beispiele.
• Es wurden ein paar Fehler beseitigt ;)

V2.2.0 - 23.2.2020

• In der Klasse MoToButtens gibt es eine neue Methode 'clicked' mit der einfache und Doppelklickes erkannt werden können.
• Sind alle Taster/Schalter einfach jeweils an einen eigenen Pin angeschlossen ( und schalten gegen Gnd ), so ist keine Callbackfunktion mehr notwendig.

V2.1.1 - 8.2.2020

• Fehler bei MoToServo beseitig, der in die letzte Version reingerutscht ist - es funktionierte nur noch mit einem Servo.

V2.1.0 - 6.2.2020

• Es gibt eine neue Klasse 'MoToButtons'. Damit können mehrere Taster/Schalter ( bis zu 32 / Instanz ) verwaltet werden. Die Klasse übernimmt das Entprellen und stellt den Status der Taster und Events ( Drücken, Loslassen, lange Drücken und kurz Drücken ) zur Verfügung.
  Die Lib ist speziell dazu gedacht, wenn mehrere Taster/Schalter verwaltet werden sollen. Das Einlesen der HW ist deshalb über eine CallBack Funktion realisert. Damit sind Matrixanordnung und/oder das Einlesen über z.B. I2C Portextender möglich.
• Der MoToTimer hat eine neue Methode 'expired'. Diese liefert nur einmalig 'true' zurück, nachdem der Timer abgelaufen ist. Alle weiteren Aufrufe sind wieder 'false'. Damit können sehr einfach Aktionen ausgelöst werden, die nach dem Ablauf des Timers nur einmalig gestartet werden sollen.
• MoToButtons und MoToTimer können, wenn gewünscht, auch einzeln in einen Sketch eingebunden werden ( MoToTimer.h / MoToButtons.h ). Die komplette Klassendefinition ist in den .h Files enthalten. Speicher spart es allerdings nicht. Auch mit 'MobaTools.h' wird nur das eingebunden, was wirklich genutzt wird.

V2.0.0 - 13.1.2020

• Der WLAN-Chip ESP8266 wird jetzt auch unterstützt ( der schafft beim Stepper bis zu 8000 Steps/Sec)
• Bei Steppern kann ein enable-Pin verwaltet werden, um den Motor im Stillstand abzuschalten
• in der Stepperklasse gibt es eine neue Funktion 'getSpeedSteps', die die aktuelle GEschwindigkeit ( auch in der rampe) zurückgibt.
• Die Klassennamen haben sich geändert und wurden vereinheitlicht. Die alten funktionieren zwar auch noch, sollten aber bei neuen Sketchen nicht mehr verwendet werden

V1.1.4 - 25.9.2019

• Es gab Probleme, wenn die Steprate auf '0' gestellt wurde. Das ist nicht zulässig und wird nun abgefangen ( wird dann intern auf '1' gesetzt)
• Wurde die Zielposition im Modus ohne Rampe in sehr schneller Folge ( schneller als die Steprate ) aktualisiert, kam es zu einem Fehler bei der Steperzeugung.
• Es sind jetzt höhere Stepraten ( bis 2500 Steps/Sek) möglich. Der relative Jitter wird dann zwar rel groß ( ist absolut immer 200µs), es hat aber in Versuchen immer gut funktioniet. Damit kann jetzt auch besser mit Microsteps gearbeitet werden.

V1.1.3 - 22.8.2019

• Fehler beseitigt beim Umrechnen von Winkel<->Steps
• Bei Softled sind jetzt auch längere Zeiten (bis 10sec) möglich
• weitere kleinere Fehlerbereinigunge und Optimierungenn

V1.1.2 - 3.8.2019

• Fehler beseitigt: Sketch stürzte ab, wenn nur Servo genutzt wurde
• V1.1.1 nicht mehr verwenden
• Bei einem detach werden die verwendeten Pins wieder auf 'INPUT' gestellt

V1.1.1 - 29.7.2019

• Stepper mit Anfahr/Bremsrampe
• Feinere Geschwindigkeitsauflösung bei höhern Stepraten
• Der Code wurde intern gesplittet, so dass der Programmspeicherverbrauch deutlich sinkt, wenn nur ein Teil der Funktionalität genutzt wird.

V1.1.0 - 26.6.19 - GESPERRT

• Achtung, hier gab es ein Problem mit dem Bibliotheksmanager, er installiert einen falschen Stand
• Diese Version NICHT nutzen

V1.0.3 - 23.2.19

• Fehlerbeseitigung: Servos funktionierten nicht an Pin 0
• Umstellung auf das 1.5 Library-Format ( Source-Dateien im Unterordner 'src' )

V1.0 - 5.11.2017

• Auf AVR-Platformen mit mehr als einem 16-bit-Timer verwenden die MoBa-Tools nun automatisch den Timer 3. Dies ermöglicht die parallele Verwendung von anderen Libs, die auch den TImer 1 verwenden auf diesem Plattformen. Dies gilt z.B. für Arduino Leonardo, Micro, Pro Micro und Mega.
• Servo's: ist 'AUTOOFF aktiv und es wird ein servo.write-Befehl auf die aktuelle Position ausgegeben, so werden nun für ca 1sec Servoimpuls ausgegeben. Die Vorgängerversionen haben in diesem Fall keine Impulse ausgegeben.

V0.9 - 1.3.2017

• Softled-Ausgänge konnen invertiert werden ( ON = LOW )
• Der speed-Parameter bei Servos hat eine feinere Auflösung
• STM32F1 Prozessoren werden unterstützt (stm32duino)

V0.8 - 3.2.2017
-Softleds funktionieren nun an allen Digitalausgängen, nicht nur an PWM-fähigen.

V0.7 - 20.1.2017
-Unterstützung des Schrittmotortreibers A4988

V0.6 - 17.10.2015
-kleine Erweiterung bei den Methoden/Funktionen des Schrittmotors
-Doku ergänzt zum Schrittmotoranschluß über SPI
-kleine Fehlerbeseitigungen
-Die MobaTools installieren sich jetzt wieder unter 'MobaTools' und nicht mehr unter 'MobaTools1' ( das war in der letzten Version noch eine Folge meiner Testumgebung )
-wegen der Größe jetzt nicht mehr hier als Anhang, sondern als Download von OneDrive

V0.5 - 4.10.2015
-Erweiterung auf bis zu 16 Servos. Die Impulse werden jetzt softwaremäßig erzeugt und können daher an beliebigen Pins ausgegeben werden.
-Des weiteren ist jetzt auch die Ansteuerung von bis zu 4 Schrittmotoren integriert. Die Ansteuerung der Schrittmotore geschieht ebenfalls im Hintergrund, und blockiert den Programmablauf im loop nicht.
-Beseitigung eines Fehlers in der detach-Funktion.
V0.2 - 17.9.2015
Servoansteuerung geändert: Beim attach fuhr das Servo bisher immer in die Mittelstellung. Jetzt bestimmt das erste write nach dem attach die Ausgangsposition. Vor diesem ersten write werden noch keine Impulse ausgegeben. Damit kann die Anfangsposition flexibel festgelegt werden.
Der detach-Befehl schaltet die Servoimpulse ab, wobei sichergestellt ist, dass auch der letzte Impuls nicht abgeschnitten ist.

[Bodo]

Hallo Franz-Peter,

ganz kurz und knapp:

Viele Grüße, Bodo

[tauberspatz]

Hallo Franz-Peter

Zitat von MicroBahner

---

Ich möchte hier eine Bibliothek vorstellen, die diese Aufgaben erleichtert.

---

also anstelle von #include <stdio.h>
ich hoffe mit meinem Video nicht alles ins Durcheinander zu bringen, habe die #include <MobaTools.h> Bibliothek abgespeichert und den Sketch kopiert
1 Servo an Pin 9
1 Taster an Pin 2
1 Taster an Pin 3
das ist dabei raus gekommen
wenn du das Video nicht haben möchtest nehme ich es wieder raus

[MicroBahner]

Hallo Karin,
grundsätzlich sieht es ja gar nicht sooo schlecht aus . Das Verhalten, das in deinem Video zu sehen ist, passiert bei diesem einfachen Sketch wenn beide Eingänge gleichzeitig als LOW erkannt werden. Dann macht das das Servo bei mir auch.
Wie hast du die Taster verdrahtet? Ich sehe auch 2 Widerstände. Eigentlich reicht es, wenn die Taster beim Drücken den Eingang nach GND ziehen - ohne weitere Beschaltung. EIn Pull-Up Widerstand nach 5V ist im Prozessor bereits enthalten, und wird durch das INPUT_PULLUP aktiviert. Extern ist also gar kein Widerstand notwendig. Es sollte übrigends reichen, die Taster nur kurz zu drücken, das Servo muss sich dann von alleine weiterbewegen. Wenn Du dann während der Bewegung den anderen Taster antippst, muss sich die Bewegungsrichtung sofort umkehren.
Hast Du mal das Beispiel 'Servo_02' aus der Library getestet? Da reagiert das Programm während der Servobewegung nicht mehr auf die Taster. Wenn dann beide Taster gleichzeitig aktiv sind, bewegt sich das Servo einfach zwischen den Endpunkten hin- und her.

[tauberspatz]

Hallo Franz-Peter
ja bei dem Video ist zu sehen ,dass es nicht so gelaufen ist wie es sollte ops: ich musste die Taster gedrückt halten damit sich was bewegt, ausserdem gab es noch dieses selbstständige Zurücklaufen in winzigen Schritten...

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

ich habe die Taster genauso angeschlossen wie in meinen Sketch , das hat ja auch funktioniert aber dann hatte ich eine Idee

... habe den Sketch geändert und aus ==LOW bei Taster 1 und 2 einfach ==HIGH gemacht und jetzt funktioniert es

vorher
[color=#000080]if (tasterStatus1 == LOW ) {
meinServo.write(40); //wird langsam drehen
delay(100);[/color]

nachher
[color=#000080]if (tasterStatus1 == HIGH ) {
meinServo.write(40); //wird langsam drehen
delay(100);[/color]


und wegen der Widerstände stand dies so in meiner Funduino Anleitung :

"Wenn man den Taster einfach nur mit dem Mikrocontroller verbindet, dann liegt an dem Pin des Mikrocontrollers eine Spannung an, sobald der Taster gedrückt wird. Man kann sich das so vorstellen, als würden an dem besagten Pin ganz viele Elektronen herumschwirren. Wenn der Taster dann losgelassen wird, kommen keine neuen Elektronen mehr zu dem Pin am Mikrocontroller hinzu. Jetzt kommt der Knackpunkt. Die Elektronen, die es sich vorher auf dem Pin gemütlich gemacht haben, sind dann immer noch da und entweichen nur ganz langsam über kleine Kriechströme. Der Mikrocontroller denkt dann also, dass der Taster nicht nur kurz gedrückt wird sondern dass er ganz lange gedrückt wird. Nämlich so lange, bis sich keine Elektronen mehr auf dem Pin aufhalten. Dieses Problem kann man dadurch beheben, dass man den Pin über einen Widerstand mit ca. 1000 Ohm (1 K Ohm) erdet. Die Elektronen können dadurch recht schnell vom Pin abfließen und der Mikrocontroller erkennt, dass der Taster nur kurz „angetastet“ wurde. Da der Widerstand die Spannung an dem Eingangspin immer auf 0V „herunter zieht“, wird er auch als „PULLDOWN-“ Widerstand bezeichnet. ACHTUNG: Wenn man dafür einen zu kleinen Widerstand verwendet, kann beim Drücken des Tasters ein Kurzschluss auf dem Mikrocontroller entstehen."

den zweiten Sketch habe ich noch nicht ausprobiert, muss mal sehen wie weit ich komme denn bis jetzt habe ich nur ein Servo zum Ausprobieren
NACHTRAG
habe den zweiten gerade ausprobiert, Servo läuft von allein rechts links ohne Taster...toll, bei LOW
jetzt habe ich wieder LOW in HIGH umgeschrieben und es läuft so wie du beschrieben hast

[MicroBahner]

Hallo Karin,
super, dass es jetzt läuft .
Es gibt 2 Möglichkeiten, einen Schalter/Taster an einen Input anzuschließen. Immer wird der Schalter und ein Widerstand benötigt:

Links ist die von dir angewendete Möglichkeit, wie sie wohl auch in der Funduino-Anleitung beschrieben ist ( ich geb's zu, die habe ich nicht gelesen ). Wenn der Taster gedrückt wird, wird der Eingang mit 5V verbunden, und das Programm liest HIGH. Ist der Taster offen, wird der Eingang über den Widerstand mit Gnd verbunden, und das Programm liest LOW.
Die rechte Variante funktioniert genau anders herum. Da ist der Taster mit Gnd verbunden, und der Widerstand ist mit 5V verbunden. Das schöne an dieser Variante ist, dass der Widerstand im µC bereits vorhanden ist. Man muss in nur noch mit dem Eingang verbinden. Und genau das macht der INPUT_PULLUP. In der Regel verwende ich diese Variante, weil man sich da den externen Widerstand spart . Aber man muss dann im Programm auch andersherum abfragen - bei gedrücktem Taster erkennt das Programm LOW.

[MicroBahner]

Hallo an alle Moba- und Arduino Interessierte

anbei ein weiterer kleiner Sketch, der den Einsatz der MobaTools zeigt. Diesmal schon etwas durchaus 'einsetzbares'.
Eine Baustellenabsperrung mit 4 Warnblinkern. Diese Blinker sind oft akkubetriebene Geräte, die zwar vom gleichen Typ sind,
deren Blinkfrequenz aber doch nicht exakt gleich ist. Daraus ergibt sich dann ein recht 'chaotisches' Blinkmuster.
Dies bildet der folgende Sketch nach. Dabei wird der in den MobaTools enthaltene Zeitgeber eingesetzt.

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
 

#include <MobaTools.h>
/* Zeitverzögerungen ohne delay-befehl
 * Der 'eggtimer' arbeitet im Prinzip wie ein Kurzzeitwecker in der
 * Küche: Man zieht ihn auf eine bestimmte Zeit auf, und dann läuft 
 * er bis 0 zurück. Im Gegensatz zum Küchenwecker klingelt er aber nicht.
 * Man muss zyklisch nachschauen, ob er abgelaufen ist. Das passt aber
 * perfekt zum prinzip des 'loop', also einer Endlosschleife, in der man
 * zyklisch abfragt.
 * Aufrufe:
 * EggTimer.setTime( long Laufzeit );    setzt die Zeit in ms
 * bool = EggTimer.running();       == true solange die Zeit noch läuft, 
 *                                  == false wenn abgelaufen
 *                                  
 * Im Gegensatz zum Verfahren mit delay() lassen sich damit mehrere
 * unabhängige und asynchrone Taktzeiten realisieren.
 * Hier ein Baustellenzaun mit 4 unabhängigen Blinklampen
*/
#define ANZAHL  4   // Anzahl der Blinker
 
const byte blinkerP[ANZAHL] =  {4,5,6,8};           // Pins für die Led's
const int  blinkOn[ANZAHL]  =  {210,220,230,240};   // Einschaltzeit der Blinklampen (ms)
const int  blinkOff[ANZAHL] =  {410,405,415,400};   // Pausezeit ( in ms)
 
EggTimer Blinkzeit[ANZAHL]; // Die Zeitgeber lassen sich auch wie ein Array definieren
 
byte i;     // Zählvariable
 
void setup() {
    for ( i=0; i<ANZAHL; i++ ) {
        pinMode(blinkerP[i], OUTPUT); 
    }
}
 
void loop() {
    // -------- Verwalten der 4 Blinker in einer Schleife ------------------
    for ( i=0; i<ANZAHL; i++ ){
        if ( Blinkzeit[i].running()== false ) {
            // Blinkzeit abgelaufen, Ausgang toggeln und
            // Zeit neu aufziehen
            if ( digitalRead( blinkerP[i] ) == HIGH ) {
                digitalWrite( blinkerP[i], LOW );
                Blinkzeit[i].setTime( blinkOff[i] );
           } else {
                digitalWrite( blinkerP[i], HIGH );
                Blinkzeit[i].setTime( blinkOn[i] );
            }
        }
    } // Ende for-Schleife
}
 

Der Sketch lässt sich auch ohne großen Aufwand auf mehr Blinker erweitern. Dazu muss nur in der #define Zeile die Anzahl von 4 auf den gewünschten Wert geändert werden, und in den 'const' Zeilen müssen die Listen mit den Pin-Nummern und den Blinkzeiten ergänzt werden.

Wenn etwas unklar ist - einfach nachfragen

Viel Spaß!

[MicroBahner]

Hallo,
es gibt ein kleines Update. Siehe im 1. Post.

[MicroBahner]

Hallo,
nun möchte ich einen schönen Vorteil des Programmierens ohne 'delay' zeigen: man kann ein bisschen 'Multitasking' betreiben. D.h. der Arduino kann mehrere ganz unterschiedliche Aufgaben 'quasi gleichzeitig' erledigen.
Dazu kombinieren wir einfach den Sketch aus dem ersten Thread (die delays da lassen wir einfach weg - die sind nämlich gar nicht notwendig) und den Baustellenblinker. Wir schreiben also im setup und im loop einfach beide Programmteile jeweils hintereinander. Und - voila - unser Arduino macht beides:

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
 

/* 'Multitasking'
 * Kombination des Demo-Sketches für den Servo mit dem Demo-Sketch 'Baustellenblinker'
 * Beide Programme werden in dem Abschnitten 'definitionen', 'setup' und 'loop'
 * einfach hintereinandergesetzt und praktisch unabhängig voneinander ausgeführt.
 *
 * Voraussetzung: kein delays und Warteschleifen im Programm
*/
 
// -----Definitionen für den Blinker -------------------------------------------
#define ANZAHL  4   // Anzahl der Blinker
#include <MobaTools.h>
 

const byte blinkerP[ANZAHL] =  {4,5,6,8};           // Pins für die Led's
const int  blinkOn[ANZAHL]  =  {210,220,230,240};   // Einschaltzeit der Blinklampen (ms)
const int  blinkOff[ANZAHL] =  {410,405,415,400};   // Pausezeit ( in ms)
 
EggTimer Blinkzeit[ANZAHL]; // Die Zeitgeber lassen sich auch wie ein Array definieren
 
byte i;     // Zählvariable
 
// --------- Definitionen für das Servo ------------------------------------------
// 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 byte tasterPin1 = 2;    //Taster1 Pin 2
const byte tasterPin2 = 3;    //Taster2  Pin 3
const byte servoPin =  9;  // Anschluß für den Servo
// bei Werten, die sich im Programm nie verändern, sollte immer 'const' vorangestellt
// werden
 

int tasterStatus1, tasterStatus2;
Servo8 meinServo;
 
void setup() {
    // ------------  setup Blinker -----------------------------------
    for ( i=0; i<ANZAHL; i++ ) {
        pinMode(blinkerP[i], OUTPUT);
    }
   
    // ------------ setup Servo --------------------------------------
    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
 
}
 

 
void loop() {
    // -----------------Programmteil Blinker ------------------------------
    // -------- Verwalten der 4 Blinker in einer Schleife ------------------
    for ( i=0; i<ANZAHL; i++ ){
        if ( Blinkzeit[i].running()== false ) {
            // Blinkzeit abgelaufen, Ausgang toggeln und
            // Zeit neu aufziehen
            if ( digitalRead( blinkerP[i] ) == HIGH ) {
                digitalWrite( blinkerP[i], LOW );
                Blinkzeit[i].setTime( blinkOff[i] );
           } else {
                digitalWrite( blinkerP[i], HIGH );
                Blinkzeit[i].setTime( blinkOn[i] );
            }
        }
    } // Ende for-Schleife Blinker
   
    // -------- Programmteil Servo ------------------------------
    tasterStatus1 = digitalRead(tasterPin1);
    tasterStatus2 = digitalRead(tasterPin2);
 
    if (tasterStatus1 == LOW ) {
        meinServo.write(40); //wird langsam  drehen
    }
 
    if (tasterStatus2 == LOW) {
        meinServo.write(150); //wird langsam drehen
    }
 

}
 

Die Leds blinken schön 'chaotisch' und wenn wir die Taster betätigen läuft auch unser Servo entsprechend hin- und her.

[MicroBahner]

Hallo an alle Arduinointeressierten und Servo-Anwender

Derzeit bin ich dabei die MobaTools so zu erweitern, dass neben Schrittmotoren auch mehr als 2 Servos angesteuert werden können.
Für die Servos werden die Impulse dann softwaregesteuert erzeugt, und können auch an beliebigen Pins ausgegeben werden ( wie bei der Standard Servo-Library ). Nun habe ich da 2 Varianten zur Auswahl:

1) Die Impulse werden ähnlich erzeugt wie bei der Arduino Lib. Ich komme dann - je nachdem welche Grenzwerte man für die Impulslängen zulässt - auf 11 oder 12 Servos. Allerdings bedeutet das, dass die Impulse nicht immer exakt im 20ms-Raster ausgegeben werden, sondern sich bei Änderungen gegenseitig beeinflussen. Wenn sich mehrere Impulslängen gleichzeitig ändern, kann es dazu kommen, dass sich der ausgegebene Impuls im Raster schonmal heftig hin- und herbewegt. Z.B. dass er sich einmal schon nach < 10ms wiederholt oder auch erst nach >30ms. Sind Extremwerte, können aber auftreten (Die Arduino Lib hat das gleiche 'Problem' ).

2) Ich erzeuge die Impulse so, dass sie immer exakt im festen Raster von 20ms ausgegeben werden. Dann kann ich aber nur 8 Servos parallel ansteuern.

Was meint ihr?
Gute Servos sollten sich von den springenden Wiederholraten zwar nicht beeinflussen lassen. Bei einfachen Analogservos wäre ich mir aber da nicht so sicher. Ich würde daher zur Lösung mit dem exakten 20ms-Raster tendieren. 8 Servos sind doch auch schon ganz ordentlich und dürften bei den meisten Anwendungen ausreichen oder?

P.S. Einen Modus mit automatischem Abschalten der Impulse nach Erreichen der Zielposition ist enthalten, so dass da die Servos auf jeden Fall ruhig stehen sollten.

[MicroBahner]

Hallo,
auch wenn das Interesse an den MobaTools ja sehr überschaubar ist mach ich jetzt einfach mal weiter. Man soll ja keine halben Sachen machen und sein Ding durchziehen .
Heute gibt es ein größeres Update für die MobaTools und wieder ein kleines Demoprogramm. Die wesentlichen Erweiterungen sind:

• 16 Servos
  Die Impulse werden jetzt per Software erzeugt und es sind maximal 16 Servos möglich. Die Pinzuordnung ist beliebig, es kann jeder digitale Ausgang verwendet werden. Die Klasse heißt jetzt Servo8 statt Servo2 ( und fragt nicht, warum sie nicht Servo16 heißt...)
• AutoOff der Servoimpulse
  Die Servoimpulse können bei Erreichen der jeweiligen Endlage automatisch abgeschaltet werden. Damit steht der Servo in der Endlage absolut ruhig ( solange seine Selbsthemmumg ausreicht ). Dazu muss im attachbefehl ein zusätzlicher Parameter übergeben werden:
  1
   

  Servo8.attach( byte pin, bool autoOff )
   

  Wird der Zusatzparameter weggelassen, werden die Impulse wie bisher nicht abgeschaltet.

• 4 Schrittmotore
  Es können bis zu 4 unipolare Schrittmotore angesteuert werden. Getestet ist es mit diesem Schrittmotor, der mir für unsere Zwecke recht geeignet erscheint( Danke an Uli - Garti62 für den Hinweis). Die 4 Steuerignale können an beliebigen Pins oder über die SPI-Schnittstelle seriell ausgegeben werden. Im Gegensatz zur Stepper Library des Arduino ist diese Ansteuerung nicht blockierend. D.h. während sich der Schrittmotor bewegt, läuft der Sketch im loop weiter (wie bei den Servos ). Servos und Schrittmotore können parallel betrieben werden.
  Ist ein Referenzpunkt definiert ( mit 'setZero'), so kann der Schrittmotor ähnlich wie die Servos auch absolut positioniert werden, natürlich ohne die Winkelbegrenzung des Servos. Beim Schrittmotor kann man dann z.B. auch 3600° vorgeben - also 10 Umdrehungen vom Referenzpunkt entfernt( Siehe Beispiel und Beschreibung in der Lib )

Da die Änderungen und Erweiterungen doch recht umfangreich sind, habe ich einen kleinen Versionssprung zur V0.5 gemacht. Das Zip-File (aktualisiert im 1. Beitrag) enthält auch eine Beschreibung und ein Beispiel zu der Schrittmotoransteuerung.


Damit man sieht, dass die MobaTools nicht nur für Bewegung neben den Gleisen sorgen können, hier mal eine Demo eines einfachst DCC-Servodecoders zur Weichenansteuerung. Der Decoder kann 8 Servos über frei wählbare Weichenadressen stellen. Programmierbar ist dieser Einfachstdecoder natürlich nicht, alles muss über Konstante im Programm eingestellt werden. Dafür ist die Zahl der Programmzeilen auch recht überschaubar:

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
 

#include <NmraDcc.h>
#include <MobaTools.h>
 
// Demo: ein ganz einfacher Dcc-Servodecoder //
//------------------------------------------ //
// die NmraDcc - Library gibt es unter https://github.com/mrrwa/NmraDcc/archive/master.zip
 
// anzupassende Konstante:
const byte isROCO = 4  ;    // wegen unterschiedlicher Weichenadressberechnung bei Roco (sonst = 0)
const byte weichenAdr[] =   {   6,   7,   3, 123,   8,  34,  77,  88};  // DCC-Weichenadressen 
const byte servoPins[]  =   {   3,   4,   5,   6,   7,   8,   9,  10};  // output-pin der Servos
const int geradePulse[] =   {1200,1200,1200,1200,1200,1200,1200,1200};  // Pulslänge geradeaus
const int abzweigPulse[]=   {1800,1800,1800,1800,1800,1800,1800,1800};  // Pulslänge abzweigend
 
const int speed = 8;
const byte autoOff = 1;
const byte ServoZahl = sizeof(weichenAdr);
Servo8 weicheS[ServoZahl];
NmraDcc Dcc;
///////////////////////////////////////////////////////////////
void setup() {
    Dcc.init( MAN_ID_DIY, 15, FLAGS_OUTPUT_ADDRESS_MODE | FLAGS_DCC_ACCESSORY_DECODER, 0 );
    Dcc.pin(0, 2, 1); // Dcc-Signal an Pin2 ( = Int0 );
 
    for ( byte i=0; i<ServoZahl; i++ ) {
        // Weichenservos initiieren
        weicheS[i].attach( servoPins[i], autoOff );
        weicheS[i].setSpeed( speed );
    }
}
////////////////////////////////////////////////////////////////
void loop() {
    Dcc.process(); // Hier werden die empfangenen Telegramme analysiert
    
}
//////////////////////////////////////////////////////////////
// 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+isROCO; // Roco zählt ab 0, alle anderen lassen die ersten 4 Weichenadressen frei
    // Testen ob eigene Weichenadresse
    for ( byte i = 0; i < ServoZahl; i++ ) {
        if (  wAddr == weichenAdr[i] ) {
            // ist eigene Adresse, Servo ansteuern
            if ( OutputAddr & 0x1 ) {
                weicheS[i].write( geradePulse[i] );
            } else {
                weicheS[i].write( abzweigPulse[i] );
            }
            break; // Schleifendurchlauf abbrechen, es kann nur eine Weiche sein
        }
    }
}
 

 

Dazu braucht man natürlich auch noch die DCC Library, die ihr hier herunterladen könnt und die Schaltung, um das DCC-Signal an den Arduino zu bringen:

Die Adressierung ist etwas ungewöhnlich, denn da die Decoderadresse nicht über CV programmiert wird, können wir die Weichenadressen direkt angeben und sind nicht auf 4er Gruppen festgelegt. Das Ganze könnte durch Erweitern der Listen auch ohne weiteres auf bis zu 16 Servos ausgebaut werden. Allerdings muss man daran denken, dass man auch entsprechend viele Pins benötigt. Besonders, wenn man den Decoder noch um Relaisanschlüsse für die Herzstückpolarisation erweitert.
Getestet habe ich eingefleischter Analogi das mit einer Roco Multimaus, die bei mir noch aus einer Startpackung in der Schublade schlummerte . Ich wollte halt auch mal was für unsere Digitalfreunde bieten .
Grundsätzlich ist der Decoder auch so funktionsfähig, aber zumindest eine Möglichkeit die Endlagen zu justieren wäre schon noch sinnvoll. Aber ausbauen kann man ja immer noch . Auch eine Variante mit Schaltern statt DCC-Ansteuerung für die 'Analogis' wäre natürlich denkbar.

Sollte jemand die MobaTools ausprobieren und Fehler finden, darf er die gerne hier posten

[digi_thomas2003]

Hallo Franz-Peter,

danke für das DCC-Decoder Projekt!
Daran sitze ich auch hin und wieder, allerdings mit der Mynabay-Library. Leider haben sie ihre Homepage komplett umgestellt und die Bauanleitung rausgenommen, aber es gibt ja noch andere Quellen (z.B. Ruud).

Zu Deinem Aufbau habe ich noch eine Frage:
Warum hast Du bei der Schaltung den Kondensator C1 drin? Und mit welcher Kapazität?

Herzliche Grüße
Thomas

[MicroBahner]

Hallo Thomas,

Zitat von digi_thomas2003

---

danke für das DCC-Decoder Projekt!

---

naja, bisher ist es nur eine kleine Demo . Aber bei Interesse könnte man ja ein kleines Projekt draus machen :

Die MynaBay-Library habe ich mir auch angeschaut. Ich persönlich halte die NmraDCC Lib aber für die bessere Implementierung. Dort findet die gesamte Bitverarbeitung im Interrupt statt bis ein komplettes Telegramm empfangen ist. Sie ist meiner Meinung nach recht effizient und braucht nur rel. wenig CPU-Zeit dafür ( man könnte aber trotzdem noch ca 30% Bearbeitungszeit / Bit rauskitzeln . Aber an der Lib wollte ich erstmal nichts ändern - es geht ja auch so). Der Aufruf im loop muss nur noch die fertigen Pakete interpretieren. Bei der MynaBay Lib muss der Aufruf im loop sich auch noch um Bitinterpretationen kümmern, was wesentlich zeitkritischer ist.
Ausserdem bekommst Du bei NmraDCC die Daten im Sketch 'vorverarbeitet': z.B. sind die Adressen schon richtig aus den einzelnen Bitbereichen zusammengesetzt, was man bei Mynabay - so wie ich das gesehen habe - noch selbst machen muss.
Deshalb funktioniert der 'Einfachst-Decoder' mit der NmraDCC Lib ja auch mit so wenig Zeilen Code .
Auch um die dauerhafte Speicherung der CV-Werte kümmert sich der NmraDCC schon wahlweise. Dann okkupiert er aber das ganze EEPROM. Man kann sich aber auch selbst drum kümmern - je nach Wunsch
Einziger Nachteil ist, dass die Lib den Timer0 mitbenutzt und dadurch die vom Timer0 abhängigen PWM(analog)-Ausgänge nicht mehr nutzbar sind.

Der Kondensator hat 3,9nF und ist ein bisschen ein 'Angstkondensator': er soll hochfrequente Störungen fernhalten. Ob er in der Praxis was bringt ... stören tut er jedenfalls nicht.

[digi_thomas2003]

Hallo Franz-Peter,

danke für Deine Ausführungen!
Damit lieferst Du mir unbeabsichtigt einige Antworten auf Fragen, die ich mir bei der Beschäftigung mit der Mynabay-Lib gestellt habe.
Nun werde ich mich bei meinen weiteren DCC-Projekten auf die NRMA-Lib konzentrieren.

Danke auch Deine Auführungen zum Kondensator!

Herzliche Grüße
Thomas

[TRAXXer]

Hallo Franz-Peter,

danke, dass du mir das Hirnen abnimmst ich habe schon alles bereit liegen, um bald das ein oder andere auf meiner kleinen Spur N-Anlage zu bewegen. Arduino, Servo und Schrittmotoren meine ich. Da werde ich mich dann an deine Sketches erinnern!

Schöne Grüße,
Niklas

[Bodo]

Hallo,

vielen Dank für´s Weitermachen und für die DCC-Demo ... das hatte ich bisher auch immer vor mir hergeschoben - aber nun habe ich das Beispiel einfach mal nachgebaut und es hat auf Anhieb funktioniert. Vielleicht finde ich nun auch Zeit und Motivation, mal verschiedene Servos mit verschiedenen Geschwindigkeiten zu testen und das ganze mit meiner Schieberegister-Beleuchtung zu kombinieren.

Viele Grüße, Bodo

[Mape71]

Hallo Franz-Peter,

mit viel Begeisterung schaue ich mir die Inhalte Deiner MobaTools Bibliothek an und probiere auf einem Breadboard fleißig aus. Zusammengefasst - ich glaube ich kann alle Anwendungen an verschiedenen Stellen meiner Anlage gut gebrauchen. Da ich auf meiner Anlage alles digital steuere besteht meine Herausforderung aktuell die NMRADCC Bibliothek soweit zu verstehen, als dass ich einem "Arduino Decoder" eine Adresse - oder besser noch einen Adressbereich, wie z.B. in Deinem DCC Servo Sketch, zu geben, worauf dann eine bestimmte Funktion ausgeführt wird. Dabei ist mein Anspruch weniger auf dem Arduino möglichst viele komplexe Funktionen laufen zu lassen, sondern eher den Arduino als digitalen Schalter zu nutzen, der im einfachsten Fall eine LED schaltet (Hausbeleuchtung), oder aber einen kleinen auf einem Attiny 45 ausgelagerten Sketch startet. Der Attiny ist mit Kosten von 1 Euro aus meiner Sicht eine gute Möglichkeit Funktionen zu dezentralisieren (z.B. ein Schweißlicht mit drei verschieden flackernden LEDs oder einen einfachen Stepper Motor) und so die für einen Einsteiger doch schon hohe Komplexität etwas zu reduzieren. Ist es Dir möglich Deinen Post noch einmal in Bezug auf diese Fragestellung etwas aufzubohren?

Vielen Dank vorab und Grüße

Marko

[Mape71]

...hm, beim noch mal durchlesen meines Posts bin ich mir nicht sicher, ob meine Frage überhaupt verstanden werden kann. Also noch einmal zur Ergänzung:
Der Sketch zum DCC Servodecoder läuft bei mir prima. Durch einfaches verändern der Konstanten gelingt es mir sehr schön Servos so zu steuern, dass ich z.B. über meine ECOS ein zweiflügeliges Formsignal steuern kann. Hier werde ich mir jetzt noch eine Servoaufnahme konstruieren, die auch einen Arduino Nano und die Elektronik für den Optokoppler für das DCC Signal aufnehmen kann, und diese dann mit dem 3D Drucker ausdrucken. Schon habe ich für jedes Signal einen Decoder inkl. Servos. Dafür schon einmal herzlichen Dank

So, nun zur Fragestellung. Ich habe versucht den DCC Servo Sketch so abzuändern, dass ich ebenso wie die beiden oben beschriebenen Servos die Ausgänge des Arduinos mit einem einfachen High und Low Pegel versehen kann - also um z.B. eine LED zum leuchten zu bringen und sie wieder auszuschalten (ohne Schnickschnack, einfach nur über DCC an und aus). Damit könnte ich dann wie schon erwähnt die kleinen Attiny Chips ansteuern. Bekomme ich mit meinem noch eher oberflächlichen Wissen aber nicht hin und auch obwohl ich gerade in meinem Buch "Die elektronische Welt mit Arduino entdecken" lese wie verrückt - ich sehe aktuell noch kein Land. Wenn ich hier eine Hilfestellung bekommen könnte wäre ich sehr dankbar (dann kann ich meine Maschinenfabrik in Betrieb nehmen, wo mehrere Schweisslichter, ein flackerndes Feuer und ein mit Steppermotor angetriebenes Förderband zum Laufen gebracht werden müssen. )

Wenn die Maschinenfabrik läuft ist das nächste Projekt ein Bahnübergang. Die Servos sind schon montiert und werden über einen Joka-Servodecoder angesprochen, allerdingsfehlt noch die Ansteuerung des Wechselblinkers und ggf. ein Soundmodul. So wie ich das sehe bietet der Arduino DCC Servodecoder Sketch eine gute Grundlage auch für diese Fragestellung - ich persönlich glaube dass hier extrem viel Potenzial besteht.

Danke vorab für Unterstützung

Grüße

Marko

[MicroBahner]

Hallo,
es wird Zeit, mal ein paar Posts zu beantworten

@Thomas:

Zitat von digi_thomas2003

---

Damit lieferst Du mir unbeabsichtigt einige Antworten auf Fragen, die ich mir bei der Beschäftigung mit der Mynabay-Lib gestellt habe.

---

Hab' ich dich also von der NmraDcc-Lib überzeugt? Was waren denn die Fragen, die Du dir gestellt hast? Wenn Du noch Fragen zur NmraDcc-Lib hast, kannst Du dich gern melden. Ich möchte nicht behaupten, dass ich sie in allen Details analysiert habe, aber ich glaube sie inzwischen schon recht gut zu verstehen. Die Doku ist ja nicht sooo berauschend .

@Niklas:

Zitat von TRAXXer

---

danke, dass du mir das Hirnen abnimmst

---

na ja, so ganz ohne wird's trotzdem nicht gehen . Aber es würde mich natürlich freuen, wenn Du die MobaTools nutzen kannst, und sie dir das 'Hirnen' etwas erleichtern

@Bodo:

Zitat von Bodo

---

aber nun habe ich das Beispiel einfach mal nachgebaut und es hat auf Anhieb funktioniert.

---

So hatte ich mir das gedacht . Freut mich zu hören, dass es auch tatsächlich so funktioniert - das ist bei Software ja nicht immer so selbstverständlich .
Ausbaufähig ist die Demo auf jeden Fall - ist ja nur ein absoluter minimal-Sketch.

@Marko:

Zitat von Mape71

---

und probiere auf einem Breadboard fleißig aus

---

So soll es sein, freut mich dass Du die MobaTools ausprobierst.
Dein 2. Post war in der Tat hilfreich
Dass Du die Demo schon richtig einsetzt finde ich toll - obwohl es ja doch recht umständlich ist, die Endlagen der Servos im den Konstantentabellen zu pflegen. Aber ein Arduino Nano pro Signal - ist das nicht etwas 'überdimensioniert'? Die Demo kann ja schon 8 Servos ansteuern, und das würde für 4 zweiflügelige Signale reichen. Meist stehen doch auch ein paar Signale recht nah beieinander, sodass auch die Leitungen zu den Servos kein Problem sein sollten. Oder hast Du noch andere Gründe dafür?

Zu den AtTiny habe ich inzwischen - zumindest in der Arduino-Umgebung - eine andere Meinung. Einen Arduino Mini gibt es bei ebay im 5erPack schon für 3€ / Stück - und da hat man nicht nur den nackten Chip, sondern schon ein kleines lauffähiges System, dass eben auch direkt über die IDE programmiert werden kann. Und der Mini ersetzt locker 3 tinys. Sooo schwierig ist es doch auch nicht, dass er mehrere unterschiedliche Aufgaben erledigt. In meinem Post zum 'Multitasking' habe ich das schon mal gezeigt.
Aber letztendlich muss das natürlich jeder selbst entscheiden.
Da die MobaTools auf dem AtTiny nicht laufen, werde ich sie hier auf jeden Fall nicht berücksichtigen.

Zu deiner konkreten Frage: Um dem Demo-Sketch auch reine Ein/Aus OUTPUTs beizubringen geht man am einfachsten so vor:

In den Listen mit den Konstanten kennzeichnet man die Ausgänge, die keine Servopulse erzeugen, sondern nur die Ausgänge schalten sollen. Ich habe das mal so gemacht, dass ich bei diesen Ausgängen, die Pulslänge auf -1 gestellt habe. Der Wert kann bei Servos nicht vorkommen:

1
2
 

const int geradePulse[] =   {1200,  -1,1200,  -1,1200,1200,1200,1200};  // Pulslänge geradeaus
 
 

Beim Initiieren der Servos wird dieser Wert abgefragt, und wenn negativ nur der Pin auf OUTPUT geschaltet, aber kein Servo initiiert:

1
2
3
4
5
6
7
8
9
10
11
12
13
 

    for ( byte i=0; i<ServoZahl; i++ ) {
        // Weichenservos initiieren
        if ( geradePulse[i] >= 0 ) {
            // ServoAusgang:
            weicheS[i].attach( servoPins[i], autoOff );
            weicheS[i].setSpeed( speed );
        } else {
            // nur Digital Output
            pinMode( servoPins[i],OUTPUT );
            digitalWrite( servoPins[i],LOW );
        }
    }
 
 

Die gleiche Abfrage wird auch da gemacht, wo die Servos angesteuert werden. Bei negativen Werten wird eben kein Servo angesteuert, sondern nur der Ausgang geschaltet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 

    for ( byte i = 0; i < ServoZahl; i++ ) {
        if (  wAddr == weichenAdr[i] ) {
            // ist eigene Adresse,
            if ( geradePulse[i] >= 0 ) {
                //Servo ansteuern
                if ( OutputAddr & 0x1 ) {
                    weicheS[i].write( geradePulse[i] );
                } else {
                    weicheS[i].write( abzweigPulse[i] );
                }
                
            } else {
                //Digital-Ausgang
                digitalWrite( servoPins[i], OutputAddr & 0x1 );
            }
            break; // Schleifendurchlauf abbrechen, es kann nur eine Weiche sein
        }
    }
 

 

Damit kann man dann frei bestimmen, ob an einem Pin Servopulse erzeugt werden, oder ob der pin nur einfach auf HIGH bzw LOW geschaltet wird.

Zum Bahnübergang: hast Du schon mal hier geschaut? Da habe ich einen kompletten Sketch für einen Servo-betriebenen Bue mit Wechselblinker und Sound-Ansteuerung vorgestellt. Dort wird das Schliessen zwar über einen einfachen Schalter ausgelöst, sollte sich aber auch auf DCC-Ansteuerung umstellen lassen.

Wenn Du noch Fragen hast - nur her damit

[Bodo]

Hallo,

Zitat von MicroBahner

---

@Bodo:

Zitat von Bodo

---

aber nun habe ich das Beispiel einfach mal nachgebaut und es hat auf Anhieb funktioniert.

---

So hatte ich mir das gedacht . Freut mich zu hören, dass es auch tatsächlich so funktioniert - das ist bei Software ja nicht immer so selbstverständlich .
Ausbaufähig ist die Demo auf jeden Fall - ist ja nur ein absoluter minimal-Sketch.

---

der Beispiel-Sketch für den Schrittmotor ist auch getestet - sowohl über Arduino-Ports als auch über SPI>Schieberegister. Hier fehlte mir in der Doku eine Zuordnung der Schrittmotor-PINs - aber einfach mal intuitiv anschließen wie es auskommt, scheint zu funktionieren .
Ob es sich jetzt noch lohnt, an meinem eigenen Funktionsaufruf weiterzubasteln, glaube ich fast nicht - einziger Vorteil wäre, dass es dann vielleicht auch mit dem ATtiny85 funktioniert. Aber so groß ist die Kostenersparnis bei kleinen Stückzahlen halt wirklich nicht ...
Jetzt fehlt nur noch eine passende mechanische Anwendung, an der ich mich entsprechend austoben kann - das wird dann wieder eher länger dauern, aber ich bleibe dran .

Viele Grüße, Bodo

[Mape71]

Hallo Franz-Peter,

vielen Dank für die schnelle Antwort. Mit Deinen Änderungen funktioniert nun auch das Schalten der Digitalausgänge und zusätzlich dazu noch die Servosteuerung - perfekt und noch einmal 1000 Dank!

Zu Deinen anderen Anregungen bezüglich Attiny und ein Arduino für mehrere Formsignale: Ich gebe Dir recht, alles auf dem Arduino ist sicher der eleganteste Weg. Dass ich dennoch vorerst bei meinem Plan bleibe hat letzendlich nur einen wesentlichen Hintergrund. Ich habe einfach Angst, da ich mich nicht täglich mit dem Thema beschäftige, dass ich nach einer längeren Ruhepause, vor allem im Falle eines Fehlers, nicht mehr so recht in das Thema reinfinde.
Wenn ich einen Arduino pro Signal nehme, dann habe ich pro Signal ein separates System, welches ich im Fehlerfall oder bei einer punktuellen Veränderung noch halbwegs überschauen kann (Stand heute schaffe ich es ja nicht einmal alle Details in Deinem Sketch zu verstehen). Die Verkabelung ist auch denkbar einfach - Stromversorgung und Digitalsignal zu jedem Formsignal. Wenn ich also jetzt viele Funktionen auf einen Arduino bringe und dann auch jeder Arduino etwas anders ist, so ist das einfach deutlich komplexer. Und aus genau dem selben Hintergrund auch die Attinys. Es ist für mich dann einfach überschaubarer. Ich habe z.B. einen sehr schönen Sketch für ein Schweisslicht gefunden und auf meine Bedürfnisse parametrisiert. Der Sketch, den ich am Ende mal beigefügt habe, arbeitet mit Delays, deren Wert über einen Zufallsgenerator innerhalb definierter Grenzbereiche gebildet wird. Wie Du ja auch in einem anderen Post schreibst kann man das auch sicher so programmieren, dass der Prozessor nicht beim Abarbeiten der Delays für andere Aufgaben blockiert ist - nur das vermag ich aktuell nicht umzusetzen. So schiebe ich diesen Sketch einfach auf den Attiny und schalte ihn mit einem Digitalausgang des Arduinos ein und wieder aus. So läuft der Schweisslicht Sketch auch komplett autark, ohne dass er den Arduino beeinflusst.
Wenn ich mich aufgrund vieler Anwendungsideen für den Arduino auch abseits der Modellbahn irgendwann einmal so mit dem Thema auskenne, dass ich das Thema gut beherrsche, sehe ich das dann evtl. auch wieder anders.
Ich finde es schon sehr beeindruckend, wenn jemand so viel Energie in das Posting seiner Ideen steckt, wie Du es hier machst. Da freue ich mich natürlich um so mehr, wenn Du dann auch noch auf individuelle Fragestellungen eingehst und noch mehr Unterstützung leistest - aber ich mag den Bogen da auch nicht überspannen und behelfe mir dann wo es geht selbst, auch wenn es dann evtl. nicht der eleganteste Weg ist. Aber die Platte der Moba ist ja groß und vieles liegt darunter im Verborgenen

Auch den Post mit den Schranken, auf den Du verwiesen hast, habe ich mir angeschaut. Ich bin mehr als nur beeindruckt und werde diese Ideen auch übernehmen - evtl. dann aber auch wieder mit separaten DCC-Arduino, der dann den Schranken Arduino die Befehle zum Öffnen und Schließen gibt (es sei denn Du führst den Schranken-Post doch noch weiter und baust vor die Logik für die Schranken noch den DCC Decoder Part in den Sketch mit ein .

Ich werde das Thema hier sehr eng weiter verfolgen und bin schon sehr gespannt, was da noch alles entsteht. Wenn mein Servohalter für das 2-flügelige Formsignal fertig ist werde ich ebenfalls die Daten für den 3D Druck zur Verfügung stellen und das mit Deinem Servo-Sketch kombinieren - hilft dann hoffentlich auch der/dem ein oder anderen Kollegin/Kollegen weiter.

Viele Grüße

Marko

Sketch Schweisslicht mit 3 LEDs (eine weiße und eine blaue LED flackern, eine rote LED wird während des Flackervorgangs heller und mit Ende des Flackerns langsam wieder gedimmt und simuliert somit das Glühen des geschweissten Objektes)

// Definition Ausgabe Pins
int ledWeld0Pin = 0; // Ausgang weiße LED
int ledWeld1Pin = 1; // Ausgang blaue LED
int ledGlow0Pin = 4; // Ausgang rote LED

// Definition des Ausgabewertes für das Schweisslicht
byte flicker = 0;
byte ledflickermin = 25;
byte ledflickermax = 255;

// Definition der Flackerzeit
byte leddelay = 0;
byte leddelaymin = 15;
byte leddelaymax = 125;

// Definition wie viele Flacker vor Pause
long flickertimes = 0;
long flickertimesmin = 100;
long flickertimesmax = 255;

// Definition Länge der Pause (in Millisekunden)
long pause = 0;
long pausemin = 1000;
long pausemax = 3000;

// Definition Startwert Glühen und Delay
byte glow = 1;
byte glowdelay = 15;

void setup()
{
pinMode(ledWeld0Pin, OUTPUT);
pinMode(ledWeld1Pin, OUTPUT);
pinMode(ledGlow0Pin, OUTPUT);
}

void loop()

{
flickertimes = random(flickertimesmin, flickertimesmax); // Wählt ein zufallswert für die Anzahl der Flacker
while(flickertimes > 0) // So lange die Anzahl der Flacker mehr als 0 ist Wiederholung bis zum Ende des While Schleife
{
flicker = random(ledflickermin, ledflickermax); // Wählt zufälligen Flackerwert
analogWrite(ledWeld0Pin, flicker); // Ausgabe Flackerwert weiße LED
analogWrite(ledWeld1Pin, flicker); // Ausgabe Flackerwert blaue LED


glow++; // Zum Glühlevel 1 hinzu addieren
analogWrite(ledGlow0Pin, glow); // Ausgabe Glühwert rote LED

leddelay = random(leddelaymin, leddelaymax); // wählt zufälliges Delay
delay(leddelay); // Warten
flickertimes--; // Reduziert Flackerzeit um den Wert 1
} // Ende der ersten "While" Schleife

analogWrite(ledWeld0Pin, 0); // Schaltet die weiße LED aus
analogWrite(ledWeld1Pin, 0); // Schaltet die blaue LED aus

while(glow > 0) // so lang der Glühwert größer als 0 ist wiederholen bis zum Ende der "while" Schleife
{
analogWrite(ledGlow0Pin, glow); // Ausgang Glühwert rote LED
delay(glowdelay); // Warte
glow--; // Reduziert Glühwert um 1
} // Ende der zweiten "While" Schleife


pause = random(pausemin, pausemax); // Selektiert zufälliges Delay für Pause zwischen den Schweissvorgängen
delay (pause); // Wartet

}

[MicroBahner]

Hallo an alle,
es gibt ein Update für die MobaTools

Hallo Marko,
ich habs ja wieder mal nicht lassen können, und aus dem Schweißlichtsketch die delays 'rausooperiert' . So könnte das Schweißlicht jetzt auch in einen anderen Sketch (z.B. den DCC Decoder ) integriert werden. Ich find's übrigens noch besser, wenn die Led(s) für den Lichtbogen digital und nicht analog angesteuert werden. Der ist ja auch eigentlich immer gleich hell, nur unterschiedlich lang an.

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
 

#include <MobaTools.h>
 
// Definition Ausgabe Pins
int ledWeld0Pin = 4; // Ausgang weiße LED
int ledWeld1Pin = 6; // Ausgang blaue LED
int ledGlow0Pin = 5; // Ausgang rote LED
 
// Definition des Ausgabewertes für das Schweisslicht
byte flicker = 0;
byte ledflickermin = 25;
byte ledflickermax = 255;
 
// Definition der Flackerzeit
byte leddelaymin = 15;
byte leddelaymax = 125;
 
// Definition wie viele Flacker vor Pause
int flickertimes;
int flickertimesmin = 100;
int flickertimesmax = 255;
 
// Definition Länge der Pause (in Millisekunden)
int pausemin = 1000;
int pausemax = 3000;
 
// Definition Startwert Glühen und Delay
byte glow = 0;
byte glowdelay = 15;
 
EggTimer wait;
void setup()
{
    pinMode(ledWeld0Pin, OUTPUT);
    pinMode(ledWeld1Pin, OUTPUT);
    pinMode(ledGlow0Pin, OUTPUT);
}
 
void loop() {
    bool isNext = (wait.running() == 0);
    // während der Timer läuft, wird keiner der folgenden if / else if Blöcke ausgeführt:
    if (flickertimes > 0 && isNext) 
    { // So lange die Anzahl der Flacker mehr als 0 ist weisse und blaue Led ansteuern
        flicker = random(ledflickermin, ledflickermax); // Wählt zufälligen Flackerwert
        analogWrite(ledWeld0Pin, flicker); // Ausgabe Flackerwert weiße LED
        analogWrite(ledWeld1Pin, flicker); // Ausgabe Flackerwert blaue LED
        
        glow++; // Zum Glühlevel 1 hinzu addieren
        analogWrite(ledGlow0Pin, glow); // Ausgabe Glühwert rote LED
        
        wait.setTime(random(leddelaymin, leddelaymax)); // wählt zufälliges Delay
        if ( --flickertimes == 0 ) {
            // Reduziert Flackerzahl um den Wert 1, wenn 0, Leds abschalten
            analogWrite(ledWeld0Pin, 0); // Schaltet die weiße LED aus
            analogWrite(ledWeld1Pin, 0); // Schaltet die blaue LED aus
        }
    } else if ( glow > 0 && isNext ) { // Glüh-Led langsam ausgehen lassen
        analogWrite(ledGlow0Pin, glow); // Ausgang Glühwert rote LED
        wait.setTime(glowdelay); // Warte
        if ( -- glow == 0 ) {
            // Reduziert Glühwert um 1, wenn 0 Pause starten
            wait.setTime( random(pausemin, pausemax) ); // Selektiert zufälliges Delay für Pause zwischen den Schweissvorgängen
        }
    } else if ( glow == 0 && isNext ) {
        // Pause zwischen den Flackerern zu Ende
           flickertimes = random(flickertimesmin, flickertimesmax); // Wählt ein zufallswert für die Anzahl der Flacker
    }
 
}
 
 

[UweS]

Hallo Franz-Peter,

Schweißlichtsketch, : war doch bisher als Beispiel nicht dabei, oder habe ich was übersehen?

[MicroBahner]

Hallo Uwe,
nein, Du hast nichts übersehen. Den Schweißlichtsketch hatte Marko in seinem letzten Post oben eingestellt, der ist nicht bei den Beispielen dabei.
Nur war der noch mit 'delay' Befehlen realisiert und deshalb konnte man den so nicht mit was anderem kombinieren. Ich habe das jetzt nur auf den 'EggTimer' der MobaTools umgestellt.

@Marko: wenn Du den SourceCode zwischen 'Code'-Tags setzt, wird er schöner dargestellt und ist besser zu erkennen.

[Mape71]

Hallo Franz-Peter,

Das ist ja klasse - ich sitze morgen 13 Stunden im Flugzeug, da werde ich mich da mal durchwühlen (nur Aufbauen werde ich es da nicht, die Anderen gucken dann immer so komisch

Danke und Grüße

Marko