Ansteuerung eines Schrittmotors mit 2 Endschaltern

Das Relais schaltet einen Motor an, der erst auf Touren kommen muß, 
deshalb die 5 Sek. Wartezeit, ehe der Schrittmotor loslaufen soll. der 
treibt einen Schlitten auf einer Linearachse an, der bis zur Endlage 
fahren, dort soll der Andere Motor abgeschaltet werden und abtouren, 
deshalb wieder 5 Sek. warten und wieder zur Ausgangspos. zurückfahren.
Erfahrungsgemäß kommt es bei Schrittmotoren zu Schrittverlusten, aus 
unterschiedlichen Gründen. Somit würde sich die Position immer mehr 
verschieben. Die Endschalter wären sozusagen eine Sicherheit, aber wenn 
das mit der einfachen Zählerrei auch gut funktioniert, könnte ich es so 
machen. Das vereinfacht das Ganze erheblich, ich habe da glaube ich 
schon einen Code in einer Bibliothek gesehen. Das mit der Rampe macht es 
wieder komplizierter.
Näheres zum Projekt hier:
Beitrag "Vorschubsteuerung für Gehrungssäge"

tommy schrieb:
> Hallo Jens,
> mach doch bitte nicht mehrere Threads zu einem Thema auf.
>
Es handelt sich um unterschiedliche Aspekte in meinem Projekt, die in 
unterschiedlichen Themengruppen behandelt werden. Ich möchte die 
Experten, die sich in den entsprechenden Themengruppen umsehen, 
erreichen.
> Hier in "Compiler und IDEs" bist Du sowieso völlig falsch.
>
Es geht mir hier nur um die Programmierung, welche Gruppe wäre dann hier 
die richtige?
>> Das Relais schaltet einen Motor an
>
> Was für ein Motor?
> Es gibt bestimmt bessere, elektronische Möglichkeiten.
> Vermeidet dann z.B. den Abreissfunken beim Ausschalten.
Da geht es um die Elektronik, das in einem anderen Themengebiet 
behandelt wird
>
> Das Programm ohne Nutzung fremder Bibliotheken (Libraries) zu
> schreiben hat einen viel höheren Lernfaktor ;-)
O.K. werde ich versuchen.
> P.S.: Du scheinst schon etwas älter zu sein, denn ich meine in
> einem der anderen Threads "220V" gelesen zu haben. Das war einmal ;-)
>
Ja Ü50, jetzt sind es wohl 230V die Umstellung ist mir doch glatt 
entgangen.

Ich danke für die Belehrungen in Bezug auf Schrittmotoren, aber in einem 
anderen Beitrag war jemand der Meinung, dass wenigstens ein Schalter 
sein muß. Nun ja so ist das halt.
Ich bin nur ein kleiner Bastler, der eine Idee umzusetzen versucht.
Wenn`s nicht funktioniert bleibe ich bei Handbetrieb.
Wie gesagt, hier geht es nur um`s Programmieren.
Ich fange mal an und bitte euch um eure Meinung.

Wolfgang schrieb:
> Jens R. schrieb:
>> ... aber in einem anderen Beitrag war jemand der Meinung, dass wenigstens
>> ein Schalter sein muß.
>
> Benötigt wird ein Positionssensor. Das kann z.B. eine Lichtschranke
> irgendwo auf dem Weg sein, die dem Contoller mitteilt: "Der Schlitten
> ist jetzt beim Sensor".

Warum dann nicht ein Rollenschalter, den habe ich gerade da, am Wegende?
Und wenn da schon einer ist, kann doch am Weganfang auch einer sein, den 
habe ich nähmlich auch gerade da.
Ich arbeite an einer CNC-Maschine mit hochgenauen Messsystem, trotzdem 
gibt es auch hier noch Endschlter!
Ist das dann auch unnötig? Dann bau ich sie heute noch aus.

Udo K. schrieb:
> Und um was geht es genau?
>
> Oder ist das wieder so ein supergeheimes Ding aus dem
> Verteidigungsministerum?

Nein natürlich nicht.
Also ich habe mir eine Gehrungssäge gebaut.
Eine Kreissäge angetrieben von einem Brushlessmotor.
Die Säge sitzt auf einem Schlitten, der hin und her rutscht.
Damit ich das Ganze nicht mehr von Hand betätigen muß und um weit weg 
von gefährlichen sich drehenden Teilen zu sein soll die Hin-Herbewegung 
automatisch erfolgen.
Also wie folgt:
-Sägenmtor an
-hochtouren lassen
-Vorschub an
-am Ende der Wegstrecke angelangt anhalten
-Sägenmotor abschalte
-abtouren
-Vorschub zurück in Ausgangslage
und aus
Anbei mal ein Bild davon

Ich beginne mal mit einer Trockenübung:
Ich habe mal versucht einen Code zu schreiben, um das Relais am Anfang 
einzuschalten und eingeschaltet zu lassen.
Bitte nicht lachen, es sind meine ersten Gehversuche.

void setup() {
pinMode(2,OUTPUT);
pinMode(3,INPUT);
}

void loop() {
if (digitalRead(3)==HIGH;digitalRead(2)==LOW)
{
  digitalWrite(2,HIGH)
  else digitalWrite(2,HIGH)}
}

Mich verwirrt, die Schleife (void loop) warum kann ich das Relais nicht 
einfach einschalten und weiter im Programm?

Wolfgang schrieb:
> Jens R. schrieb:
>> Warum dann nicht ein Rollenschalter,
>> ...
>> Ich arbeite an einer CNC-Maschine mit hochgenauen Messsystem, trotzdem
>> gibt es auch hier noch Endschlter!
>> Ist das dann auch unnötig? Dann bau ich sie heute noch aus.
>
> Rollenschalter sind eher nicht hochgenau, also nicht zur
> Positionsbestimmung geeignet. Du solltest zwischen Maschinensteuerung
> und Sicherheitstechnik unterscheiden.

Hochgenau positionieren möchte ich nicht, für mich sind die 
Rollenschalter sicherheitstechnisch relevant, da sie die Endlage 
kontrollieren, sonst kann ich sie auch weglassen. Ich denke eine Abfrage 
der Schalter sollte programmtechnisch eher gering im Aufwand sein und da 
sie sowieso vorhanden sind kann es ja nicht schaden.
In meiner kleinen Fräse im Keller sind auch diese Dinger verbaut und 
funktionieren seit 3 Jahren reibungslos, wie gesagt nur als Endschalter.

Jens R. schrieb:

> Per Tasterdruck soll ein Relais geschaltet werden, nach ca. 5 Sek. soll
> ein 2 Phasen Schrittmotor losdrehen und bis zur Betätigung eines
> Endschalters fahren, dort anhalten,

Warum nimmst Du da nicht einfach einen DC-Motor? Dann funktioniert
die Schaltung ganz ohne Elektronik.

Mir ist ein Licht aufgegangen.

Jens R. schrieb:
> Mich verwirrt, die Schleife (void loop) warum kann ich das Relais nicht
> einfach einschalten und weiter im Programm?

Ich versuche mir mal selbst zu antworten,
der µC fängt sofort wenn er unter Strom steht das gespeicherte Programm 
abzuarbeiten an, ohne Anstoß von außen.
Wäre da nicht dieses dauernde Durchlaufen, könnte man höchstens einen 
Code ausführen, Eingaben könnten aber nicht überwacht werden.
Richtig?
Wieder was gelernt!
Sollte ich jetzt für den Code einen neuen Beitrag eröffnen in der 
entsprechenden Gruppe?
Die älteren Beiträge könnten geschlossen werden, weil erledigt.
Wie macht man den so etwas.

