Hallo, zusammen,

angeregt durch "Herbert's belebtes Haus" habe ich meine ersten Gehversuche mit Arduino und ATtiny gestartet. Bei der Gelegenheit ein großes Dankeschön an all diejenigen, die einem Laien wie mir mit ihren Kommentaren und Sketches den Einstieg in die sehr interessante Thematik möglich machen.

Ich möchte u.a. künftig meine Weichen mittels Servos steuern und habe mir in dem Zusammenhang das nachstehende Programm unter Zuhilfenahme von Sketches aus dem Stummi-Forum u.a. zusammengeschrieben, wobei meine Einfügungen minimal sind (um mich nicht mit fremden Federn zu schmücken):

#include <WProgram.h>

int myservo;

int KippschalterPin = 0;
int Servo_Pin = 2;

int Stellung1 = 28;//ServoStellung 1 (Einstellbar zwischen 0° bis max. 180°)
int Stellung2 = 0;//ServoStellung 2 (Einstellbar zwischen 0° bis 180°)
int Stellung_bisher;//Für Vergleich
const int Warten = 19;//19 MilliSekunden Warten nach Stellschritt. Nicht verändern!
void Servo_move(int servo,int Stellung_neu);

void setup()
{
pinMode(KippschalterPin, INPUT);
digitalWrite(KippschalterPin, HIGH);
pinMode(Servo_Pin, OUTPUT);

Stellung_bisher=Stellung1;//Ruhestellung
}

void loop()
{
if(digitalRead(KippschalterPin)==HIGH)
Servo_move(Servo_Pin, Stellung1);
if(digitalRead(KippschalterPin)==LOW)
Servo_move(Servo_Pin, Stellung2);
delay(20);
}

void Servo_move(int servo,int Stellung_neu){
int Schritt;
if(Stellung_neu==Stellung_bisher)return;
Schritt=(Stellung_neu>Stellung_bisher)?1:-1;
while(Stellung_bisher!=Stellung_neu){
Stellung_bisher+=Schritt;

digitalWrite(servo, HIGH);
delayMicroseconds((Stellung_bisher*8)+500);
digitalWrite(servo, LOW);
delay(Warten);
}
}
Kurze Anmerkung: "KippschalterPin = 0" und "Servo_Pin = 2" ist schon für den ATttiny eingestellt

Ergänzende Bemerkung:
Nach diversen Versuchen war der o.g. Sketch bisher der einzige, den ich sowohl auf dem Arduino als auch auf dem ATttiny erfolgreich speichern konnte.
Das o.g. Programm selbst läuft einwandfrei. Die Servos werden problemlos geschaltet.
Es gibt im Betrieb keinerlei Zuckungen bei den Servos, weder in Ruhestellung, noch bei der Bewegung.

Nun zu meinem Problem:
Einzig beim Einschalten der Stromversorgung schalten die Servos jeweils um, und zwar - soweit ich das beobachten kann - in die
"Stellung 1" bzw. "Stellung_bisher", egal, in welcher Stellung die Servos beim Ausschalten der Stromversorgung gestanden haben.

Ich habe schon versucht, den Sketch abzuändern, jedoch aufgrund meiner beschränkten Kenntnisse ohne Erfolg.

Meine Frage bzw. Bitte:
Kann man den Sketch so modifizieren, dass die Servos beim Einschalten der Stromversorgung stillhalten?

Im Voraus ein kräftiges Dankeschön für Eure Hilfe.

Einen schönen Abend wünscht
Bierrudl

Dein Programm startet ja jedes Mal neu, wenn du die Stromversorgung einschaltest. Dann wird Stellung_bisher auf den Wert 1 zurückgesetzt, also fährt auch der Servo die entsprechende Position an.

Du solltest in setup() die Zeile

Zitat

---

Stellung_bisher=Stellung1;

---

ersetzen durch

Zitat

---

