Schrittmotor mit L298N Dual-H-Brücke ansteuern und über Pott Drehzahl einstellen

Guten Abend sehr geehrtes Forum,

ich habe ein Problem mit der Potentiometer Einstellung, sodass ich keine richtige Änderung der Umdrehung erhalte.
Die Verkabelung stimmt auch soweit nur der Pott speilt nicht mit wenn ich selber die rpm über das Setup einstelle funktioniert alles nur ich möchte es jetzt über eine Poti steuern. Der Code.
Motor hat 1,8° pro schritt.
L298N Brücken Treiber wird verwendet und ein 10k Ohm Pott.

// Include the Arduino Stepper Library
#include <Stepper.h>

// Anzahl der zu gehenden Schritte um eine Umdrehung zu erlangen 
const int stepsPerRevolution = 200;


Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);


void setup()
{
  // set the speed at 60 rpm:
  //myStepper.setSpeed(100);
  // initialize the serial port:
  Serial.begin(9600);
}

void loop() 
{
  sensorReading = analogRead(A0); 
  int motorSpeed = map(sensorReading, 0, 1023, 0, 200);
   if (motorSpeed > 0) // Geschwindigkeit einstellen
   {
    myStepper.setSpeed(motorSpeed);
    // step 1/100 of a revolution:
   myStepper.step(stepsPerRevolution / 100);
   }
  
  // step one revolution in one direction:
  //Serial.println("clockwise");
  //myStepper.step(stepsPerRevolution);
  //delay(500);

Serial.print(sensorReading);

  // step one revolution in the other direction:
 // Serial.println("counterclockwise");
  //myStepper.step(-stepsPerRevolution);
 // delay(500);
}

Zudem habe ich mir den code aus dem Internet zusammengebastelt, und bin ein Anfänger in Sachen Arduino.

Hast Du schon mal die Beispiele zur Arduino Stepper Bibliothek ausprobiert?
Und die AccelStepper Bibliothek und Beispiele?
Und die Serial Ausgaben drastisch reduziert?
Und überprüft, ob Dein Stepper nicht ein richtiges Stepper Treiber Modul braucht, und vielleicht mehr Spannung?

Ohne Schaltbild und Datenblätter zum Motor und Angaben zur Stromversorgung und zur Last ist alles nur Stochern im Nebel.

Der Schrittmotor ist ein NEMA 17-01 mit 2,8V und 1,68A und 0,4Nm Haltemoment.

Die Spannung stelle ich ein mehr oder weniger macht nichts aus nur das der Treiber mindestens 6V braucht Der Arduino ist über Wir über den USB versorgt, Treiber und Motor werden extern versorgt mit 12V

Hi

Es ist nicht erkennbar, wie Du das Poti angeschlossen hast - meine Vermutung: Du benutzt nur zwei der drei Anschlüsse - weshalb der Arduino durchgehend LOW oder HIGH sieht - egal, wie das Poti steht.

MfG

PS: Der L298 bietet KEINE Strombegrenzung - Der kann NUR Durchschalten, oder eben nicht.
Bei einem stromgesteuerten Motor ist Das ... nicht sonderlich toll!
In Verbindung mit einem L297 und Sense-Widerständen kannst Du Das erreichen - aber zur heutigen Zeit gibt's wesentlich bessere Treiber, Die Das bereits 'unter der Haube' haben.

Die äusseren Anschlüsse des Poti habe ich an das + und - des breatboard angeschlossen den mittleren Anschluss an den A0 Pins des Arduino

Grüße
Mika

Bei Breadboard Aufbauten lohnt es sich, die Spannungen ab und zu nachzumessen, besonders wenn etwas nicht so funktioniert wie es eigentlich sollte.

diese a4988 Schrittmotor Treiber für 4euro
sind für reine Drehzhl bestens geeignet da Diese via PWM eine beachtlichen Speed bieten
und gerade deswegen in Robotern Einsatz finden

Die Stepperbibliothek des Arduino ist blockierend, d.h. während sich der Motor dreht geht nichts anderes, also auch kein Einlesen des Poti. Du kannst entweder die Accelstepper, oder meine MobaTools verwenden ( Beides über den Bibliotheksverwalter installierbar ).
Wie schon geschrieben wurde ist der Motor für Stromsteuerung ausgelegt, und das funktioniert mir dem L298 alleine nicht. Das passt nicht zusammen. Du brauchst einen Steppertreiber wie den A4988 oder den DRV8825.
Welches Arduino-Board setzt Du überhaupt ein?

Das Problem mit den blockierenden Libs für Steppermotoren hatte ich ebenfalls gehabt.
Ich habe mir damit beholfen, daß ich den Timer 2 zu Fuß programmiert habe.

So schwer ist das nicht. Man muss nur darauf achten, den Step-Anschluss des Treibers an den richtigen Pin des Arduino anzuschließen. (In meinem Fall mit einem Nano an D11)
Aber das geht nur mit einem Treiber wie dem A4988 oder dem DRV8825.