MaWin schrieb:
> Jens R. schrieb:
>> Erfahrungsgemäß kommt es bei Schrittmotoren zu Schrittverlusten, aus
>> unterschiedlichen Gründen.
>
> Welche Erfahrung sol das sein ?
>
> Deine Erfahrung ? Ich dachte, du hast keine Erfahrung.
>
> Ein Schrittmotor, der Schritte verliert, wurde falsch eingesetzt.
Erfahrungen von meiner CNC Eigenbaufräse im Keller.
Die wird von einer Software betrieben, da habe ich mir noch keine 
Gedanken über den Code gemacht, der diese ansteuert.

MaWin schrieb:
> Benutze zum Betrieb eines Schrittmotortreibers an einem Arduino eine
> Library wie https://www.airspayce.com/mikem/arduino/AccelStepper/
> denn die eingebaute https://www.arduino.cc/en/Reference/Stepper
> kann keine Schrittmotortreiber mit DIR und STEP Anschlüssen
> [c]
> #include <AccelStepper.h>
> AccelStepper myStepper(AccelStepper::DRIVER , 8, 9); //
> Schrittmotortreiber an Pin 8 und 9
>
> Dein setup nutzt Pin3 für den Taster, Pin2 für das Relais, du brauchst
> noch einen Endschalter an Pin4 und einen Anfangsschalter auf Pin5.
>
> Dein loop sollte auf den Tastendruck warten
Ist klar der Code ist Mist.
Ich habe mich auch schon etwas weiter informiert.
Erstmal Dank für die konstruktive Hilfe!
Ich habe mir auf nem Zettel schon ein bisschen Code zusammengebastelt, 
der muß nur noch eigegeben werden.
Die Teile sind unterwegs, so mache ich jetzt Trockenübungen.
Einen Simulator will ich mir auch noch installieren.
Durch den Schrittmotortreiber muß ich, wenn ich richtig verstenden habe, 
doch nur ein Dir-Signal auf Dir-Pin (High oder Low) senden und der Takt 
wäre dann nur High, Delay, Low, Delay Auf Step-Pin.
Ist das nicht so?

Hier mein Code bisher:

1

int RelPin = 1; //Relais

2

int DirPin = 2; //Dir Schrittmotor

3

int RelPin = 3; //Step Schrittmotor

4

int EndPin = 4; //Endschalter

5

int AnfPin = 5; //Anfangsschalter

6

int Startpin = 2; //Starttaster

7

8

9

void setup() {

10

  pinMode(1; OUTPUT); //Relais

11

  pinMode(2; OUTPUT); //Dir Schrittmotor

12

  pinMode(3; OUTPUT); //Step Schrittmotor

13

  pinMode(4; OUTPUT); //Endschalter

14

  pinMode(5; OUTPUT); //Anfangsschalter

15

  pinMode(6; INPUT); //Starttaster

16

}

17

18

void loop() {

19

  digitalRead(StartPin)//Abfrage Starttaster

20

  if (StartPin == HIGH) { //Wenn Starttaster gedrückt

21

    digitalWrite(RelPin, HIGH) //Sägenmotor an

22

    delay(5000) //Wartezeit zum Sägenmotor hochtouren

23

    digitalWrite(dirPin, HIGH) //Richtung Schrittmotor

24

    While(EndPin, HIGH) { //Schleife solange Endschalter micht geschaltet

25

      //Hier soll noch  die Beschleunigung rein

26

      digitalWrite(StepPin, HIGH) //Signal Schrittmotor

27

      delay(10) //Pausenlänge für Geschwindigkeit

28

      digitalWrite(StepPin, LOW) //Signal Schrittmotor

29

      delay(10) //Pausenlänge für Geschwindigkeit

30

    }

31

    digitalWrite(RelPin, LOW) //Sägenmotor aus

32

    delay(5000) //Abtouren Sägenmotor

33

    digitalWrite(dirPin, LOW) //Richtungsumkehr Schrittmotor

34

    While(AnfPin, HIGH) { //Schleife solange Anfangsschalter micht geschaltet

35

      //Hier soll noch die Beschleunigung rein

36

      digitalWrite(StepPin, HIGH) //Signal Schrittmotor

37

      delay(10) //Pausenlänge für Geschwindigkeit

38

      digitalWrite(StepPin, LOW) //Signal Schrittmotor

39

      delay(10) //Pausenlänge für Geschwindigkeit

40

    }

41

  }

42

}

Johannes S. schrieb:
> 'state machine' wäre ein Stichwort um passendes Futter zu suchen. Damit
> wird es etwas übersichtlicher und auch so Sachen wie Schnell/Nothalt
> besser zu realisieren.

Naja zumindest kein: "Oh Gott, was für ein Müll."
In einer letzten Antwort wurde mir geraten, Bibliotheken zu meiden, um 
etwas dazuzulernen. Das habe ich auch vor.
Bevor noch Fragen wie : "Du hast noch nie zuvor programmiert?" kommen, 
ja ich habe verschieden Sachen mit Excel ausprobiert und auf der Arbeit 
"programmiere" ich Tag täglich, eine CNC-Maschine mit 
Heidenhain-Steuerung.
Jaja, von wegen programmieren, aber das Grundverständnis von Schleifen 
und Abfragen ist auch dort wichtig und in gewissen Maße kann man da auch 
richtig "programmieren".

Aha verstehe, den Notaus habe ich noch gar nicht drin, aber während des 
Hoch-und Ab-Tourens kann ich drauf rumkloppen wie ich will, es passiert 
nichts.
Aber leider verstehe ich "noch" null von flags u.s.w.
Danke für deine Hilfe.
Ich brauche erst noch alle Teile um richtig experimentieren zu können.
Und dann Schritt für Schritt weiter.
Ich finde das alles wirklich toll, wie man mit diesem Arduino als Laie 
auch schnell zu einem Ergebnis kommen kann.

Ja, danke für den Hinweis,
die Schalter sind ja wohl INPUT.
Doing bei learning habe ich gelesen, wenn hier nur die Fehler aufgezählt 
werden, will ich eure wertvolle Zeit nicht weiter verschwenden und mache 
weiter, bis der letzte yC sein Leben ausgehaucht hat.
Ich danke für die Hilfe!

Ich habe mir den Simulator for Arduino von Virtronics geladen und meinen 
Code simuliert.
Die Fehler habe ich beseitigt, weiß jemand zufällig, wie man einen 
Tastendruck (input) da simuliert?
Oder gibt es da bessere Simulatoren?

M. K. schrieb:
> Ein Flag ist nur ein Bit.
> Der Timer läuft ab und setzt das Bit.
> Das ist das Zeichen, das Zeit xx abgelaufen ist.
> Deine Auswertung startet sobald das Flag gesetzt ist und setzt es dabei
> zurück, damit wieder Zeitablauf signalisiert werden kann.
>
> ISR bedeutet Interrupt Service Routine.
> Der Timer im uC ist ein kleines Stück Hardware, das man über seine
> Register so einstellt, das es, unabhängig vom Rest des uC, in
> regelmäßigen Zeitabständen dem uC signalisiert, das er all seine
> Tätigkeiten unterbrechen und an einen bestimmten Programmbereich
> springen soll, an dem es Code abzuarbeiten gilt.
> In der ISR macht man im allgemeinen so wenig wie möglich, um den
> normalen Programmablauf so wenig wie möglich zu blockieren.
> Zieh Dir das Datenblatt des Microcontrollers der auf deinem arduino
> verbaut wurde. Da steht alles drin was Du wissen musst.

