[SOLVED]Flickering stepper, pur senza delay

Salve a tutti,``
è la prima volta che chiedo aiuto a voi tutti.
La presentazione mi pare di averla scritta qualche mese fa, spero di non commettere errori nel fare questo post =)

In pratica ho stampato in 3d e assemblato il mio primo prototipo di robottino.

Monta 2x stepper 28BYJ-48
2x ULN2003 driver motors
1x servo SR90
1x HC-SR04 sensore a ultrasuoni.

il codice da me scritto è il seguente:

#include <AccelStepper.h>
#include <NewPing.h>
#include <Servo.h>  

#define HALFSTEP 8

// 28BYJ-48 motor pins left
#define motorPin1  13     // IN1 on the ULN2003 driver 1
#define motorPin2  12     // IN2 on the ULN2003 driver 1
#define motorPin3  11     // IN3 on the ULN2003 driver 1
#define motorPin4  10     // IN4 on the ULN2003 driver 1

// 28BYJ-48 motor pins right
#define motorPin5  9      // IN1 on the ULN2003 driver 2
#define motorPin6  8      // IN2 on the ULN2003 driver 2
#define motorPin7  7      // IN3 on the ULN2003 driver 2
#define motorPin8  6      // IN4 on the ULN2003 driver 2

// HC-SR04 pins
#define triggerPin 2         // OUT Trigger on the HC-SR04 sencor
#define echoPin 3            // IN Echo on the HC-SR04 sencor

// Servo SG90 inizialization
Servo ServoMotor;            //Servo SG90

// variables for steppers
const unsigned int Steps = 1000;       // number of steps for a 90 degree turn
const unsigned int stepperSpeed = 1000;     //speed of the stepper (steps per second)

// variables for sensors
float Frontdistance = 0;             //initialize HC-SR04 sensor distances range
float Rightdistance = 0;
float Leftdistance = 0;

const unsigned int obstacledistance = 15;       //define obstacle distance to avoid
const unsigned int maxdistance = 100;        //define max distance to start ping (in cm)

// variables for movements
int target1 = 0;
int targetspeed1 = 0;
int target2 = 0;
int targetspeed2 = 0;

unsigned long tempo = 0;
unsigned long tempoold = 0;
unsigned int lookdirection = 0;
unsigned int Scaninterval = 2000;         //define delay between scan

unsigned int forwardCounter = 0;
unsigned int previusVal = 0;
const unsigned int randomTurn = 10;       //define steps multiplier untill random turn will be possible

// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
AccelStepper stepper2(HALFSTEP, motorPin5, motorPin7, motorPin6, motorPin8);

// Initialize HC-SR04 sensor pins and max distance
NewPing sonar(triggerPin, echoPin , maxdistance);

void setup() {
//  Serial.begin(115200);             // serial monitor initialize

  ServoMotor.attach(5);
  
  stepper1.setMaxSpeed(1000.0);
  stepper1.setSpeed(stepperSpeed);
  
  stepper2.setMaxSpeed(1000.0);
  stepper2.setSpeed(stepperSpeed);

  ServoMotor.write(80);

  randomSeed(analogRead(0));
}

void loop() {

  tempo = millis();

  if ((tempo - tempoold) >=  Scaninterval) {
    tempoold = tempo;
    
    switch (lookdirection) {
    case 0: 
      RightLook();
    break;
    case 1:
      FrontLook();  
    break;
    case 2:
      LeftLook();  
    break;
    case 3:
      FrontLook();  
    break;
    }
    
    if (lookdirection >= 3) {
      lookdirection = 0;
    }
    else {
      lookdirection = lookdirection +1;
    }
  }

  if ((tempo - tempoold) >=  (Scaninterval / 2) && (tempo - tempoold) <=  ((Scaninterval / 2) + 10)) {
    
  }
    switch (lookdirection) {
    case 0:   
      FrontScan(); 
    break;
     case 1:   
      RighttScan(); 
    break;
    case 2:   
      FrontScan(); 
    break;
    case 3:   
      LeftScan();  
    break;   
  }

//  Serial.print ("Front distance cm: ");                      //write on serial monitor distance in cm
//  Serial.print(Frontdistance);
//  Serial.println();
//  Serial.print ("Right distance cm: ");                      //write on serial monitor distance in cm
//  Serial.print(Rightdistance);
//  Serial.println();
//  Serial.print ("Left distance cm: ");                      //write on serial monitor distance in cm
//  Serial.print(Leftdistance);
//  Serial.println();
  
  if (stepper1.distanceToGo() == 0 && stepper2.distanceToGo() == 0) {

    target1 = 0;
    targetspeed1 = 0;
    target2 = 0;
    targetspeed2 = 0;
    
    if (Frontdistance == 0 ){
      if (Rightdistance == 0 && Leftdistance == 0){
        HardStraight();
        forwardCounter = forwardCounter +1;
      }
      else if (Rightdistance <= obstacledistance && (Leftdistance > obstacledistance || Leftdistance == 0)){
        SoftTurnLeft();
      }
      else if (Leftdistance <= obstacledistance && (Rightdistance > obstacledistance || Rightdistance == 0)){
        SoftTurnRight();
      }
      else if (Leftdistance <= obstacledistance && Rightdistance <= obstacledistance){
        SoftBack();
      }
      else{
        HardStraight();
        forwardCounter = forwardCounter +1;
      }
    }

    else if (Frontdistance > 5 && Frontdistance <= obstacledistance && Frontdistance != 0) {
      if (Rightdistance == 0 && Leftdistance == 0){
        HardTurnRandom();
      }
      else if (Rightdistance >= Leftdistance || (Rightdistance == 0 && Leftdistance != 0)) {
        HardTurnRight();
      }
      else if (Rightdistance < Leftdistance || (Rightdistance != 0 && Leftdistance == 0)) {
        HardTurnLeft();
      }
      else {
        SoftBack();
      }
    }

    else if (Frontdistance <= 5) {
      SoftBack();
    }

    else{
      HardStraight();
      forwardCounter = forwardCounter +1 ;
    }

    if (forwardCounter == randomTurn){
      int turnProbability = random(100);

      if (turnProbability <= 24){
        HardTurnRandom();
        forwardCounter = 0;
      }
      else if (turnProbability > 24 && turnProbability < 49){
        SoftTurnRandom();
        forwardCounter = 0;
      }
      else{
        forwardCounter = 0;
      }
    }

    if (previusVal == forwardCounter){
        forwardCounter = 0;
    }
    previusVal = forwardCounter;    
    
    stepper1.move(target1);
    stepper1.setSpeed(targetspeed1);
    stepper2.move(target2);
    stepper2.setSpeed(targetspeed2);
  }

  stepper1.runSpeedToPosition();
  stepper2.runSpeedToPosition();
}