if (HIGH == digitalRead(KippschalterPin)){
Stellung_bisher = Stellung1;
} else {
Stellung_bisher = Stellung2;
}

---

Damit fährt dein Servo beim Einschalten stets die vom Kippschalter vorgegebene Stellung an.

Theoretisch könntest du auch jeden Stellbefehl im EEPROM - das ist der Speicher, dessen Inhalt auch im stromlosen Zustand erhalten bleibt - abspeichern. Damit wüsste der Arduino nach dem Einschalten immer, welchen Befehl er zuletzt gesendet hat. Der Servo würde also selbst dann, wenn du den Kippschalter während der stromlosen Zeitspanne betätigt hast, seine Endposition nicht ruckartig anfahren. Allerdings beträgt die Lebensdauer des EEPROM nur etwa 100.000 Schreibzugriffe. Daher halte ich diese Möglichkeit nicht für sinnvoll.

Übrigens wäre dein Programm einfacher zu lesen, wenn du dich an gewisse Konventionen halten würdest. Dazu gehört:

• Variablen werden als camelCases geschrieben, d.h. der erste Buchstabe ist klein, Großbuchstaben stehen an jedem Wortanfang. Also stellungBisher statt Stellung_bisher. Sieht komisch aus, erleichtert aber im Programmtext die Orientierung.
• Konstanten werden über #define festgelegt und in GROSSBUCHSTABEN geschrieben. Du brauchst dafür keine Variable.
• Auch eingerückte Zeilen sind nützlich. Innerhalb eines Blockes, der durch geschweifte Klammern gebildet wird, rückt man alles ein wenig nach rechts, so dass man gleich sieht, dass es eine untergeordnete Einheit bildet.

Hallo, Ruinenbaumeister,

vielen Dank für Deine prompte Antwort und die grundsätzlichen Tipps darin.

Ich habe Deine Änderung in das Programm eingearbeitet mit folgendem Ergebnis:
1.) Wenn der Servo beim Ausschalten der Stromversorung in der "Stellung 1" ist (Kippschalter_Pin, HIGH),
bleibt der Servo auch beim Einschalten der Stromversorgung in der Stellung 1. Dies ist eine Verbesserung
zum bisherigen Stand: Hier hatte der Servo beim Einschalten von Stellung 1 zur Stellung 2 und wieder zurückgeschaltet.
2.) Wenn der Servo beim Ausschalten der Stromversorgung in der "Stellung 2" ist (Kippschalter_Pin, LOW);
schaltet der Servo beim Einschalten der Stromversorung in die Stellung 1 um und bleibt auch in dieser Stellung, solange
ich den Kippschalter nicht bediene.

Nachstehend vorsorglich nochmal das vollständige Programm mit Deiner eingearbeiteten Änderung:

#include <WProgram.h>

int myservo;

int Kippschalter_Pin = 0;//Betrifft Pin beim ATtiny 45
int Servo_Pin = 2;//betrifft Pin beim ATtiny 45
int Stellung1 = 28;// Servostellung 1 (einstellbar zwischen 0° und 180°)
int Stellung2 = 0;//Servostellung 2 (einstellbar zwischen 180° und 0°
int Stellung_bisher;//Für Vergleich
const int WARTEN = 19;//19 Millisekunden Warten nach Stellschritt. Nicht verändern!
void Servo_move(int servo,int Stellung_neu);

void setup()
{
pinMode(Kippschalter_Pin, INPUT);
digitalWrite(Kippschalter_Pin, HIGH);
pinMode(Servo_Pin, OUTPUT);

if(HIGH==digitalRead(Kippschalter_Pin)){
Stellung_bisher=Stellung1;
}else{
Stellung_bisher=Stellung2;
}
}

void loop()
{
if(digitalRead(Kippschalter_Pin)==HIGH)
Servo_move(Servo_Pin, Stellung1);
if(digitalRead(Kippschalter_Pin)==LOW)
Servo_move(Servo_Pin, Stellung2);
delay(20);
}