Ich ahne ungefähr, worauf du hinaus willst.
In so tiefe Gründe will ich dann doch nicht hinabtauchen.
Trotzdem werde ich wahrscheinlich bald vor einem Problem stehen:
Momentan bin ich mit meinem Code so weit fertig. Die Simulation läuft 
prächtig und macht alles richtig. Mit Nano hatte ich so meine 
Verbindungsschwierigkeiten (billige China-Büchse), habe den Code aber 
erfolgreich draufgespielt und nur mit LED`s mal getestet.
Jetzt habe ich folgende Idee:
Ich möchte den BL-Motor über den Fahrtenregler direkt per ESC 
ansteueren.
programmtechnischnisch ist das kein Problem. Anschließend läuft der 
Schrittmotor in einer Dauerschleife durch bis zum Endschalter. Dabei muß 
der Fahrtenregler, denke ich, parallel sein 2ms-Signal 
(Highspeed)erhalten sonst fällt er zurück?! Während des delay im 
Schrittmotortiming pausiert der Prozessor aber. Hast du einen Vorschlag, 
wie man das lösen kann?
Hier mein derzeitiger Code:

1

int DirPin = 3; //Dir Schrittmotor

2

int StepPin = 4; //Step Schrittmotor

3

int EndPin = 5; //Endschalter

4

int AnfPin = 6; //Anfangsschalter

5

int StartPin = 7; //Starttaster

6

int MotorSpeedPin = 2; //Motordrehzahl

7

int Step = 100; //Step pro Sek

8

int ESCMax = 2000; //max. Drehzahl Sägenmotor (2000µs)

9

int ESCPause = 20000; //Pause Motordrehzahl (20000µs)

10

void setup() {

11

  pinMode (2, OUTPUT); //Motorspeed

12

  pinMode (3, OUTPUT); //Dir Schrittmotor

13

  pinMode (4, OUTPUT); //Step Schrittmotor

14

  pinMode (5, INPUT_PULLUP); //Endschalter

15

  pinMode (6, INPUT_PULLUP); //Anfangsschalter

16

  pinMode (7, INPUT_PULLUP); //Starttaster

17

18

}

19

20

void loop() {

21

  //digitalWrite(StartPin, HIGH);

22

  if (digitalRead(StartPin) == LOW) { //Wenn Starttaster gedrückt

23

    for (int Speed = 0; Speed <= ESCMax; Speed++) {

24

      digitalWrite(MotorSpeedPin, HIGH);

25

      delayMicroseconds(Speed);

26

      digitalWrite(MotorSpeedPin, LOW);

27

      delayMicroseconds(ESCPause);

28

    }

29

    digitalWrite(DirPin, HIGH); //Richtung Schrittmotor

30

    //digitalWrite(EndPin, HIGH);

31

    while (digitalRead(EndPin) == HIGH) { //Schleife solange Endschalter micht geschaltet

32

33

      digitalWrite(StepPin, HIGH); //Signal Schrittmotor

34

      delay(Step); //Pausenlänge für Geschwindigkeit

35

      digitalWrite(StepPin, LOW); //Signal Schrittmotor

36

      delay(Step); //Pausenlänge für Geschwindigkeit

37

    }

38

    for (int Speed = 2000; ESCMax <= 0; Speed--) {

39

      digitalWrite(MotorSpeedPin, HIGH);

40

      delayMicroseconds(Speed);

41

      digitalWrite(MotorSpeedPin, LOW);

42

      delayMicroseconds(ESCPause);

43

    }

44

      digitalWrite(DirPin, LOW); //Richtungsumkehr Schrittmotor

45

      //digitalWrite(AnfPin, HIGH);

46

      while (digitalRead(AnfPin) == HIGH) { //Schleife solange Anfangsschalter micht geschaltet

47

        //Hier soll noch die Beschleunigung rein

48

        digitalWrite(StepPin, HIGH); //Signal Schrittmotor

49

        delay(Step); //Pausenlänge für Geschwindigkeit

50

        digitalWrite(StepPin, LOW); //Signal Schrittmotor

51

        delay(Step); //Pausenlänge für Geschwindigkeit

52

      }

53

    }

54

  }

Johannes S. schrieb:
> State machine, das Stichwort hatte ich schonmal genannt.

Ja wie löst das jetzt das Problem der Parallelabarbeitung 
(ESC/Schrittmotor)?
Ich habe schon wirklich sehr viel gelesen, das ist in der kurzen Zeit 
aber schon heftig und für mich schwer zu verstehen.
Ich benutze die Arduino Referenz als Quelle für den Code.
In der englischen Version habe ich mal etwas über eine Yield Funktion 
gelesen, die irgendwie in der Delay-Zeit etwas abarbeiten kann.
Ich wäre über weiterführende Tipps sehr dankbar.

Alles schon da schrieb:
> M. K. schrieb:
>> Ich schreibe mir für sowas eine Timer ISR die alle xx ms ein flag setzt.
>
> Wenn man Arduino verwendet, kann man direkt den sowieso für millis()
> laufenden Timer verwenden und sich z.B. per TIMER0_COMPA Interrupt dort
> einklinken.
> https://learn.adafruit.com/multi-tasking-the-arduino-part-2/timers
>
> Oder man prüft den Rückgabewert von millis() auf Änderung gegenüber dem
> vorherigen Aufruf ;-)

Oh ja harter Tobak, für mich jedenfalls, da brauche ich Jahre, das zu 
verstehen.
Vielleicht splitte ich die delays für den Schriitmmotor dann doch lieber 
auf. Ich habe gelesen, dass der ESC eine Aktualisierung von 50ms 
braucht, da muß ich mit den einzelnen delays für den Schrittmotor 
drunter bleiben und aktualisiere den ESC dann mehrmals pro 
Schrittmotor-Takt.
Nicht gerade elegant, aber ich denke, das kriege ich so auch hin.

Ich hab mir gerade nochmal die "millis" Funktion verinnerlicht, das wird 
die Lösung sein.
"millis" Zeit auslesen und in Variable merken,
anstatt delay eine Schleife, mit Abfrage ob die "millis"Variable um 
festgelegten Wert erreicht hat, dann folgende Aktion.
In der Schleife kann ich dann belibigen Code ausführen, z. B. den ESC 
aktualisieren.
Ich hoffe, ich habe das so richtig verstanden.

O.K.
Ich werde mir das nochmal ansehen mit den switch-case.
Danke erstmal.

Johannes S. schrieb:
> hier hatte ich mal ein Beispiel für eine state machine genannt. Es geht
> nur ums Prinzip, nicht jetzt hier das konkrete Problem.
> Beitrag "Re: Schrittmotor"
>
> Also das Programm rennt immer im Kreis und guckt was aktuell zu tun ist
> (die case im switch statement). Wenn ein Schritt fertig kann auf den
> nächsten oder einen anderen geschaltet werden. Den cases kann man auch
> Namen geben um das übersichtlicher zu machen.
> So 'hängt' das Programm nicht in einem Schritt, sondern ist immer bereit
> auf Ereignisse zu reagieren. Auch wenn dir dein Programm jetzt einfacher
> erscheint, so ein switch-case ist einfacher zu testen.

Ich habe das jetzt erst mal so gelöst. Ich hoffe es funktioniert.
Die Simulationmit TinkerCAD ist ein bisschen einfach aber besser als gar 
nichts.

1

digitalWrite(DirPin, HIGH); //Richtung Schrittmotor

2

  while (digitalRead(EndPin) == HIGH) { //Schleife solange Endschalter nicht geschaltet

3

     digitalWrite(StepPin, HIGH); //Signal Schrittmotor

4

      Time = millis(); //aktuelle Laufzeit in Time

5

        StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

6

          while (StepTime > Time) { //Schleife Signal ESC

7

            digitalWrite(MotorSpeedPin, HIGH);

8

            delayMicroseconds(ESCSpeed);

9

            digitalWrite(MotorSpeedPin, LOW);

10

            delayMicroseconds(ESCPause);

11

            Time = millis(); //aktuelle Laufzeit in Time

12

          }  

13

digitalWrite(StepPin, LOW); //Signal Schrittmotor

14

        Time = millis(); //aktuelle Laufzeit in Time

15

        StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

16

          while (StepTime > Time) { //Schleife Signal für ESC

17

            digitalWrite(MotorSpeedPin, HIGH);

18

            delayMicroseconds(ESCSpeed);

19

            digitalWrite(MotorSpeedPin, LOW);

20

            delayMicroseconds(ESCPause);

21

            Time = millis(); //aktuelle Laufzeit in Time

22

          }

23

    }

Eine Frage zur switch Funktion.
in der switch Abfrage wird ja nur eine Funktion, eben die, die die 
Bedingung erfüllt, ausgeführt. Das break steigt dann aus, also ist diese 
Funktion keine Scleife, wenn ich richtig verstanden habe. so muß ich die 
switch Funktion also noch in eine Dauerschleife legen?

Johannes S. schrieb:
> Jens R. schrieb:
>> so muß ich die switch Funktion also noch in eine Dauerschleife legen?
>
> Ja, richtig. Aber es blockiert aber nicht an den Delays.

Ah ja. Ostern hab ich Zeit zum probieren.
Die delays sind ja auch immer noch drin.

M. K. schrieb:
> Entweder löst Du Dich von dem Delay Gemurkse und machst das richtig,
> oder Du lebst mit dem Gemurkse.
> Aber die Frage einfach nochmal stellen weil die Antwort nicht genehm
> war, funktioniert nicht.

Na wenigstens hab ich noch deine Aufmerksamkeit.
In einem Punkt hast du recht, ich und auch nur ich werde mit dem 
Gemurkse leben müssen.
Dein letzter Beitrag war genauso unfreundlich, aber hilfreicher.
Wenn das ganze erst mal läuft, kräht kein Hahn mehr danach, ob delay 
oder nicht delay.
Im Falle eines Scheiterns mache ich ein Video von der abbrennenden 
Maschine und stell es hier ein. Dann kommt deine Zeit, dich mit 
erhobenen Zeigefinger hinzuzustellen und zu sagen "Ich hab ja gleich 
gesagt, der hat von nichts eine Ahnung!"
Ich hoffe auf weiter Beiträge, vielleicht auch mal wieder mit 
hilfreichem Inhalt, so wie die der anderen Beteiligten.

sid schrieb:
> in pseudo code in etwa:
> [code]
> while(endschalter_ende) schrittmotor.step(fwd);
> delay(pause);
> while(endschalter_start) schrittmotor.step(rwd);
> delay(pause);
> [code]
>
> banal, gell?

Genau so habe ich es umgesetzt.

Eine Frage zu switch-case.
Ich frage die aktuelle Laufzeit ab, das ist die Vergleichsvariable im 
switch
zur Laufzeit addiere ich die Taktzeit um die Bedingung für diesen case 
festzulegen und speichere die in einer Variable.
Die Variable kann ich laut Referenz aber nicht im case eintragen.
Bleibt mir nur die Möglichkeit über return der Variable einen Zahlenwert 
zuzuweisen?

Hier mein Code:

1

digitalWrite(DirPin, HIGH); //Richtung Schrittmotor

2

Time = millis(); //aktuelle Laufzeit in Time

3

StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

4

  while (digitalRead(EndPin) == HIGH) { //Schleife solange Endschalter nicht geschaltet

5

     Time = millis(); //aktuelle Laufzeit in Time

6

         switch(Time){

7

8

9

10

         case StepTime: //Erzeugt einen Fehler

11

12

13

14

            if (StepPin==HIGH){

15

            digitalWrite(StepPin, LOW); //Signal Schrittmotor LOW wenn HIGH

16

            }

17

            else{

18

            digitalWrite(StepPin, HIGH); //Signal Schrittmotor HIGH wenn LOW

19

            }

20

            Time = millis(); //aktuelle Laufzeit in Time

21

            StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

22

            break;

23

         default:

24

         digitalWrite(MotorSpeedPin, HIGH);

25

            delayMicroseconds(ESCSpeed);

26

            digitalWrite(MotorSpeedPin, LOW);

27

            delayMicroseconds(ESCPause);

28

            break;

29

        }

M. K. schrieb:
> Nein, er war ehrlich.

O.K. ich versteh deine Sprache offensichtlich nicht, aber dass dieses 
Forum nichts für Zartbesaitete ist, wurde mir ja schon angekündigt.


M. K. schrieb:
> Nun hast Du aber natürlich immer noch die gleichen Probleme, weil Du es
> ja weiterhin auf die gleiche Art tust, und stellst einfach nochmal die
> Frage wie man die Probleme loswird.

Leider weist du mich nur darauf hin, dass ich alles falsch mache.
Ein Schubs in die richtige Richtung z.B. wäre nicht schlecht.
Ich wurde animiert, es mit der switch-Case Funktion zu probieren, ich 
denke, ich habe verstanden wozu sie gut ist, hänge aber an der Umsetzung 
fest, wie man an meinem letzten switch-Gemurkse erkennen kann.
Du bist doch Mitglied seit 2012 ich seit 2 Wochen, genau so lange 
beschäftige ich mich mit der Programmierei um den Arudino.
Vielleicht könntest du von deiner reichlichen Erfahrung etwas an mich 
weitergeben?

M. K. schrieb:
> Das widerum macht Dich zu einem der üblichen MC.net Fragesteller und die
> verlieren meine Aufmerksamkeit.

Das wäre das letzte, was ich erreichen wollte!

Johannes S. schrieb:
> So klappt das nicht, in switch() muss eine Variable rein die definiert
> gesetzt wird. Und dann landet man beim Aufruf in dem passenden case.
> Also einfaches Beispiel Ampel: switch(Farbe) und case Rot/gelb/Grün
> setzt den entsprechenden Ausgang.
> Um eine Schrittkette zu bauen also die einzelnen Schritte definieren und
> dann in jedem Schritt (case) weiterschalten wenn eine Bedingung erfüllt
> ist.

Bitte entschuldige, ich habe deinen Beitrag glatt übersehen.
Danke für die Antwort.
Ich bin da wohl einem Mißverständnis unterlegen.
Hier der korrigierte Code, der zumindest keinen Fehler wirft.

1

igitalWrite(DirPin, HIGH); //Richtung Schrittmotor

2

Time = millis(); //aktuelle Laufzeit in Time

3

StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

4

  while (digitalRead(EndPin) == HIGH) { //Schleife solange Endschalter nicht geschaltet

5

    Time = millis(); //aktuelle Laufzeit in Time

6

    if (Time==StepTime){Zustand =1;} //Zustand wird 1 gesetzt, wenn die akt.Zeit gleich der berechneten Zeit für das Schrittmotorsignal ist

7

       switch(Zustand){

8

          case 1:

9

            if (StepPin==HIGH){

10

              digitalWrite(StepPin, LOW); //Signal Schrittmotor LOW wenn HIGH

11

              }

12

              else{

13

              digitalWrite(StepPin, HIGH); //Signal Schrittmotor HIGH wenn LOW

14

              }

15

              Time = millis(); //aktuelle Laufzeit in Time

16

              StepTime = Time + Step; //Zeit für nächstes Schrittmotorsignal berechnen

17

              break;

18

          default:

19

          digitalWrite(MotorSpeedPin, HIGH);

20

            delayMicroseconds(ESCSpeed);

21

            digitalWrite(MotorSpeedPin, LOW);

22

            delayMicroseconds(ESCPause);

23

            break;

Allerdings stellt sich mir die Frage, ob 2 Zustände wirklich den Switch 
benötigen, wie man sieht gibt es nicht viel zu entscheiden.
Dieser Code bedient ja auch nur den Zustand Endschalter HIGH.
Wenn ich alle möglichen Zustände ansehe, dann kommt mir das Ganze 
plausibel vor. Dann werde ich mein Gerüst mal wieder abreißen und neu 
aufbauen.
Bis dahin kann ich ja schon mal die einzelnen Codeschnipsel für 
Schrittmotoransteuerung, BL-Motorsteuerung ausprobieren.
Danke für den Stubser in die richtige Richtung.

Bin momentan schwer am Programmieren, sieht auch schon vielversprechend 
aus leider noch ohne switch-case.
In der Simulation läuft es auch schon ganz gut.
Jetzt habe ich den Ardunino mit einem einfachen Programm für die 
Steuerung des ESC des BL-Motors geladen und da gibt es gleich ein großes 
Problem. Der Motor läuft kurz an, und wieder aus. nicht wie 
programmiert.
Nun geh ich der Sache erstmal auf den Grund.
Dann teste ich den Schrittmotor mit einem einfachen Programm.
Dann weiter mit Programmieren. Mir qualmt schon der Kopf!

Johannes S. schrieb:
> Für den BL Motor über ESC hat Arduino etwas fertiges: die Servo Library.
> Teste mal das Beispiele/Servo/Sweep.

Das ist nicht so einfach mit dem BL-Motor.
Das Problem liegt in der Initialisierung des Fahrtenreglers, der ja noch 
zwischen Motor und Arduino hängt.
Aber ich habe eine Bibliothek gefunden, womit es funktionieren könnte.
Somit verabschiede ich mich jetzt von der Idee, alles selbst 
programmieren zu wollen. Es wird ja sowieso alles Murks, aber vielleicht 
funktionierender Murks.

Johannes S. schrieb:
> Für die Schrittkette überlegtst du dir was jeweils passieren soll:
>  0 stateIdle : Ruhezustand, keine Änderungen
>  1 stateMoveHome : Säge ausschalten. wenn nicht in Hompos, Schlitten in
> Homeposition fahren auslösen. wenn in Homepos, state++
>  2 stateSawStart : Sägemotor einschalten (spin up kann man später noch
> einbauen). Setzte Wartezeit. state++
>  3 stateMoveEnd: wenn nicht in Endpos, Fahrt in Endpos auslösen sonst
> state++

Das sind dann die case Schritte?
Ich muß aber in Schleifen erst die einzelnen Variablen mit einem Wert 
belegen, sodaß im switch das entsprechende case ausgeführt wird.
Sehe ich das richtig so?

Jens R. schrieb:
> Ich frage die aktuelle Laufzeit ab, das ist die Vergleichsvariable im
> switch

Nein.

Die variable in switch ist der aktuelle BewegungsZustand, steht ja wohl 
auch in den case-Kommentaren deutlich drin.

Johannes S. schrieb:
> Für den BL Motor über ESC

Er möchte aber einen Schrittmotor ohne ESC.

sid schrieb:
> Du kannst einen Pin mit sich selbst vergleichen
> statt

Danke guter Tipp

sid schrieb:
> wenn Du millis vergleichen willst sei darauf vorbereitet,
> daß der gelesene Wert vom Erwarteten abweichen kann.
> ich weiss nicht wie lange die Säge laufen soll
> eventuell rennst du sogar in einen timer overflow;
> deswegen sei damit extra Vorsichtig..

Deswegen hätte ich >=/<= im Vergleich genommen, um den richtigen Moment 
nicht zu verpassen, wenn es das Problem darstellen sollte. Eine 
zeitliche Toleranz sollte kein Problem darstellen.
Sonst stecke ich in einem Dilemma, denn delay blockiert nun mal die 
Abarbeitung.

Johannes S. schrieb:
> Die muss man aber üblicherweise nur einmal machen, der Fahrtenregler
> speichert dann die min/max Werte. Das muss also nicht unbedingt in den
> gleichen Code mit rein, geht aber auch.

Ich habe eine Bibliothek ESC.h, damit funktioniert es jetzt.

Johannes S. schrieb:
> er hat zwei Motoren, einen SM der einen Schlitten mit Säge antreibt und
> einen BL mit ESC der das Sägeblatt antreibt. Wenn es noch so ist.
>
> Gegen die Corona Langeweile habe ich mal ein Beispiel für den Nano
> gemacht, so wie ich es machen würde.

Ja so ist es:
Hier die Hardware
Ein BL-Motor für Säge mit Fahrtenregler (ESC-Eingang)
Ein Schrittmotor  mit Schrittmotorkarte A4988 (Sep/Dir-Eingang) für 
Hin-Her-Bewegung
Ein Taster Start/Stop
Ein Taster Enschalter
Ein Taster Anfangsschalter.
Hier die Befehlskette:
Starttaste gedrückt
1. BL-Motor starten
2. Wartezeit zum Hochtouren des BL-Motor
3. SM-Motor starten Richtung hin
4. Bei Taste Endsch. gedrückt SM-Motor anhalten und BL-Motor ausschalten
5. SM-Motor starten Richtung zurück
6. Bei Anfangssch. gedrückt SM-Motor abschalten
Schleifenende
An allen Positionen soll die Abarbeitung unterbrochen werden können, das 
heißt SM-Motor aus BL-Motor aus.
Für einen Neustart bei einer Unterbrechung sollte ganz am Anfang 
vielleicht noch die Anfangpos. angefahren werden.
So ist mein Grundkonzept.
In deinem Code finde ich die End/Anf.-Scahlter nicht.
Ein Relais wird nicht benötigt, da der BL-Motor über den ESC gestartet 
wird.

Michael B. schrieb:
> Nein.
>
> Die variable in switch ist der aktuelle BewegungsZustand, steht ja wohl
> auch in den case-Kommentaren deutlich drin.

Ja danke, das habe ich jetzt kapiert.

tommy schrieb:
> Jens R. schrieb:
>> Erfahrungsgemäß kommt es bei Schrittmotoren zu Schrittverlusten, aus
>> unterschiedlichen Gründen.
>
> Das passiert nur Bastlern.

Das halte ich für ein Gerücht.

Dem hier vertraue ich: :-)

http://www.schrittmotor-blog.de/

Eine "Rampe" reduziert die Möglichkeit eines Schrittverlustes - kann 
diesen aber nicht gänzlich verhindern.

Hugo H. schrieb:
> tommy schrieb:
>> Jens R. schrieb:
>>> Erfahrungsgemäß kommt es bei Schrittmotoren zu Schrittverlusten, aus
>>> unterschiedlichen Gründen.
>>
>> Das passiert nur Bastlern.
>
> Das halte ich für ein Gerücht.
>
> Dem hier vertraue ich: :-)
>
> http://www.schrittmotor-blog.de/
>
> Eine "Rampe" reduziert die Möglichkeit eines Schrittverlustes - kann
> diesen aber nicht gänzlich verhindern.

Danke für die Unterstützung, deshalb ja die Endschalter. Und die Rampe, 
damit die schwere Last in Fahrt kommt.

Johannes S. schrieb:
> Jens R. schrieb:
>> In deinem Code finde ich die End/Anf.-Scahlter nicht.
>> Ein Relais wird nicht benötigt, da der BL-Motor über den ESC gestartet
>> wird.
>
> Das sollte ja auch ein Muster sein und noch nicht die komplette Lösung.
> Es funktioniert soweit, habe ich auf dem Steckbrett getestet.
> Endschalter sind weitere Eingänge die in checkInputs eingelesen werden,
> Flankenerkennung wie bei den Tasten ist bei denen nicht nötig. Die
> states enum muss erweitert werden und in processStateMachine() die
> entsprechenden Aktionen.
> Das Servo Objekt liefert das Timing das für den ESC gleich ist, also
> kann man mit servo.write(speed) die Geschwindigkeit vom BL Motor
> einstellen.

Bitte nicht falsch verstehen, natürlich freut es mich, dass du bisher 
als einziger einen Code zusammengebastelt, äh programmiert hast.
Vielen Dank dafür. Ich bin schon am Lesen und versuche es zu verstehen.

Wolfgang schrieb:
> Anders ausgedrückt: Mit dieser Vorgehensweise kann der Schrittmotor nie
> mit voller Fahrt in Richtung Endschalter fahren und dort anhalten.

Ja, da lasse ich mir dann etwas Luft, wie gesagt ich muß hier nicht 
hochgenau positionieren!

Johannes S. schrieb:
> Ich habe mich auch bemüht ein paar Kommentare reinzuschreiben :)
> Den Anfang habe ich ja mitverfolgt, da warst du noch bei einer Steuerung
> aus Relais und Verzögerungsschaltern. Das man das nicht alles sofort
> versteht wenn man mit µC anfängt ist ok, dafür bist du schon lernfähiger
> als einige andere die hier im Forum aufschlagen. Also nicht entmutigen
> lassen und weiter so.
> Das Serial.print() ist zwar nicht so schön wie ein Debugger um etwas zu
> verfolgen, hilft hier aber auch.

Nun ja, mein Projekt ist und bleibt eigentlich die Gehrungssäge.
Als ich mit der Idee anfing, habe ich mir zuerst die Säge konstruiert 
und gebaut.
Also "Steuerung" war der BL-Motor für die Säge ein DC-Motor für den 
Vortrieb und Endschalter, die per Relais die Richtung umschalten, also 
nix mit großartiger Elektronik, gedacht.
Dann gab es schon Probleme mit der Logik und den Relais.
Das Ganze schien im Aufwand aus dem Ruder zu laufen.
Ich bekam den Tipp, das mit dem Arduino zu lösen, ich hatte bis dato 
noch geglaubt, dass man solche Chips noch "brennen" muß, also nichts für 
Hobby.
Auch preislich war ich überrascht.
Da ich schon mal etwas vom "Programmieren" gehört habe, dachte ich, das 
kiegst du auch hin.
Zwangsläufig muß ich mich auch mit der "Arduino-Sprache" 
auseinandersetzen.
Dr. Google hilft da ungemein, beantwortet aber deine Fragen nicht.
Deshalb bin ich hier gelandet.

Ich möchte jetzt nochmal neu anfangen mit dem Programmieren.
Aus meiner Arbeit kenn ich das Programmieren so:
Ich schreibe alle Dinge, die sich wiederholen in ein label nach dem 
Programmende.
Aus dem Hauptprogramm heraus rufe ich die label bei Bedarf auf.
das geschieht mit "call label", dadurch gibt es einen Rücksprung hinter 
die Aufrufstelle.
In der Arduino-Referenz finde ich nur den goto-Befehl, kein Rücksprung, 
nicht außerhalb der Schleife.
Klar kann man das mit wiederum goto-Befehlen lösen, ist aber sehr 
aufwendig.
Ich möchte das so, wie es schon mal einer mit der Steuererklärung auf 
dem Bierdeckel machen wollte, schön klein und dadurch übersichtich (für 
mich).
Seht ihr da eine Möglichkeit.
Nicht gleich wettern, mit dem switch-case kann ich mich noch nicht 
anfreunden, da ich da mehrere Probleme sehe:
Wenn ich das richtig verstanden habe, bekommt die switch-Variable einen 
Wert zugewiesen, dann ein Sprung zum Vergleichswert im case und den Code 
dort ausführen. Anschließend geht`s nach break hinter dem switch-Befehl 
weiter.
Jetzt kann ich jedem case eine Funktion zuweisen. Z.B. BL-Motor an, 
BL-Motor aus, Schrittmotor vorwärts, Schrittmotor rückwärts, Starttaste 
gedrückt, u.s.w.
Ich muß aber jedesmal vorher die switch-Variable entsprechend zuweisen.
Starttaste hat aber z.B. 2 Funktionen.
Auch wird immer nur eine Funktion oder mehrere hintereinander, aber in 
der Reihenfolge ausgeführt.
Oder ich gebe jeder möglich Konstellation einen case und habe ein 
Programm, das nicht auf den Chip passt.
Einen Rücksprung zu Variablendefinition gibt es auch nicht.