void FrontLook() {
  ServoMotor.write(80);                 //Front servo
}

void RightLook() {
  ServoMotor.write(5);                  //Right Servo
}

void LeftLook() {
  ServoMotor.write(175);                 //Left servo
}


void RighttScan() {
  Rightdistance = sonar.ping_cm();               //detect echo in left direction and give cm as output
}

void LeftScan() {
  Leftdistance = sonar.ping_cm();               //detect echo in left direction and give cm as output
}

void FrontScan() {
  Frontdistance = sonar.ping_cm();               //detect echo in left direction and give cm as output
}


void HardTurnRight() {
      target1 = Steps*8;
      targetspeed1 = stepperSpeed;
      
      target2 = Steps*4;
      targetspeed2 = stepperSpeed/2;
}

void HardTurnLeft() {
      target1 = -Steps*4;
      targetspeed1 = stepperSpeed/2;
      
      target2 = -Steps*8;
      targetspeed2 = stepperSpeed;
}

void HardTurnRandom() {
  int randDir = random(100);
  if (randDir >= 49){
    HardTurnLeft();
  }
  else{
    HardTurnRight();
  }
}

void SoftTurnRight() {
      target1 = Steps*6;
      targetspeed1 = stepperSpeed;
      
      target2 = Steps*6/10;
      targetspeed2 = stepperSpeed/10;
}

void SoftTurnLeft() {
      target1 = -Steps*6/10;
      targetspeed1 = stepperSpeed/10;
      
      target2 = -Steps*6;
      targetspeed2 = stepperSpeed;
}

void SoftTurnRandom() {
  int randDir = random(100);
  if (randDir >= 49){
    SoftTurnLeft();
  }
  else{
    SoftTurnRight();
  }
}

void SoftStraight() {
      target1 = Steps/1.5;
      targetspeed1 = stepperSpeed/1.1;
      
      target2 = -Steps/1.5;
      targetspeed2 = stepperSpeed/1.1;
}

void HardStraight() {
      target1 = Steps;
      targetspeed1 = stepperSpeed;
      
      target2 = -Steps;
      targetspeed2 = stepperSpeed;
}

void SoftBack() {
      target1 = -Steps*6;
      targetspeed1 = stepperSpeed/1.1;
      
      target2 = Steps*6;
      targetspeed2 = stepperSpeed/1.1;
}

Il difetto che riscontro è che pur non essendoci delay, i motori non risultano fluidi durante il funzionamento.
Ho provato con sketck piu’ semplici per testare la libreria acelstepper.h e i motori arrivano a 1000 (maxspeed) in modo fluido, mentre se eseguo questo sketch funzionano apparentemente da schifo.

Qualcuno saprebbe spiegarmi dov’e’ il mio problema ?

Grazie,
scrivete se servono ulteriori chiarimenti.

Saluti

Se fai una ricerca qui sul forum, se ne è parlato poco tempo fa ... ... da quello che ricordo è che alcuni metodi della libreria AccelStepper sono "bloccanti" e quindi ... non viene eseguito null'altro sino al temine del metodo chiamato.

Devi guardare bene la documentazione della libreria.

Guglielmo

Risolto, era un problema Hardware, non software, inquanto l'assorbimento inizialmente era troppo alto. Non credevo che un semplice servo assorbisse tanto!!! Ho separato i circuiti di alimentazione et voila!

@gpb01: In effetti questo e' stato un problema che mi sono trovato ad affrontare, ma con l'istruzione stepperX.runSpeedToPosition(); non è bloccante! =)

Muplex: In effetti questo e' stato un problema che mi sono trovato ad affrontare, ma con l'istruzione stepperX.runSpeedToPosition(); non è bloccante!

Ottimo a sapersi per ... eventuali utenti futuri :)

Guglielmo