# Ich find den Fehler nicht

Wie der Titel schon sagt,…
ich komm nicht weiter !
Koennt ihr mal einen Blick drauf werfen und mir eine kleine Hilfestellung geben ?

``````#define clockPoti A2
int ClockSpeed = 0;
unsigned long clockPrev = 0;

#define gatePoti A3
float gateLenght = 0;
unsigned long gatePrev = 0;

int gatePin = 13;
int greenLed = 12;
int clockIn = 7;

int stepCounter = 0;
bool firstRun = true;

#define STEPS_COUNT 8
int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};

void setup(){

pinMode(greenLed, OUTPUT);
pinMode(clockIn, INPUT);
pinMode(gatePin, OUTPUT);
clockPrev = millis();

Serial.begin(9600);

}

void loop(){

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();
}

if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
digitalWrite(gatePin, LOW);
}

if(gatePin == LOW && !firstRun) {
stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;

if(stepCounter < 8) {
loop();
}

else {
while(1);
}
}
}
``````

Die millis() Geschichte mit digitalWrite(gatePin) klappt wunderbar !
Nur hier scheine ich was falsch gemacht zu haben :

``````  digitalRead(gatePin);
if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
``````

Bitte um Fehlerbeschreibung. Grüße Uwe

``````    if(stepCounter < 8) {
loop();
}

else {
while(1);
}
``````

Was ist das denn? Keine Ahnung wie gut es ist, loop() innerhalb von loop() wieder rekursiv aufzurufen. Zumal unklar ist, was passiert, wenn Dein Programm mal nicht an dieser Stelle herauskommt, weil die Eingangsbedingung nicht erfüllt ist und dann der aktuelle Aufruf von loop() beendet wird und Du in der Rekursion wieder eine Stufe nach oben rutschst. Bzw. wenn die Endbedingung irgendwann erfüllt ist und die Funktion in der Endlosschleife hängen bleibt.

Als erstes wäre mal eine Beschreibung dessen was Dein Programm eingentlich machen soll hilfreich. Danach bitte eine Beschreibung was es macht und wie sich der Fehler äußert. Dann kann Dir hier sicher auch geholfen werden.
Mario.

mkl0815:

``````    if(stepCounter < 8) {
``````

loop();
}

``````

Was ist das denn? Keine Ahnung wie gut es ist, loop() innerhalb von loop() wieder rekursiv aufzurufen. Zumal unklar ist, was passiert, wenn Dein Programm mal nicht an dieser Stelle herauskommt, weil die Eingangsbedingung nicht erfüllt ist und dann der aktuelle Aufruf von loop() beendet wird und Du in der Rekursion wieder eine Stufe nach oben rutschst. Bzw. wenn die Endbedingung irgendwann erfüllt ist und die Funktion in der Endlosschleife hängen bleibt.
``````

ok,
erstmal hierzu was :
das ganze soll ein testlauf fuer eine funktion sein, die ich (wenn sie dann laeuft) in mein hauptprogramm einsetze.
deswegen auch der aufruf von loop();
spaeter hat die funktion natuerlich ihren namen. ich hab das ganze schon in einer abgespeckten version versucht und sie lief.
die else { while(1); } geschichte sollte mir nur zeigen das die funktion 8 mal durch laeuft und dann in der while schleife bleibt.

so, nun aber zu dem code.

dieser teil :

``````  ClockSpeed = analogRead(clockPoti);

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
digitalWrite(gatePin, LOW);
}
``````

ist meine clock, die mir die geschwindigkeit der blickintervalle und auch der blinkdauer vorgibt.
wie man im setup(); sieht, gibt es auch noch pinMode(clockIn, INPUT); da es spaeter auch noch die moeglichkeit geben soll ein externes triggersignal als clock zu nutzen. eigentlich geht der gatePin in den clockPin auf meiner schaltung. nur habe ich es der einfachheit und zur fehlersuche im ersten geposteten code geaendert.
dieser teil des codes scheint auch zu funktionieren da meine LED blinkt so wie soll.
nun kommt der 2te und neue teil :