Na gut, vielen Dank für die gut gemeinten Ratschläge.
Aber ich baue das Ganze jetzt konventionell, Schritt für Schritt auf. So 
komplex ist das Konstrukt nun wieder auch nicht.
Ich will am Anfang nicht gleich eine Rakete bauen, fange besser erstmal 
mit einem Papierflugzeug an. Es bringt nichts, wenn ich mich mit Dingen 
beschäftige, wo das Reindenken länger dauert, als einen ersten 
funktionierenden Code zu schreiben. Später kann man immer noch, wenn 
überhaupt nötig, optimieren, oder zusätzliche Funktionen einbauen.
Wie schon gesagt, mein eigentliches Projekt ist die Säge und nicht die 
Programmierung eines µC für dessen Steuerung.

So hier mal der ungetestete Code für das Anfahren des Schrittmotors Bis 
zum Endschalter.
Die delay`s sind gewollt, da ist auch die Maschine inaktiv.
An allen ausführenden Punkten habe ich eine Start/Stop-Tasterabfrage 
eingefügt.
Auch wenn keiner goto braucht, habe ich es hier verwendet, um aus dem 
laufenden Programm komplett rauszukommen und einen End-Code auszuführen.
Ein Neustart ist jeder Zeit möglich.
Was meint ihr dazu?

1

void loop() {

2

  if (Labelsprung == 1) goto Aus;

3

  if (digitalRead(StartPin) == LOW) { //wenn Starttaste gedrückt

4

    delay(1000); //Wartezeit um Doppelschaltung zu verhindern

5

    digitalWrite(DirPin, HIGH); //Richtung Endschalter

6

    for (StepTime = StepMin; StepTime >= StepMax; StepTime = StepTime - StepStepup) { //Schleife Hochtouren Schrittmotor

7

      Time = millis(); //akt. Zeit

8

      while (millis() <= Time + StepTime) { //Schleife Zeitablauf nächste Step

9

        if (digitalRead(StartPin) == LOW)goto Aus; //AUS

10

        if (millis() >= Time + StepTime) { //bei akt. Zeit = errechneter Schaltzeit

11

          digitalWrite(StepPin, !digitalRead(StepPin)); //StepPin umschalten

12

        }

13

      }

14

    }

15

    while (digitalRead(EndPin) == HIGH) { //Fahren Richtung Endschalter

16

      if (digitalRead(StartPin) == LOW)goto Aus; //AUS

17

      Time = millis(); //akt. Zeit

18

      while (millis() <= Time + StepTime) { //Schleife Zeitablauf nächster Step

19

        if (millis() >= Time + StepTime) { //bei akt. Zeit = errechneter Schaltzeit

20

          digitalWrite(StepPin, !digitalRead(StepPin)); //StepPin umschalten

21

        }

22

      }

23

    }

24

  }

25

26

  goto weiter;

27

Aus: {

28

    Labelsprung = 1;

29

    if (digitalRead(StartPin) == LOW) Labelsprung = 0;

30

    delay(1000);//Wartezeit um Doppelschaltung zu verhindern

31

  }

32

weiter: {}

33

}

S

STK500-Besitzer schrieb:
> Um Schleifen zu verlassen, verwendet man "break;" oder eine (weitere)
> Abbruchbedingung.

Ja aber auch nur aus der laufenden Schleife, oder ist das nicht so?. Ich 
möchte aber mit dem Aus-Schalter die Bearbeitung sofort abbrechen. Da 
erschien mir der Sprung zu Aus-label am schnellsten.

STK500-Besitzer schrieb:
> Dir ist nict zu helfen.

Ja leider!

Johannes S. schrieb:
> Die Starttaste würde ich nicht doppelt belegen, besser eine Stoptaste
> die in jedem Fall Stop macht und damit alle Bewegungen abbricht.

Schade, das Geld für eine 2.Taste wollte ich mir sparen. Ich muß doch 
jetzt schon an die Kosten denken, wenn ich in Großserie gehe;-)
Nun gut, wenigstens das leuchtet mir ein. Ich werde es überdenken, aber 
wenn`s hart auf hart kommt und ich habe 2 Tasten zur Auswahl, 
hoffentlich drücke ich in der Hektik dann die richtige. Ein 
Notausschalter in der Netzleitung ist auf jeden Fall geplant.