void Servo_move(int servo,int Stellung_neu)
{
int Schritt;
if(Stellung_neu==Stellung_bisher)return;
Schritt=(Stellung_neu>Stellung_bisher)?1:-1;
while(Stellung_bisher!=Stellung_neu){
Stellung_bisher+=Schritt;

digitalWrite(servo, HIGH);
delayMicroseconds((Stellung_bisher*8)+500);
digitalWrite(servo, LOW);
delay(WARTEN);
}
}

Hast Du hierfür eine Erklärung? Hängt dies evtl. mit der Zeile im "void Servo_move" zusammen, wo es heißt:
"if(Stellung_neu==Stellung_bisher)return;"?

Nochmal vielen Dank für Deine Hilfestellung.

Einen schönen Tag
Bierrudl

Ja, die Zeile muss weg. Andernfalls werden keine Befehle an den Servo gesandt.

Probier mal das hier:

#include <WProgram.h>

#define KIPPSCHALTER 0
#define SERVOPIN 2
#define STELLUNG_1 28
#define STELLUNG_2 0
#define WARTEN 19

int myservo;
int stellungBisher;

void Servo_move(int servo,int Stellung_neu);

void setup(){
pinMode(KIPPSCHALTER, INPUT);
digitalWrite(KIPPSCHALTER, HIGH);
pinMode(SERVOPIN, OUTPUT);

if(HIGH == digitalRead(KIPPSCHALTER)){
stellungBisher = STELLUNG_1;
}else{
stellungBisher = STELLUNG_2;
}
}

void loop(){
if(HIGH == digitalRead(KIPPSCHALTER))
Servo_move(SERVOPIN, STELLUNG_1);
else
Servo_move(SERVOPIN, STELLUNG_2);
delay(20);
}

void Servo_move(int servo,int stellungNeu){
int schritt;
schritt = (stellungNeu > stellungBisher)?1:-1;
while(stellungBisher != stellungNeu){
stellungBisher += schritt;
digitalWrite(servo, HIGH);
delayMicroseconds((stellungBisher*8)+500);
digitalWrite(servo, LOW);
delay(WARTEN);
}
}

Du siehst, dass ich einige der Variablen durch #define ersetzt habe. Wenn dein Programm kompiliert wird, läuft erstmal der Präprozessor drüber und ersetzt alles, was oben definiert wurde durch den entsprechenden Wert. Anstelle von "WARTEN" in der vorvorletzten Zeile hättest du auch gleich "19" einsetzen können. Mit #define kannst du Korrekturen zentral vornehmen und musst nicht im Programmtext suchen, wo und wie oft du den Zahlenwert verwendet hast.

Den Zahlenwert als int-Variable zu definieren ist unnötig aufwendig. Die Werte bleiben ja, solange das Programm läuft, unverändert. Es reicht also, die festen Werte in den Programmtext einzutragen. Der Platz in den REgistern bleibt frei für die Variablen, die auch wirklich variabel sind.

Hallo, Clemens,

vielen Dank für Deinen Sketch und die sehr hilfreichen Erläuterungen.

Ich habe den Sketch ausprobiert. Leider ändert sich das Verhalten des Servo ggü. meinen Angaben von gestern, 09. Mai, nicht.
Ich habe meine Schaltung überprüft; diese passt, soweit ich das beurteilen kann.
Evtl. liegt es an den verwendeten Servos selbst. Es sind relativ billige.

Ich bin schon froh, dass die Weichensteuerung mittels Servos überhaupt funktioniert.

Falls sich nicht noch etwas auftut, werde ich die Weichen einfach so stellen, dass sie beim Einschalten der Stromversorgung ruhig bleiben.
Ich habe nicht so viele Weichen.

Auf jeden Fall nochmals vielen Dank und ein schönes Wochenende wünscht