Hier mal ein einfaches Beispiel:

#define DIR 10        // Ausgang Richtung
#define STEP 11       // Ausgang OCR2A Takt für Stepper
#define ENA 12        // Ausgang Enable

void setup() {
    TCCR2A = 66;      // Timercontrolregister 2A Mode Toggle on OutputCompareMatch  CTC-Mode
    pinMode (ENA, OUTPUT);       // Enableausgang
    pinMode (STEP, OUTPUT);      // AUsgang für Takt
    pinMode (DIR, OUTPUT);       // Ausgang für Drehrichtung
}


void loop() {

startMotor(true, 50);         // Motor starten, rechtslauf
delay(5000);
stopMotor();                     // Motor stoppen
delay(5000);
startMotor(false,50);         // Motor starten, linkslauf
delay(5000);
stopMotor();                     // Motor stoppen
delay(5000);              
}


void startMotor (bool dir, byte spd){         // Funktion zum Starten des Motors
  setSpd(spd);                                         // Geschwindigkeit einstellen
  digitalWrite (DIR, dir);                            // Drehrichtung einstellen
  digitalWrite (ENA, true);                         // Enable einschalten
  TCCR2B = 5;                                         // Prescaler auf 128
}

void stopMotor(){                                    // Funktion zum Stoppen des Motors
  TCCR2B = 0;                                         // Timer ausschalten
  digitalWrite (ENA, false);                        // Freigabe ausschalten
}

void setSpd(byte spd){                            // Funktion zum Einstellen der Geschwindigkeit
    OCR2A = byte_spd;                             // Geschwindigkeit in Outputcompareregister schreiben
}

Anfahrrampen muss man hierbei natürlich zu Fuß programmieren.
Aber so läuft der Schrittmotor ohne weiteres Zutun.
Schritte zählen geht hiermit auch nur sehr begrenzt. Dazu muss man dann den Timerinterrupt aktivieren und bei jedem Overflow einen Zähler inkrementieren oder dekrementieren.

Frank501:
Das Problem mit den blockierenden Libs für Steppermotoren hatte ich ebenfalls gehabt.

Nur die bei der IDE mitgelieferte Lib blockiert grundsätzlich. Warum also nicht eine der nicht blockierenden Lib's verwenden? Die haben Anfahr- und Bremsrampen und können auch die Steps ordentlich zählen. Man muss nicht alles selbst machen - es bleibt auch so noch genug zu tun :wink:

Guten Morgen liebes Forum,

vielen Dank für die vielen Antworten einen A4988 Treiber habe ich vorhanden und davor auch benutzt und bin dann auf die Brücke übergegangen. Ich hatte aber enorme Probleme mit dem Poti und zwei Kippschaltern da hat nämlich garnichts mehr gedreht. Ich Schließe wieder den A4988 Treiber an und melde mich da habe ich auch einen Code schon zu geschrieben jedoch hat dort der Poti Funktioniert nur nich so ganz wie gewollt da der Motor nur am vibrieren war, und als dann die Kippschalter angeschlossen wurden für die Richtungsumkehr ging garnichts mehr. Dann bis nachher.

Viele Grüße
Mika

So ich habe umgesteckt auf den A4988 Treiber nach dem Bild im Anhang dazu will ich jetzt ein 10k Ohm Poti anschließen der jetzt nicht auf dem Bild ist an den A0 Pin den Mittleren Anschluss und die zwei äusseren an plus und minus.

Mien Code

/*Example sketch to control a stepper motor with A4988 stepper motor driver and Arduino without a library. More info: https://www.makerguides.com */
// Define stepper motor connections and steps per revolution:


#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

#include <LiquidCrystal.h> // Bibliothek für LCD

/* Create object named lcd of the class LiquidCrystal */
//LiquidCrystal lcd(13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3);  /* For 8-bit mode */
LiquidCrystal lcd(13, 12, 11, 6, 5, 4, 1);  /* For 4-bit mode */

unsigned char Character1[8] = { 0x04, 0x1F, 0x11, 0x11, 0x1F, 0x1F, 0x1F, 0x1F }; //Obere Ebene -
unsigned char Character2[8] = { 0x01, 0x03, 0x07, 0x1F, 0x1F, 0x07, 0x03, 0x01 }; //Unter Ebene des Displays

int customDelay;
int Einstellung;
int Poti;

int WechselStatus;

/*--------------------------------------SETUP---------------------------------------------*/
void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(A1, INPUT);

  lcd.begin(16,2); /* Initialize 16x2 LCD */
  lcd.clear();  /* Clear the LCD */
  lcd.createChar(0, Character1);  /* Generate custom character */
  lcd.createChar(1, Character2);
}