``````  digitalRead(gatePin);
if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}

if(gatePin == LOW && !firstRun) {
stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;

if(stepCounter < 8) {
loop();
}

else {
while(1);
}
}
``````

wenn mein clocksignal HIGH ist, soll aus meinem blickrhythmus :

``````int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};
``````

wie im beispiel, stepsOn2 ausgefuehrt werden.
natuerlich soll die funktion 8 mal durlaufen werden um den kompletten rhythmus zu blinken.

stepsOff soll natuerlich ausgefuehrt werden wenn das clocksignal LOW ist.

ich hoffe, das ich es einigermaßen verstaendlich ruebergebracht habe und ihr versteht was ich erreichen will.
und entschuldigt die ae oe & ue’s. ich muss leider auf einem us-keyboard schreiben.

Wozu ist das "digitalRead(gatePin);" gut? gatePin ist als OUTPUT definiert. Das aber nur der vollständigkeit halber. desweiteren machst Du einen Vergleich "if(gatePin == LOW && !firstRun)" gatePin hat aber den Wert "13", denn diese Variable speichert nicht den Zustand sondern die Pin-Nummer von gatePin. Damit schlägt der Vergleich aber immer fehl, denn "13 != 0" Das Gleiche gilt natürlich auch für "if(gatePin == HIGH && firstRun)" Der Übersicht willen würde ich eine Variable "gateState" einführen die immer entweder auf HIGH oder LOW gesetzt wird und die dann mit digitalWrite(gatePin,gateState); setzen. Dann brauchst Du auch das digitalRead(gatePin) nicht mehr, denn ich vermute mal Du willst damit den aktuellen gesetzten Zustand ermitteln. Was evtl. sogar funktionieren könnte, dann aber maximal als "if(digitalRead(gatePin) == HIGH && firstRun)". Allerdings kann ich nicht sagen, ob das Lesen eines als Ausgang geschalteten Pins verläßlich ist.

Du hast uns immer noch nicht klar gesagt was das Teil eigentlich tun soll und was genau wie schief geht.

Ein Pin, das aus Augang definiert ist, kann man lesen und erhält den Ausgangszustand.

Des weiteren kann ich mich nochmal Udo anschließen. Ohne Infos was es machen soll und was schief läuft können wir Dir nicht effektiv helfen, sondern nur Sytaxfehler finden. Logikfehler können wir nicht finden, da wir nicht wissen was das Programm machen soll.

Willst Du unsere Hilfe oder sollen wir ein Ratespiel machen? ;) ;)

Grüße Uwe

ok, eigentlich dachte ich die beschreibung oben reicht,
aber ich versuche es noch mal :
das ganze soll mal ein sequencer fuer einen analog synthesizer werden.

das ist meine clock :

``````ClockSpeed = analogRead(clockPoti);

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
digitalWrite(gatePin, LOW);
}
``````

die mir die geschwindigkeit vorgibt und danach sollen spaeter verschiedene funktinonen ausgefuehrt werden.
wie zum beispiel der rhythmus :

``````int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};
``````

ich moechte eine funktion schreiben, das wenn die clock einen HIGH impuls am gatePin hat, diese ausfefuehrt wird.
in diesem fall soll zum beispiel : stepsOn2[STEPS_COUNT] durchlaufen werden. also muss die funktion 8 mal durchlaufen werden.
das habe ich versucht mit diesem teil zu loesen, was aber nicht klappt :

``````  digitalRead(gatePin);
if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}