Bierrudl

Hallo,

ich verwende keine Arduino software, also kann ich keine weiteren Details beisteurn ausser folgendem: Ich schicke keine Impulse zu den Servos, wenn sie sich nicht bewegen sollen. Konkret mache ich es mit meinen Atmegas so, dass die Timer, die die Impulse erzeugen, erst dann eingeschaltet werden, wenn der Servo sich in einen neue Postion bewegen soll. So liegen meine Servos immer ruhig und still an ihren Positionen.

Michael

Clemens,

da ich mich in die Programmierung noch nicht sehr weit eingearbeitet hab, mal ein paar Anfängerfragen :

wenn ich dein Programm richtig verstehe, steuerst du damit "nur" einen Servo an.

Was müßte man ändern, um damit weitere Servos (wieviele max ?) ansteuern zu können ?

Und wo werden Servos und Schalter angeschlossen ?

Danke für deine Hilfe.

Hallo Jörg,

die Standardbibliothek des Arduino ist für bis zu 6 Servos zu gebrauchen. Es gibt auch die SoftwareServo-Bibliothek, die 12 oder gar 48 Servos steuern kann. Da stellen sich erstmal die Fragen: Wieviele Servoanschlüsse brauchst du? Welchen Arduino willst du verwenden? Welche Stromversorgung willst du nutzen? Welche Bedienelemente (Taster, Kippschalter, Reedkontakte etc.) willst du verwenden?

Ich werde im Moment aus dem Programm nicht schlau. Es wird eine Variable myservo gesetzt, die nicht ausgelesen wird; es wird ein Pin als Input deklariert und gleich darauf als Output angesteuert ... Das hätte mir eigentlich vor einem halben Jahr schon auffallen müssen. Ich würde das Programm nochmal neu schreiben, so dass es sich besser an mehrere Servos anpassen lässt. Das ist nicht kompliziert, ich brauche nur eine etwas klarere Vorstellung davon, wie der Anwendungsfall aussieht. Ich schlage vor, du beantwortest die obigen Fragen. Dann sehen wir weiter.

Zitat von Der Ruinenbaumeister

---

• Variablen werden als camelCases geschrieben, d.h. der erste Buchstabe ist klein, Großbuchstaben stehen an jedem Wortanfang. Also stellungBisher statt Stellung_bisher. Sieht komisch aus, erleichtert aber im Programmtext die Orientierung.
• Konstanten werden über #define festgelegt und in GROSSBUCHSTABEN geschrieben. Du brauchst dafür keine Variable.
• Auch eingerückte Zeilen sind nützlich. Innerhalb eines Blockes, der durch geschweifte Klammern gebildet wird, rückt man alles ein wenig nach rechts, so dass man gleich sieht, dass es eine untergeordnete Einheit bildet.

---

Hi,
das findich lustig, es erinnert mich an die Zeit, in der ich noch selbst programmiert habe.

• Damals (90er?) stritten sich die Erneuerer, die die KamelSchreibWeise einführen wollten, mit den Bewahreren, die ihre Variablern anders_aber_genauso_gut_lesbar schrieben. Der Gipfel der Erneuerung war damals eine Schreibweise, die als ersten Buchstaben den Typ hatte, also ein int einfacher_zaehler wurde nicht etwa zum int EinfachenZaehler, sondern zum int iEinfachenZaehler. Ein Zeiger auf eine nullterminierte Folge von Characters wurde also pzsPointerAufZeroTerminatedString.
• #define DAS_IST_EINE_NULL 0 war damals noch Standard und ohne Diskussion, heute aber liest man immer mehr, #defines gar nicht mehr zu benutzen. Ein const int nimmt auch nicht mehr Platz weg, da der Compiler ihn ohnehin "wegoptimiert".
• Nur das mit dem Einrücken, das ist noch nicht in Verruf geraten. Das empfiehlt sich nach wie vor. Wenn man sich streiten will, dannn darüber, wo die geschweifte Klammer hingehört - mit eingerückt, oder nciht?