Johannes S. schrieb:
> nein, der Zustand ist in meinem Muster global und bleibt solange gesetzt
> bis er geändert wird.

Ich bin ganz ehrlich, dein Programm kann ich leider nicht nachvollziehen 
und das liegt gewiss nicht an dir.

Johannes S. schrieb:
> Wenn es gut werden soll startet man noch einen Überwachungstimer für die
> Fahrfunktion: Fehler, wenn der Enschalter nicht nach einer max. Zeit
> erreicht wurde.

Ja, Stück für Stück. Ich habe gemerkt, dass ich mit einem kompletten 
Programmcode aus der Hüfte nicht weit komme.

Johannes S. schrieb:
> Als Anfänger neigt man natürlich dazu alles in ein meterlanges main bzw.
> beim Arduino loop() zu Schreiben, aber sowas will keiner lesen.

Ja das habe ich gemacht und es funktioniert schon mal zufriedenstellen.

Johannes S. schrieb:
> Deshalb sofort angewöhnen mit Unterprogrammen zu strukturieren.

Das ist es, was ich auf der Arbeit in Label, dort nach dem 
Hauptprogramm, schreibe und diese aus dem Hauptprogramm bei Bedarf 
aufrufe. Toll, dass das
hier auch funktioniert.

Johannes S. schrieb:
> für den Anfang sollte man zumindest die von Arduino mitgelieferten
> Beispiele aus Control durchsehen und verstehen. Das sind die
> Standardkostrukte für Abfragen, Schleifen und Switch drin.

