Arduino friert während "while" loop ein

Moin,

ich versuche nun seit einigen Tagen mir mit meinen geringen Arduino-Kentnissen eine Schaltung für meinen Schrittmotor zu überlege.
Ich nutze einen Schrittmotor, der über zwei Lichtschranken gesteuert werden soll.
Wird die untere Lichtschranke ausgelöst, so soll der Motor laufen, bis die obere Lichtschranke ausgelöst wird. Ab dann soll der Motor wieder stehen bleiben, bis die untere Lichtschranke ausgelöst wird. Und dann wieder alles von vorne.
Ich bekomme zwar hin, dass der Motor anläuft, sobald jedoch die obere Lichtschranke ausgelöst wird, bleibt der Motor komplett stehen und auch der Serial Monitor gibt keine weiteren Werte aus.

Hier mein Code

// Initializing pins
const int pwr_a = 3;
const int pwr_b = 9;
const int dir_a = 2;
const int dir_b = 8;

const int STEPS = 2*200;      //total count of halfsteps per full rotation (*2 for half steps!)
                              // e.g. 1.8deg stepper => 200 steps => 400 halfsteps
int currStep = 0;             //current step, corresponds to angular position,  limits: 0...STEPS
int sub =0;                  //current halfstep within repeating sequence (8 halfsteps), limits: 0...7

int stepdelay_fast = 600;     //Wait time between steps (microseconds) - fast drive
int stepdelay_slow = 1000;    //Wait time between steps (microseconds) - slow drive

int sensorPin1 = A2;           // Input von Lichtschranke 1
int sensorPin2 = A5;           // Input von Lichtschranke 2           // negativ_input von 1
int sensorValue1 = 0;          // Startwert von sensorValue1, Lichtschranke 1 
int sensorValue2 = 0;         // Startwert von sensorValue2, Lichtschranke 2
int ledPin = 11;              // Pin an dem die LED ist;  





void setup()
{
  
  // Initialize the pins, in the correct type of mode.
    pinMode(pwr_a,OUTPUT);
    pinMode(pwr_b,OUTPUT);
    pinMode(dir_a,OUTPUT);
    pinMode(dir_b,OUTPUT);
    
    pinMode(ledPin, OUTPUT);
    Serial.begin(9600); 

    
}