Zitat von Der Ruinenbaumeister

---

Hallo Jörg,

die Standardbibliothek des Arduino ist für bis zu 6 Servos zu gebrauchen. Es gibt auch die SoftwareServo-Bibliothek, die 12 oder gar 48 Servos steuern kann. Da stellen sich erstmal die Fragen: Wieviele Servoanschlüsse brauchst du? Welchen Arduino willst du verwenden? Welche Stromversorgung willst du nutzen? Welche Bedienelemente (Taster, Kippschalter, Reedkontakte etc.) willst du verwenden?

---

Zu deinen Fragen :
in meinem Modulbahnhof gilt es 8 Servos anzusteuern. Es können ruhig zwei Arduinos eingesetzt werden. Es würde also die Standartbibliothek reichen. Wenn der UNO reicht, nehm ich den.
Jede Weiche soll mit 1 oder zwei Tastern betätigt werden und jeweils 2 LEDs sollen die Weichenlage anzeigen. Stromversorgung über extra 5V-Netz. Es stünden aber auch 12V zur Verfügung.

Zitat von Der Ruinenbaumeister

---

Ich werde im Moment aus dem Programm nicht schlau. Es wird eine Variable myservo gesetzt, die nicht ausgelesen wird; es wird ein Pin als Input deklariert und gleich darauf als Output angesteuert ... Das hätte mir eigentlich vor einem halben Jahr schon auffallen müssen. Ich würde das Programm nochmal neu schreiben, so dass es sich besser an mehrere Servos anpassen lässt. Das ist nicht kompliziert, ich brauche nur eine etwas klarere Vorstellung davon, wie der Anwendungsfall aussieht. Ich schlage vor, du beantwortest die obigen Fragen. Dann sehen wir weiter.

---

Danke für deine Hilfe.

Ich würde dir folgendes vorschlagen: Ansteuerung über Kippschalter statt Tastern, LEDs auch über den Kippschalter gesteuert. Dann brauchst du nur sechzehn Ports und kommst mit einem Arduino Uno aus.

Wenn es bei Tastern bleiben soll, braucht es pro Servo [s]vier[/s] drei Ports: zwei für die Taster und die LEDs, einen für die Servos selbst. Du bräuchtest dann zwei Arduinos. Ich würde in dem Fall gleich dazu übergehen, für je zwei Servos einen ATTiny zu verwenden. Die können mit dem Arduino Uno programmiert werden und sind weit günstiger in der Anschaffung.

Welche Methode ist dir lieber?

Hallo Clemens,

Zitat von Der Ruinenbaumeister

---

...
Es wird eine Variable myservo gesetzt, die nicht ausgelesen wird;
...

---

Stimmt, ist mir auch aufgefallen.

Zitat von Der Ruinenbaumeister

---

...
es wird ein Pin als Input deklariert und gleich darauf als Output angesteuert
...

---

Damit wird der interne PullUp-Widerstand des Arduino für den besagten Pin aktiviert.

Ansonsten werde ich das Programm demnächst auch mal austesten.

Freundliche Grüße
Thomas

@Clemens,

es soll bei Tastern und LEDs bleiben.
Das mit den ATtinys hört sich in sofern noch interessanter an, weil es besser zu Verteilung der Weichen auf die 4 Modulkästen passt und den Verkabelungsaufwand geringer hielte.

Thomas,
was bewirkt dieser pullup-Widerstand ?

Hallo Jörg,

Zitat von heidebahner

---

...
Thomas,
was bewirkt dieser pullup-Widerstand ?

---