if(gatePin == LOW && !firstRun) {
stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;

if(stepCounter < 8) {
loop();           // loop(); steht hier einfach fuer den funktionsnamen den die funktion spaeter mal hat
}
``````

das der rhythmus ausgefuert wird, soll mir die greenLed bestaetigen, die aber nichts macht.
die LED, die am gatePin haengt blinkt im clockrhythmus und funktioniert.
die greenLed sollte wenn es funktionierne wuerde im rhythmus von stepsOn2 blinken, also bei jedem 2ten HIGH impuls vom gatePin.
spaeter soll noch ein poti ausgelesen werden, welches bestimmt welcher rhythmus stepsOn1 bis stepsOn8 gespielt werden soll, aber das gehoert jetzt nicht hier hin.
erstmal muss ich es schaffen ,das greenLed funktioniert.

ich hoffe, ihr koennt damit mehr anfangen als mit der ersten beschreibung.
mario hat ja schon ein paar sachen gesagt und ich schau mal ob ich damit weiter komme.
aber ueber weitere tips waere ich euch auch sehr dankbar !

einen fehler hab ich schon mal gefunden. ich habe die geschweiften klammern falsch gestetzt :

``````  if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();
}

if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}
``````

es sollte wohl eher so aussehen :

``````  if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();

if(gatePin == HIGH && firstRun) {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}
}
``````

u.s.w

klar ist der inhalt des codes noch falsch aber auch um den werde ich mich noch kümmern.

noch ne frage zu marios :

``````digitalWrite(gatePin,gateState);
``````

setze ich damit nicht den gatePin gleich gateState ? müsste es nicht andersrum sein ?

``````digitalWrite(gateState, gatePin);
``````

damit gateState den wert von gatePin annimmt. ich frag nur, damit ich weitere fehler von vornherein vermeide und ausschließen kann.

Mit digitalWrite(PIN,VALUE) setzt Du den Wert an einem Pin, Du liest ihn nicht. gateState sollte in Deiner Anwendung je nach Sachlage entweder auf HIGH oder LOW gesetzt werden

``````gateState = LOW;
gateSTate=HIGH;
``````

Diese Variable repräsentiert den WERT den Dein Gate-Pin annehmen soll, nicht das gate-Pin selbst. Mit

``````digitalRead(gatePin);
``````

liest Du zwar den Wert von Pin 13 (da gatePin=13), allerdings speicherst Du ihn nirgendwo. "gatePin" ist der Parameter für die Funktion digitalRead der festlegt von welchem Pin gelesen werden soll. gatPin nimmt NICHT den gelesenen Wert an!

``````gateState = digitalRead(gatePin);
``````

Das würde der Variable gateState den aktuellen Zustand vom Pin 13 (gatePin) zuweisen.

Wie bereits geschrieben könntest Du den Vergleich aber auch gleich so schreiben:

``````if(digitalRead(gatePin) == HIGH && firstRun);
//oder
``````

Mario.

Wenn ich das richtig sehe hat er auch immer noch den aufruf loop() mit drinne. Soweit ich das verstehe ist das keine gute Idee.

so, ich hab das ganze jetzt geaendert :

``````#define clockPoti A2
int ClockSpeed = 0;
unsigned long clockPrev = 0;

#define gatePoti A3
float gateLenght = 0;
unsigned long gatePrev = 0;

int gatePin = 13;
int greenLed = 12;
int clockIn = 7;

int stepCounter = 0;
bool firstRun = true;

#define STEPS_COUNT 8
int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};

void setup(){

pinMode(greenLed, OUTPUT);
pinMode(clockIn, INPUT);
pinMode(gatePin, OUTPUT);
clockPrev = millis();

Serial.begin(9600);

}

void loop(){
rhythmus1();
}

void rhythmus1(){

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();

if(digitalRead(gatePin) == HIGH && firstRun); {
digitalWrite(greenLed, stepsOn3[stepCounter]);
firstRun = false;
}
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
digitalWrite(gatePin, LOW);

if(digitalRead(gatePin) == LOW && !firstRun); {
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;
}

stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
if(stepCounter < 8) {
rhythmus1();
}

else {
delay(2000);      // pause zum sehen, das die funktion 8 mal durchlaufen wurde
stepCounter = 0;

}
}
}
``````

funkioniert aber immer noch nicht so wie es sollte.
durch Marios erklaerung leuchtet jetzt schon mal die greenLed, aber ich habe das gefuehl, das mit meinem stepCounter = (++stepCounter); was nicht stimmt.
zur ueberpruefung hab ich mal