/*-----------------------------------------------LOOP-------------------------------------*/
void loop() {
/*-----------------------------------------------LCD--------------------------------------*/  
  lcd.setCursor(0,0);  /* Set cursor to column 0 row 0 */
  lcd.print(Poti); /* Print data on display */
  lcd.setCursor(0,1);  
  lcd.print(Einstellung);/* Write a character to display */
  lcd.setCursor(5,1);
  lcd.print(WechselStatus);
  lcd.setCursor(5,0); 
  lcd.print("1/min");
/*--------------------------SCHRITTMOTOR-----------------------------------------------*/
  

     WechselStatus = analogRead(A1);
     Poti = analogRead(A0); // Reads the potentiometer
     Einstellung = map(Poti, 0, 1023, 0,1000); // Converts the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)



    //if(WechselStatus == LOW){

    digitalWrite(dirPin, LOW);                       /*Wenn dirpin HIGH=gegen Uhrzeigersinn und LOW=im Uhrzeigersinn*/
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
    //}
    
    //if(WechselStatus == HIGH){
    
    //digitalWrite(dirPin, HIGH);                       /*Wenn dirpin HIGH=gegen Uhrzeigersinn und LOW=im Uhrzeigersinn*/
    //digitalWrite(stepPin, HIGH);
    //delayMicroseconds(Einstellung);
    //digitalWrite(stepPin, LOW);
    //delayMicroseconds(Einstellung);
      //}
        
     

      

}

mich würde auch Interessieren wofür genau die "delayMicroseconds" Funktion steht ?

mzumika:
mich würde auch Interessieren wofür genau die "delayMicroseconds" Funktion steht ?

Das sollte eigentlich selbsterklärend sein. Einfach mal den Namen übersetzen

Ansonsten in die Referenz schauen:

In deinem Sketch bestimmen die 'delayMicroseconds' wie schnell sich der Motor dreht, d.h. wie schnell die Stepimpulse erzeugt werden. Wenn Du das von der Potistellung abhängig machen willst, musst Du also diese delay-Werte je nach Potiwert ändern.

Hi

Sollen wir Ihn wirklich auf das tote Pferd aufsteigen lassen?
Da kann Er auch bei den Beispielen aus der IDE bleiben ... ob delay() oder delaymicroseconds() ...

MfG

Damit kann er zumindest mal seine HW testen - mehr dann wohl eher nicht.

MicroBahner:
Nur die bei der IDE mitgelieferte Lib blockiert grundsätzlich. Warum also nicht eine der nicht blockierenden Lib's verwenden? Die haben Anfahr- und Bremsrampen und können auch die Steps ordentlich zählen. Man muss nicht alles selbst machen - es bleibt auch so noch genug zu tun :wink:

Ich habe mehrere Libs ausprobiert, die angeblich alle nicht blockierend sein sollten.
Aber sowie irgend etwas rechen- oder zeitintensives im Loop läuft, schwankt die Drehzahl oder es treten andere Seiteneffekte auf.

Natürlich muss man, wenn man einen Stepper so "unkontrolliert" laufen lässt, etwas aufpassen, daß im Interrupt die Schritte auch ordentlich gezählt werden, aber wenn man weiß, was man tut, ist das eine schlanke und effektive Ansteuerung.

Für Anfänger, die erst mal lernen wollen, zu programmieren, sind die Libs aber eine einfache und effektive Möglichkeit, schnell zum Erfolg zu kommen.

Frank501:
Ich habe mehrere Libs ausprobiert, die angeblich alle nicht blockierend sein sollten.
Aber sowie irgend etwas rechen- oder zeitintensives im Loop läuft, schwankt die Drehzahl oder es treten andere Seiteneffekte auf.

Dann hast Du etwas falsch gemacht. Bei der Accelstepper muss man da gegebenenfalls etwas aufpassen. Meinen MobaTools ist es schlichtweg egal, was Du im loop machst - solange Du nicht die Interrupt sperrst.

Hi

Wobei die AccelStepper wohl eine höhere Taktrate hinbekommen könnte - je nach Laufzeit von loop().
Die ist bei Dir durch den Timer eher begrenzt. (wobei ich mir Deine Lib noch nicht sooo genau angeschaut habe)

MfG

Bei der AccelStepper hängt die Taktrate in der Tat von loop() ab. Auf einem AVR braucht eine Step-Berechnung ca. 200µs. Also etwa 5000 Steps/sec wenn in loop() sonst nichts anderes passiert. Bei einem 2. Motor wirds dann schon kritisch - wenn beide sehr schnell laufen sollen, beeinflussen sie sich.
Die aktuellen MobaTools schaffen 2500 Steps/sec. Allerdings unabhängig von loop, und gegebenenfalls auch für mehrere Motore gleichzeitig.
Der große Vorteil der AccelStepper ist natürlich, dass sie HW unabhängig geschrieben ist. Auf schnelleren Prozessoren geht's auch schneller.
Die MobaTools muss ich für jede Plattform portieren. Aktuell geht AVR und STM32F1, ESP8266 ist in Arbeit (fast fertig).

Letztendlich hängt es vom Anwendungsfall ab, was besser ist. Insofern hilft die Info vielleicht auch dem TO.