void loop()
{
  int sensorValue1 = analogRead(sensorPin1);
  int sensorValue2 = analogRead(sensorPin2);
  Serial.println(sensorValue1);
  Serial.println(sensorValue2);




  if (sensorValue2<1022)
  { 
      subStep(20, stepdelay_slow);
  
  }
  while  ((sensorValue2 > 1022)&& (sensorValue1<1022)) 
  {
  TurnOfMotors();
  delay(10);
 

  }

Würde mich sehr über Hilfe und Anregungen zur Verbesserung meines Codes freuen!

Eigentlich brauchst Du while nicht, denn Du hast ja loop aber Du hast da auch eine klassische Endlosschleife gebaut.

Wenn Du in der Schleife die beiden Sensorwerte nicht neu einliest, bleibt die Bedingung immer erfüllt --> Endlos.

Gruß Tommy

Und warum nimmst du dafür eine "while-Schleife" ?

Eine if-Abfrage tut es sicher genau so.

Die blockiert dann deinen Sketch nicht.

(deleted)

Hab vergessen meinen ganzen Code zu teilen, der geht noch weiter. Dort wird unteranderem substep und TurnOfMotors definiert:

#include <Servo.h>

// Initializing pins
const int pwr_a = 3;
const int pwr_b = 9;
const int dir_a = 2;
const int dir_b = 8;

const int STEPS = 2*200;      //total count of halfsteps per full rotation (*2 for half steps!)
                              // e.g. 1.8deg stepper => 200 steps => 400 halfsteps
int currStep = 0;             //current step, corresponds to angular position,  limits: 0...STEPS
int sub =0;                  //current halfstep within repeating sequence (8 halfsteps), limits: 0...7

int stepdelay_fast = 600;     //Wait time between steps (microseconds) - fast drive
int stepdelay_slow = 1000;    //Wait time between steps (microseconds) - slow drive

int sensorPin1 = A2;           // Input von Lichtschranke 1
int sensorPin2 = A5;           // Input von Lichtschranke 2           // negativ_input von 1
int sensorValue1 = 0;          // Startwert von sensorValue1, Lichtschranke 1 
int sensorValue2 = 0;         // Startwert von sensorValue2, Lichtschranke 2
int ledPin = 11;              // Pin an dem die LED ist;  



Servo myservo;
int pos = 0;

void setup()
{
  myservo.attach(6);
  
  // Initialize the pins, in the correct type of mode.
    pinMode(pwr_a,OUTPUT);
    pinMode(pwr_b,OUTPUT);
    pinMode(dir_a,OUTPUT);
    pinMode(dir_b,OUTPUT);
    
    pinMode(ledPin, OUTPUT);
    Serial.begin(9600); 

    
}


void loop()
{
  int sensorValue1 = analogRead(sensorPin1);
  int sensorValue2 = analogRead(sensorPin2);
  Serial.println(sensorValue1);
  Serial.println(sensorValue2);




  if (sensorValue2<1022)
  { 
      subStep(20, stepdelay_slow);
  
  }
  if  ((sensorValue2 > 1022)&& (sensorValue1<1022)) 
  { 
  TurnOfMotors();
  delay(10);
  }
  analogRead(sensorPin1);
analogRead(sensorPin2);

 
   
    
  
      
   
}      
                   



void subStep(long steps, int stepDelay){

  // The function will run for the amount of times called in the method.
  // This is accomplished by a while loop, where it will subtract 1 from the amount after every run (forwards).
  // In case of backward rotation it will add 1 to the negative number of steps until 0 is reached.

    while(steps!=0)
        {

        if(steps>0){currStep++;}       //increment current halfstep (forward)
        if(steps<0){currStep--;}       //decrement current halfstep (backward)

        if(currStep>STEPS){currStep= currStep-STEPS;}         //position >360deg is reached => set position one turn back
        if(currStep<0){currStep= currStep+STEPS;}             //position <0deg   is reached => set position one turn forward

        sub = currStep%8;           //determine the next halfstep

        switch(sub)
        {
               case 0: 
        // Starting position (if repeated, ful step (4))
        // EXPLINATION: in this case, both our power are high.
        // Therefore both coils are activated, with their standard polarities for their magnetic fields.
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,HIGH);
        digitalWrite(dir_b,HIGH);
                break;

                case 1:
        //Half step (½)
        // EXPLINATION: In this case, only out b-coil is active, still with it's stand polarity.
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,LOW);
        digitalWrite(dir_a,HIGH);
        digitalWrite(dir_b,LOW);
                break;

        case 2:
                //Full step (1)
        // EXPLINATION: In this case, the b-coil is activated as in previous cases.
        // But the a-coil now has it's direction turned on. So now it's active, but with the reversered polarity.
        // By continuing this pattern (for reference: http://www.8051projects.net/stepper-motor-interfacing/full-step.gif) , you'll get the axis to turn.
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,HIGH);
        digitalWrite(dir_b,LOW);
                break;

        case 3:
        // Half step (1½)
        digitalWrite(pwr_a,LOW);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,LOW);
                break;

        case 4:
        // Full step (2)
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,LOW);
                break;

        case 5:
        // Half step (2½)
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,LOW);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,LOW);
                break;

        case 6:
        // Full step (3)
        digitalWrite(pwr_a,HIGH);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,HIGH);
                break;

        case 7:
        // Half step (3½)
        digitalWrite(pwr_a,LOW);
        digitalWrite(pwr_b,HIGH);
        digitalWrite(dir_a,LOW);
        digitalWrite(dir_b,HIGH);
                break;
         }

        delayMicroseconds(stepDelay);        //Waiting time to next halfstep

        if(steps>0){steps--;}      //decrement of remaining halfsteps of forward rotation
    if(steps<0){steps++;}      //increment of remaining halfsteps of backward rotation
    }
}


// This method simply just turn of the motors, called when ever we don't need the motors anymore.
// In this way, we won't fray the circuit or coils.
// Note 1: Motor has no torque anymore
// Note 2: If current position is between full steps, motor will move for a half step!
void TurnOfMotors(){
    digitalWrite(pwr_a,LOW);
    digitalWrite(pwr_b,LOW);
    digitalWrite(dir_a,LOW);
    digitalWrite(dir_b,LOW);
}

Wenn ich wie jetzt die zweite Schleife mit einem if aufbaue, bleibt der Motor zwar stehen, läuft aber sofort wieder an, sobald ich die Lichtschranke freigebe. Ich habe einfach keinen Ansatz, wie ich den Motor pausieren lassen kann, bis ich die obere Lichthschranke blockiere.

JAVOLL007: .... Ich habe einfach keinen Ansatz, wie ich den Motor pausieren lassen kann, bis ich die obere Lichthschranke blockiere.

Du musst die Aktion in einer Variablen zwischen speichern und dort in der Loop immer abfragen.

Sobald der Motor sein Ziel erreicht hat, diese Variable löschen.

Stichwort Statusvariable oder Finite State Machine. Merke Dir, wo Du gerade bist, die Lichtschranken ändern den Status und danach steuerst Du den Motor.

Gruß Tommy