Wird gemacht!

Johannes S. schrieb:
> Im loop() wird dann einfach das Einlesen, Verarbeiten von Wartezeit und
> Zustand ausgeführt. Immer wieder im Kreis rum ohne anzuhalten.

So habe ich mir das auch gedacht.

Johannes S. schrieb:
> im Serial Monitor
> gibt s Ausgaben.

Da habe ich leider noch nicht verstanden, wie ich das nutzen kann.


Dein Code ist ziemlich umfangreich, aber ich glaube die Struktur zu 
erkennen.
Sehr schön!
und Danke

Johannes S. schrieb:
> Deshalb
> sofort angewöhnen mit Unterprogrammen zu strukturieren.

Eben das versuch ich gerade.
Ich habe jetzt für alle Funktionen ein eigenes void geschrieben.
Also:
SM-Motor hochtouren
SM-Motor fahren
SM-Motor abtouren
BL-Motor hochtouren
BL-Motor fahren
BL-Motor abtouren
Über if-Abfragen der Endschalter kann ich jetzt jeden nötigen Schritt 
ausführen.
Jetzt möchte ich über Interrupts den Starttaster als Ausschalter 
benutzen, den ESC über Interrupt alle -zig ms aktualisieren.
Bevor ich damit anfange, ist bis hierher alles richtig?