``````    Serial.print(stepCounter);
Serial.print(",");
``````

mitlaufen lassen .
es sieht so aus, als wuerde stepCounter nicht pro durchlauf der funktion rhythmus1 erhoeht, sondern sofort an ort und stelle.
da hab ich wohl falsch gedacht. ich dachte, das bei jedem durchlauf der funktion um 1 erhoeht wird.
mir fehlt einfach noch das verstaendniss des programmablaufes
ich nehme mal an, das ich mit den if-anweisungen da nicht weiter komme, da sie ja sofort eintreten wenn die bedingung wahr ist, oder ?

Warum rufst Du eingentlich die Funktion rythus1() wieder selsbt auf? Das ist das Gleiche wie vorher, nur das Du nun einen Schritt dazwischen hast (loop() ruft rythmus1() auf, das sich dann selbst aufruft)

loop() wird eh immer wieder aufgerufen, da musst Du nix für machen. Ohne Anspruch auf Gewähr würde ich einfach folgendes machen:

``````    if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}
``````

Wenn Deine Funktion rythmus1() durchgelaufen ist, springt das Programm zurück in die Funtion loop(). Da diese keine weiteren Anweisungen enthält, endet auch diese und wird sofort wieder aufgerufen. Damit wird dann auch wieder Deine Funktion rythmus1() aufgerufen. Was Du gebaut hast ist eine Rekursion, die nie zurückkehrt. Im schlimmsten Fall ist irgendwann der Stack voll, weil keine Rücksprungadressen mehr abgelegt werden können.

danke Mario fuer deine hilfe, aber leider laeuft es nicht.
ich hab es jetzt so geaendert :

``````#define clockPoti A2
int ClockSpeed = 0;
unsigned long clockPrev = 0;

#define gatePoti A3
float gateLenght = 0;
unsigned long gatePrev = 0;

int gatePin = 13;
int greenLed = 12;
int clockIn = 7;

int stepCounter = 0;
bool firstRun = true;

#define STEPS_COUNT 8
int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};

void setup(){

pinMode(greenLed, OUTPUT);
pinMode(clockIn, INPUT);
pinMode(gatePin, OUTPUT);
clockPrev = millis();

Serial.begin(9600);

}

void loop(){
rhythmus1();
}

void rhythmus1(){

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();

if(digitalRead(gatePin) == HIGH && firstRun); {
digitalWrite(greenLed, stepsOn3[stepCounter]);
firstRun = false;
}
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
digitalWrite(gatePin, LOW);

if(digitalRead(gatePin) == LOW && !firstRun); {
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;
}

stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
if (stepCounter < 8) {
rhythmus1();

if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}}
}
}
``````

ich habs auch noch mal so probiert, aber es ist das gleiche :

``````    stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");
//if (stepCounter < 8) {
// rhythmus1();

if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}}
// }
}
``````

stepCounter wird wohl nicht pro schleifen-durchlauf um einen erhoeht sondern zaehlt gleich durch bis 8.
ist auch durch Serial.print im monitor zu sehen :~

Das Dein stepCounter in einem Rutsch durchrauscht liegt an folgendem Code:

``````  if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
printstatus("gateChange erkannt");
digitalWrite(gatePin, LOW);

if(digitalRead(gatePin) == LOW && !firstRun); {
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;
}

stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");

if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}
}
``````

"if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght))" liefert ein TRUE, daher wird der Block abgearbeitet. Da Du in dem Block selbst aber nicht das "gatePrev" neu setzt, bleibt die Bedingung auch beim nächsten Durchlauf erfüllt. Der nächste Aufruf von loop() und damit von rhythmus1() springt dann wieder in dern gleichen Block. Da "firstRun" beim vorherigen Durchlauf aber schon auf true gesetzt wurde, ist die zweite Bedingung "if(digitalRead(gatePin) == LOW && !firstRun)" nicht mehr erfüllt (!firstRun), daher wird dieser innere Block ausgelassen. Dein stepCounter wird aber trotzdem erhöht, da er außerhalb des inneren Blocks steht. Daher sieht es für Dich so aus, als würde alles in einem Rutsch durchgezählt. Der erste if-Block Deines Programms wird auch ignoriert, da Dein gatePin immer noch auf LOW gesetzt ist und digitalRead(gatePin) == HIGH sein muss.