In Zusammenhang mit einem Schalter bzw. Taster: Bei offenem Taster liegt die Versorgungsspannung des Arduinos (+ 5V) über den PullUp-Widerstand am Eingangspin des Mikrocontrollers an (HIGH) und nicht irgendein undefinierter Zustand.
Wird der Taster/Schalter geschlossen, wird der Pin sofort mit dem Massepotential verbunden (LOW).

Wenn Du mehr dazu wissen willst: http://www.elektronik-kompendium.de/publ...aerer/pullr.htm

HTH

Freundliche Grüße
Thomas

Danke dir, Thomas.

Hier ist das Programm, mit dem du bis zu sechs Servos mit einem Arduino ansteuern kannst. Leider funktionieren hier keine Einrückungen, was das Ganze etwas unübersichtlich macht.

Vielen Dank, Clemens

Da muß ich mich erst mal richtig reinlesen.

Allerdings ergeben sich gleich zwei Fragen.

Müßte nicht die Variable SERVOS in der dritten Zeile auf 6 statt auf 2 stehen ?

Und reicht ein 1F, 5,5V Goldcap ?

Bei SERVOS trägst du soviele Servos ein, wie du nutzen willst.

1F sollte auf jeden Fall ausreichen.

Was ich noch erwähnen sollte: Die GND-Pins von Arduino und Servo-Spannungsversorgung müssen miteinander verbunden sein. Falls du keine potentialfreie Spannungsversorgung (also kein eigenes Netztei) für den Arduino hast, dann sollten wir uns deine Spannungsversorgung etwas genauer ansehen. Sonst kann es unerwünschte Nebeneffekte geben.

Dann hab ich die Variable ja richtig interpretiert.

Danke für den Tip mit dem Gnd-Pins. Ich habe ein Steckernetzteil 5V, 1500mA für meinen Arduino gekauft.

Das wollte ich dafür nutzen. Sollte ja dicke reichen.

Hallo,
ich bin nach dem oben erwähnten Projekt gefragt worden, wo der Arduino das DCC-Signal interpretiert.

Die Grundlagen dazu werden hier in diesem Projekt gelegt. Hier wird das DCC-Signal gelesen, aber noch nicht ausgewertet:
http://www.mynabay.com/arduino/2-uncateg...ino-dcc-monitor
Notabene: Man braucht einen High-Speed-Optokoppler als zusätzliches Bauteil.

In diesem zweiten Projekt, das auf dem erstgenannten aufbaut, wird dann das DCC-Signal auch ausgewertet, um damit einen oder nehrere Servos oder anderes anzusteuern.
https://rudysmodelrailway.wordpress.com/...nction-decoder/

Ich wollte das mal ausprobieren, aber weiter als bis zum Bestellen der besonderen Optokoppler bin ich noch nicht gekommen

Gruß
Martin

Ich will mich auch schon länger diesem Programm widmen, um es als Basis für eigene Projekte zu nutzen. Dazu gehört dann auch eine neue Hardware - quasi als Alternative zum WeichEi oder SandEi und mit Zugriff auf die umfangreichen Bibliotheken des Arduino.

Hallo Martin,

Zitat von Nichteisenbahner

---

...
Ich wollte das mal ausprobieren, aber weiter als bis zum Bestellen der besonderen Optokoppler bin ich noch nicht gekommen
...

---

da bist Du aber schon deutlich weiter als ich...
Ich bin derzeit noch dabei, die Library und den Code des zweiten Projektes zu analysieren.

Und dann gibt es ja noch TC...

Freundliche Grüße
Thomas

Hallo Martin,

vielen Dank für die Links. ich werd mir das auch mal zu Gemüte führen und in einer ruhigen Minute mal ausprobieren. Die Frage ist, ob man das auch mit nem Attiny oder atmega quasi standalone machen kann. Aber so wie es in dem einen Video heißt sind die Arduino Unos aus Fernost ja mittlerweile so preiswert, das sich das wohl gar nicht mehr rechnen wird..... auf jeden Fall eine spannende Sache

Grüße

Tom75