Johannes S. schrieb:
> Kann man über Ints machen, nur die Doppelbelegung Start/Stop würde ich
> nicht so machen. Das muss jedenfalls gut entprellt werden und EMV fest
> sein, nicht das die Säge losrennt wenn du Licht oder ein Gerät daneben
> einschaltetst.

Also genügt die delay-Zeit nach der Starttasterbetätigung wohl nicht zum 
Entprellen. Aber kann dieser ominöse EMV nicht jederzeit vorkommen?
Nun ich werde wohl einen separaten Aus-Schalter einzufügen.
Not-Aus zur Netzttrennung muß aber trotzdem sein!
Dann habe ich schon 3 Schalter. 1-2oder 3 letzte Chance...

Johannes S. schrieb:
> Die Servo Lib vom Arduino ist gar nicht schlecht, die arbeitet schon mit
> Interrupt und der Wert muss nicht in jedem Zyklus neu gesetzt werden.
> Und mit AccelStep gibt es eine gut Lib für SM, die läuft ebenfalls über
> HW Timer.

Wenn das so einfach ist, bediene ich mich dann mal ganz frech.

Johannes S. schrieb:
> Man muss nur aufpassen das sich die HW Resourcen nicht in die
> Quere kommen.

Du meinst, die beiden Pin`s, die ich für interrupt zur Verfügung habe?

Johannes S. schrieb:
> ja, nur Interrupts reagieren da schnell empfindlich. Keine lange Leitung
> dranmachen, und ext. RC Glied würde ich einsetzen. Bzw. sowieso lieber
> meine Polling Lösung. Über Polling vs. Ints gibts hier ja gerade mehrere
> Diskussionen...

Also Hardwareentprellung!

Johannes S. schrieb:
> nein, die HW Timer Resourcen. Wenn man nicht weiss wie die Libs intern
> arbeiten und die belegten Resourcen nicht dokumentiert sind kann die
> Kombination mehrerer Libs schief gehen. Versuch macht kluch, oder eben
> in die Internas gucken.

Ich habe gelesen, dass 2 interrupts auf meinem Arduniono Nano laufen 
müßten.
So würde ich den einen für den ESC und den anderen für den Stop 
verwenden.
Damit könnte ich das von `sid` angesprochene Überlaufproblem auch 
loswerden, indem ich wieder mit delay rummurkse und es mir einfach 
mache.
Da der interrupt auch hinter dem Delay läuft wäre eine Entprellung mit 
delay und Verwendung eines Tasters für Start/Aus sowieso sinnlos, also 
kommt nun endgültig ein 2. Schalter rein.

Ich möchte nach Schalten des Aus-Taster per interrupt ein Unterprogramm 
ausführen lassen. Nach dessen Abarbeitung springt das Programm an die 
Stelle der Unterbrechung zurück. Nun soll dort die loop-Schleife zum 
Start springen . Wie bewerkstelle ich so etwas?

Ich hatte mal wieder etwas Zeit und einen Code geschrieben. Es scheint 
ja wenigstens noch einen zu geben, der meine Beiträge liest(siehe 
Bewertungen), denn man kann ja erst bewerten, wenn man gelesen hat.
Hier meine neueste Murksversion:

1

#include "ESC.h"

2

#define SPEED_MIN 1000                        // Set the Minimum Speed in microseconds

3

#define SPEED_MAX 2000                        // Set the Minimum Speed in microseconds

4

#define DirPin  8                             //Dir Schrittmotor

5

#define StepPin 7                             //Step Schrittmotor

6

#define EndPin  6                             //Endschalter

7

#define AnfPin  5                             //Anfangsschalter

8

#define ESCPin  4                             //Motordrehzahl

9

#define StartPin  3                           //Starttaster

10

#define StopPin  2                            //Stoptaster

11

ESC BL (ESCPin, SPEED_MIN, SPEED_MAX, 1000);  //ESC_Name (ESC PIN, Minimum Value, Maximum Value, Default Speed, Arm Value)

12

int ESC;                                      //Variable for the speed sent to the ESC

13

int StepMin = 2000;                           //HIGH/LOW-Zeit min. Geschwindigkeit Schrittmotor

14

int StepMax = 600;                            //HIGH/LOW-Zeit max. Geschwindigkeit Schrittmotor

15

int StepStepup = 100;                         //Steigerung Rampe Schrittmotor Hochtouren

16

int StepStepdown = 1000;                      //Steigerung Rampe Schrittmotor Abtouren

17

volatile int StepTime ;                       //HIGH/delay Schrittmotor

18

int PinAbfr;                                  //abzufragender End/Anfangsschalter

19

volatile int StopStatus = 0;                  //Status Stoptaster

20

21

void setup() {

22

  pinMode (ESCPin, OUTPUT);                   //PIN ESC Motorspeed

23

  pinMode (DirPin, OUTPUT);                   //PIN Dir Schrittmotor

24

  pinMode (StepPin, OUTPUT);                  //PIN Step Schrittmotor

25

  pinMode (EndPin, INPUT_PULLUP);             //PIN Endschalter

26

  pinMode (AnfPin, INPUT_PULLUP);             //PIN Anfangsschalter

27

  pinMode (StopPin, INPUT_PULLUP);            //PIN Stoptaster

28

  attachInterrupt(0, AUS, LOW);               //PIN 2 StopPin interrupt aktiviert

29

}

30

31

void SM_Fahr() {                                      // Schrittmotor fahren bis End/Anfangsschalter, Unterbrechung bei Stoptaster

32

  StepTime = StepMin;

33

  StepTime = StepTime + StepStepup;

34

  while (StepTime <= StepMax) {                       //Schrittmotor beschleunigen

35

    if (StopStatus == 1)break;

36

    if (PinAbfr == HIGH) {

37

      digitalWrite(StepPin, !digitalRead(StepPin));   //StepPin umschalten

38

      delay(StepTime);

39

      StepTime = StepTime + StepStepup;

40

    }

41

  }

42

  if (PinAbfr == HIGH) {                              //Schrittmotor bis Schalter fahren

43

    digitalWrite(StepPin, !digitalRead(StepPin));     //StepPin umschalten

44

    delay(StepTime);

45

  }

46

  StepTime = StepMax;

47

  StepTime = StepTime - StepStepdown;

48

  while (StepTime >= StepMin) {                       //Schrittmotor abbremsen

49

    if (StopStatus == 1)break;

50

    digitalWrite(StepPin, !digitalRead(StepPin));     //StepPin umschalten

51

    delay(StepTime);

52

    StepTime = StepTime - StepStepdown;

53

  }

54

}

55

56

void BL_up() {//BL-Motor hochtouren

57

  for (ESC = SPEED_MIN; ESC <= SPEED_MAX; ESC += 1) { // goes from 1000 microseconds to 2000 microseconds

58

    if (StopStatus == 1)break;

59

    BL.speed(ESC);                                    // tell ESC to go to the oESC speed value

60

    delay(10);                                        // waits 10ms for the ESC to reach speed

61

  }

62

}

63

64

void BL_down() {//BL-Motor abtouren

65

  for (ESC = SPEED_MAX; ESC >= SPEED_MIN; ESC -= 1) { // goes from 2000 microseconds to 1000 microseconds

66

    if (StopStatus == 1)break;

67

    BL.speed(ESC);                                    // tell ESC to go to the oESC speed value

68

    delay(10);                                        // waits 10ms for the ESC to reach speed

69

  }

70

}

71

72

void AUS() {                                          //Unterbrechnung bei Stoptaster gedrückt (interrupt)

73

  BL.speed(SPEED_MIN);

74

  StopStatus = 1;

75

}

76

77

void ANFANG() {                                       //Fahr zur Anfangspos.(am Endschalter BL aus)

78

79

  PinAbfr = AnfPin;

80

  digitalWrite(DirPin, LOW);

81

  SM_Fahr();

82

  if (EndPin == LOW)BL_down();

83

}

84

85

void ENDE() {                                         //Fahr zur Endpos. (BL an)

86

  PinAbfr = EndPin;

87

  BL_up();

88

  digitalWrite(DirPin, HIGH);

89

  SM_Fahr();

90

}

91

92

void loop() {

93

  if (digitalRead(StartPin) == LOW) {//wenn Starttaste gedrueckt geht`s los

94

    if ((digitalRead(AnfPin) == HIGH) && (digitalRead(EndPin) == HIGH)) ANFANG();//wenn Anfangspos. nicht erreicht

95

    ENDE();

96

    ANFANG();

97

    StopStatus = 0;

98

  }

99

}

Ich ducke mich schon mal und hoffe auf reichlich Kritik.