Versuch mal den Block so abzuändern:

``````  if((millis() - gatePrev)*1024 > (ClockSpeed * gateLenght)) {
gatePrev = millis();
digitalWrite(gatePin, LOW);

if(digitalRead(gatePin) == LOW && !firstRun); {
printstatus("gatePin LOW erkannt");
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;
}

stepCounter = (++stepCounter);
Serial.print(stepCounter);
Serial.print(",");

if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}
}
``````

Den rekursiven Aufruf habe ich rausgenommen, der ist wirklich unnötig.

Die Anweisung

``````  stepCounter = (++stepCounter);
``````

ist etwas merkwürdig. Das funktioniert zwar so, ist aber nur unnötig kompliziert.

Folgender Code reicht vollkommen aus:

``````  ++stepCounter;
``````

Rudi

klasse Mario, das funktioniert soweit ganz gut .... DANKE !

aber es gibt noch ein kleines problem. wenn ich gateLength verkuerze gibt es nur noch 4 blinker pro durchluf, noch kuerzer 2 blinker, ganz kurz 1 blinker :~ da muessen sich wohl irrgendwelche millis in die quere kommen.

so sieht das ganze jetzt aus :

``````#define clockPoti A2
int ClockSpeed = 0;
unsigned long clockPrev = 0;

#define gatePoti A3
float gateLength = 0;
unsigned long gatePrev = 0;

int gatePin = 13;
int greenLed = 12;
int clockIn = 7;

int stepCounter = 0;
bool firstRun = true;

#define STEPS_COUNT 8
int stepsOn1[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int stepsOn2[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn3[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn4[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};
int stepsOn5[STEPS_COUNT] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH,  HIGH};
int stepsOn6[STEPS_COUNT] = {HIGH, LOW,  HIGH, LOW,  HIGH, LOW,  HIGH,  LOW};
int stepsOn7[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  HIGH, LOW,  LOW,   LOW};
int stepsOn8[STEPS_COUNT] = {HIGH, LOW,  LOW,  LOW,  LOW,  LOW,  LOW,   LOW};

int stepsOff[STEPS_COUNT] =  {LOW,  LOW,  LOW,  LOW,  LOW,  LOW, LOW,   LOW};

void setup(){

pinMode(greenLed, OUTPUT);
pinMode(clockIn, INPUT);
pinMode(gatePin, OUTPUT);
clockPrev = millis();

Serial.begin(9600);

}

void loop(){
rhythmus1();
}

void rhythmus1(){

if((millis() - clockPrev) > ClockSpeed) {
clockPrev = millis();
digitalWrite(gatePin, HIGH);
gatePrev = millis();

if(digitalRead(gatePin) == HIGH && firstRun); {
digitalWrite(greenLed, stepsOn2[stepCounter]);
firstRun = false;
}
}

if((millis() - gatePrev)*1024 > (ClockSpeed * gateLength)) {
gatePrev = millis();
digitalWrite(gatePin, LOW);

if(digitalRead(gatePin) == LOW && !firstRun); {
//printstatus("gatePin LOW erkannt");
digitalWrite(greenLed, stepsOff[stepCounter]);
firstRun = true;
}

stepCounter = (++stepCounter);
Serial.print(gateLength);
Serial.print(",");

if(stepCounter >= 8) {
delay(2000);
stepCounter = 0;
}
}
}
``````

hab den fehler gefunden :)

``````if(!firstRun && ((millis() - gatePrev)*1024 > (ClockSpeed * gateLength)))
``````

da fehlte noch das !firstRun