StappenMotor en Arduino

Arduino Bootloader

Release status: Tutorial

Description	StappenMotor en Arduino
License	GPL
Author	Harry H. Arends
Contributors
Based-on	unknown
Categories
CAD Models	none
External Link	ARDUINO

Inleiding

In deze tutorial leren we alles wat we moeten weten over het aansturen van stappenmotoren met Arduino. Daarbij bespreek ik hoe u een NEMA17 stappenmotor kunt aansturen in combinatie met een A4988 of een DRV8825 en een stappenmotor.

Deze combinatie van stappenmotor en driver wordt gebruikt in talloze toepassingen waar positiecontrole nodig is, zoals 3D-printers, CNC-machines, robotica, rotoren enzovoort.

Ik zal in detail proberen uit te leggen hoe ze werken, hoe je stappenmotoren met een Arduino verbindt, hoe je de stroomlimiet van een driver insteld. Ik zal je ook laten zien hoe we eenvoudig meerdere stappenmotoren kunnen besturen met behulp van een Arduino.

We hebben dus heel wat te behandelen in deze tutorial. Deze tutorial bevat alle voorbeeldcodes en bedradingsschema's.

Wat is een stappenmotor en hoe werkt deze?

Ik zal beginnen met een korte uitleg van wat een stappenmotor is en hoe deze werkt, omdat dit ons zal helpen al het andere in deze tutorial beter te begrijpen.

Een stappenmotor is een uniek type borstelloze gelijkstroommotor(BLDC) waarvan de positie zelfs zonder enige feedback nauwkeurig kan worden geregeld.

Het werkingsprincipe van een stappenmotor is, zoals bij alle motoren, gebaseerd op magnetische velden. Het heeft twee hoofdcomponenten, een stator en een rotor. De rotor is meestal een permanente magneet en is omgeven door enkele spoelen op de stator.

Wanneer we de spoelen bekrachtigen door er spanning en laten stromen, worden er in de stator bepaalde magnetische velden gegenereerd die de rotor aantrekken of afstoten. Door de spoelen stap voor stap, de een na de ander, in een bepaalde volgorde te activeren, kunnen we een voortdurende beweging van de rotor bereiken, maar we kunnen hem ook op elke positie laten stoppen.

Daarom worden deze motoren stappenmotoren genoemd: ze bewegen in discrete stappen. Door het aantal magnetische polen op de rotor te vergroten, kunnen we het aantal mogelijke stopposities vergroten, waardoor de resolutie of de precisie van de motor toeneemt. Houd er rekening mee dat dit slechts een basisuitleg is en dat u meer details kunt vinden in mijn tutorial Hoe stappenmotoren werken.

Een typische stappenmotor, één van het type NEMA17 bijvoorbeeld, heeft 50 stoppunten of stappen op de rotor. Aan de andere kant kan de stator meerdere spoelen hebben die in twee fasen zijn georganiseerd en die vier verschillende magnetische veldoriëntaties of -posities bieden.

Dus de 50 stappen van de rotor vermenigvuldigd met de 4 verschillende magnetische veldoriëntaties, oriëntaties, maak in totaal 200 stappen voor het voltooien van een volledige rotatie. Of als we 360 ​​graden delen door 200 stappen, dan is dat een resolutie van 1,8 graden per stap.

Ik zei al dat de statorspoelen in twee fasen zijn georganiseerd, en dat kunnen we ook opmerken als we kijken naar het aantal draden van een stappenmotor. Het heeft vier vier draden, twee voor elke fase. De vier verschillende magnetische veldoriëntaties zijn mogelijk omdat we stroom in beide richtingen door de fasen kunnen laten stromen.

Er zijn ook stappenmotoren met 5, 6 of zelfs 8 draden, maar die werken nog steeds op twee fasen of we sturen ze aan met slechts vier klemmen.

6-Draads Bipolaire configuratie

8-Draads Bipolaire configuratie

Het probleem met hen is dat ze verschillende prestatiekenmerken kunnen bieden, zoals meer koppel of meer snelheid, afhankelijk van hoe we deze draden op de vier stuurklemmen aansluiten.

Niettemin begrijpen we nu met deze korte uitleg dat we voor het aandrijven van een stappenmotor er niet zomaar stroom op kunnen aansluiten, omdat er dan niets zal gebeuren. In plaats daarvan moeten we de twee motorfasen in beide richtingen bekrachtigen en in een bepaalde volgorde pulsen activeren of sturen. Daarom hebben we drivers nodig voor het aansturen van stappenmotoren.

Er zijn vele soorten en maten drivers, passend bij de vele soorten en maten stappenmotoren. Het fundamentele werkingsprincipe van ze allemaal is echter dat ze twee H-bruggen hebben die het mogelijk maken de motorfasen in beide richtingen te bekrachtigen (H-Bridge).

Natuurlijk hebben deze drivers nog veel meer functies, zoals micro-stepping, stroombegrenzing, enzovoort, waarmee we de stappenmotoren gemakkelijk kunnen besturen, wat het hele doel ervan is.

Hoe een NEMA17 stappenmotor te besturen met Arduino en A4988 driver

Oké, nu kunnen we het eerste voorbeeld voor deze tutorial bekijken, hoe je een NEMA 17 stappenmotor bestuurt met een A4988 driver.

De NEMA17 is de populairste stappenmotor onder makers, omdat hij geweldige prestaties levert en tegelijkertijd betaalbaar is. Het is ook te vinden in vrijwel elke desktop 3D-printer en lasergraveerder. Over het algemeen heeft de NEMA17 stappenmotor 200 stappen, oftewel 1,8 graden per stap resolutie, maar er zijn ook modellen met 400 stappen en 0,9 graden per stap resolutie. We moeten hier opmerken dat de aanduiding NEMA17 eigenlijk alleen de grootte van de motor beschrijft in termen van de grootte van de voorkant.

Het getal staat voor de grootte van de frontplaat in inches gedeeld door 10, of in dit geval is dat 17 gedeeld door 10, wat gelijk is aan 1,7 inch frontplaat, of 2,3 inch frontplaat in het geval van NEMA23.

De afmeting van de frontplaat ligt dus vast, maar de lengte van de NEMA17-stappenmotoren kan variëren van 20 mm tot 60 mm, en daarmee varieert ook de vermogensbehoefte van de motor. Het stroomvereiste wordt meestal bepaald door hoeveel stroom de motor mag trekken, en het bereik voor deze NEMA17 stappenmotoren is van 0,3A tot 2,5A. Nu moeten we, afhankelijk van de stroomsterkte van de stappenmotor, een geschikte driver kiezen die die hoeveelheid stroom aankan. De meest populaire driverbesturing voor NEMA17-stappenmotoren is de A4988-stappenmotordriver.

De A4988 heeft een maximale stroomsterkte van 2A per spoel, maar dat is eigenlijk een piekwaarde. Het wordt aanbevolen om de stroom rond de 1A te houden, maar het is natuurlijk ook mogelijk om tot 2A te gaan als er voor een goede koeling van het IC wordt gezorgd.

Een geweldige functie van de A4988 stappenmotor, die eigenlijk alle andere schijven hebben, is de stroombegrenzing. Hiermee kunnen we eenvoudig instellen hoeveel stroom de motor zal trekken, ongeacht het motorvermogen. We kunnen bijvoorbeeld zelfs een stappenmotor van 2,5 A aansluiten, maar we beperken de stroom van de driver tot 1,5 A. Dus hoewel de motor niet op zijn maximale capaciteit werkt, zouden we hem nog steeds kunnen gebruiken.

Aan de andere kant, als de motor een lager nominaal vermogen heeft dan de ingestelde stroomlimiet op de driver, zou de motor oververhit raken. Het is uiteraard altijd aan te raden om te proberen de stroomwaarde van de motor af te stemmen op de stroomwaarde van de besturing.

A4988 en Arduino-verbinding

Oké, laten we nu eens kijken hoe we de A4988-driver kunnen verbinden met de stappenmotor en de Arduino-controller.

In de rechterbovenhoek van de driver hebben we de VMOT- en GND-pinnen en hier sluiten we de voeding voor de motor aan, die 8 tot 36V kan bedragen. Hier wordt ook aanbevolen om een ​​ontkoppel-condensator over deze twee pinnen te gebruiken om de printplaat tegen spanningspieken te beschermen. We moeten een grote elektrolytische condensator gebruiken met een capaciteit van minimaal 47uF.

Vervolgens zijn de vier pinnen waarop we de stappenmotor aansluiten. De ene fase van de motor gaat op 1A- en 1B-pinnen, en de andere fase op 2A- en 2B-pinnen.

Soms kan het lastig zijn om te herkennen welke twee draden van de motor een fase vormen, maar er zijn verschillende manieren om ze te identificeren. De eenvoudigste manier is om de as van de stappenmotor met de hand te draaien en vervolgens twee draden met elkaar te verbinden. Als je twee draden aansluit die een fase vormen, wordt de rotatie van de as iets moeilijker. [[]] Een andere manier is om een ​​multimeter te gebruiken en te controleren op continuïteit tussen de twee draden. Als je twee draden aansluit die een fase vormen, ontstaat er kortsluiting en begint de multimeter te piepen. [[]] Zodra we een fase hebben gevonden, kunnen we deze verbinden met elke positie van de twee posities op de A4988, de volgorde doet er niet toe.

Vervolgens hebben we de IC of de logische voedingspinnen, VDD en GND, die van 3V tot 5V kunnen zijn. Aan de andere kant hebben we de Step- en Direction-pinnen, die op elke pin van het Arduino-bord kunnen worden aangesloten. Met de Direction-pin selecteren we de draairichting van de motor, en met de Step-pin regelen we de stappen van de motor. Met elke puls die we naar de Step-pin sturen, gaat de motor één stap vooruit in de geselecteerde richting.

Direct boven deze pinnen hebben we de Sleep- en Reset-pinnen die worden gebruikt om, zoals hun naam doet vermoeden, de A4988 in de slaapmodus te zetten of te resetten. We moeten er rekening mee houden dat beide pinnen laag actief zijn. De slaappin is standaard HOOG, maar de RST-pin zweeft. Dat betekent dat, om het stuurprogramma ingeschakeld te hebben, de eenvoudigste manier is om deze twee pinnen gewoon met elkaar te verbinden, ervan uitgaande dat we deze pinfuncties niet zullen gebruiken.

De Enable-pin is ook laag actief, dus tenzij we hem HOOG trekken, wordt de A4988ingeschakeld.

De volgende drie pinnen, MS1, MS2 en MS3, zijn bedoeld voor het selecteren van de stapresolutie van de motor. We zeiden al dat de stapresolutie afhangt van de constructie van de motor, die meestal 200 stappen per omwenteling bedraagt ​​voor een NEMA 17 stappenmotor. Alle drivershebben echter de functie microstepping, waarmee de motor met hogere resoluties kan worden aangestuurd. Dit wordt bereikt door de spoelen op een tussenstroomniveau te bekrachtigen, waardoor tussenstaplocaties ontstaan.

Als we bijvoorbeeld een kwartstapresolutie selecteren, worden de 200 stappen van de motor: 200 vermenigvuldigd met 4 is gelijk aan 800 microstappen per omwenteling. Om dit te bereiken zal de driver vier verschillende stroomniveaus op de spoelen gebruiken.

De A4988-driver heeft een maximale resolutie van 16 microstappen, wat ervoor zorgt dat een NEMA17-motor van 200 stappen 3200 stappen per omwenteling heeft, oftewel 0,1125 graden per stap. Dat is echt een indrukwekkende precisie en daarom worden dit soort stappenmotoren en drivers in zoveel toepassingen gebruikt. Eigenlijk zijn er stappenmotoren die 256 microstappen hebben, of dat zijn maar liefst 51.200 stappen per omwenteling, oftewel 0,007 graden per stap.

Niettemin hebben deze drie pinnen pull-down-weerstanden, dus als we ze los laten, werkt de driver in volledige stapmodus. Om een ​​andere microstepping-resolutie te selecteren, moeten we 5V aansluiten op de juiste pinnen volgens deze tabel.

A4988 Stroombegrenzing

Oké, dus nu we weten hoe we de stappenmotor en de driver op het Arduino-bord moeten aansluiten, kunnen we verder gaan met uitleggen hoe we de Arduino moeten programmeren of coderen voor het besturen van de stappenmotor. Voordat we dat echter doen, of voordat we de motor van stroom voorzien, is er nog één heel belangrijk ding dat we moeten doen, en dat is het aanpassen van de stroomlimiet van de bestuurder.

Zoals we al hebben uitgelegd, moeten we de stroomlimiet van de driver zo instellen dat deze lager is dan de stroomwaarde van de motor, anders zou de motor oververhit raken. [[]] Er zit een kleine trimpotentiometer op de A4988-driver waarmee we de stroomlimiet kunnen aanpassen. Door de potentiometer met de klok mee te draaien, wordt de stroomlimiet verhoogd, en omgekeerd. Er zijn twee methoden die kunnen worden gebruikt om de werkelijke waarde van de stroomlimiet te bepalen.

De eerste methode omvat het meten van de referentiespanning over de potentiometer zelf en GND. We kunnen de referentiespanning meten met een multimeter en die waarde in de volgende formule gebruiken om de stroomlimiet van de driver te berekenen:

Stroomlimiet = Vref / (8 x Rcs)

De Rcs is de stroomdetectieweerstand of de waarden van de stroomdetectieweerstanden die zich direct naast de chip bevinden. Afhankelijk van de fabrikant zijn deze waarden meestal 0,05, 0,1 of 0,2 ohm. We moeten dus de waarde van deze weerstanden nader bekijken om met deze methode de stroomlimiet nauwkeurig te berekenen. In mijn geval hadden deze weerstanden het label R100, wat 0,1 ohm betekende.

Als we bijvoorbeeld een referentiespanning van 0,7 V meten en we hebben weerstanden van 0,1 ohm, zou de stroomlimiet 0,875 A zijn. Of als we de stroom willen beperken tot bijvoorbeeld 1A, moeten we de referentiespanning aanpassen naar 0,8V.

De tweede methode voor het instellen van de stroomlimiet is door rechtstreeks de stroom door de spoelen te meten. Voor dat doel moeten we de stappenmotor en de driver aansluiten zoals eerder uitgelegd. We kunnen de controlleraansluiting overslaan, maar in plaats daarvan 5V aansluiten op de Direction- en de Step-pinnen, zodat de motor actief blijft en één positie vasthoudt. De MS-pinnen moeten losgekoppeld blijven, zodat de driver in volledige stapmodus werkt. Vervolgens kunnen we één lijn of spoel loskoppelen van de motor en deze in serie aansluiten met een ampèremeter. Op deze manier kunnen we, zodra we de driver voorzien van zowel de logische spanning, de 5V, als de voeding voor de motor 12V in mijn geval, lezen hoeveel stroom er door de spoel loopt. [[]] We moeten hier echter opmerken dat wanneer de driver in de volledige-stapmodus werkt, de stroom in de spoelen slechts 70% van de werkelijke stroomlimiet kan bereiken. Dus als de driver in de andere microstepping-modi wordt gebruikt, moet de waarde van de ampèremeter met 1,3 worden vermenigvuldigd om de werkelijke waarde van de stroomlimiet van de driver te krijgen.

Ik heb beide methoden geprobeerd om de huidige limiet van de driver in te stellen en ze gaven me ongeveer dezelfde resultaten.

Stappenmotoren en Arduino – Voorbeeldcodes

Toch kunnen we nu verder met het programmeren van de Arduino, of een aantal voorbeeldcodes bekijken voor het aansturen van een stappenmotor met een Arduino-bord. [[]] Laten we beginnen met een heel eenvoudige voorbeeldcode van hoe je een stappenmotor kunt besturen zonder een bibliotheek te gebruiken.

Voorbeeldcode 1

/*   
 *   Basic example code for controlling a stepper without library
 *      
 *   by HHA, https://rotor.harry-arends.nl / info@harry-arends.nl
 */

// defines pins
#define stepPin 2
#define dirPin 5 
 
void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin,OUTPUT); 
  pinMode(dirPin,OUTPUT);
}
void loop() {
  digitalWrite(dirPin,HIGH); // Enables the motor to move in a particular direction
  // Makes 200 pulses for making one full cycle rotation
  for(int x = 0; x < 800; x++) {
    digitalWrite(stepPin,HIGH); 
    delayMicroseconds(700);    // by changing this time delay between the steps we can change the rotation speed
    digitalWrite(stepPin,LOW); 
    delayMicroseconds(700); 
  }
  delay(1000); // One second delay
  
  digitalWrite(dirPin,LOW); //Changes the rotations direction
  // Makes 400 pulses for making two full cycle rotation
  for(int x = 0; x < 1600; x++) {
    digitalWrite(stepPin,HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin,LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

Codebeschrijving:

Hier hoeven we alleen maar te definiëren op welk pinnummer de STEP- en DIR-pinnen zijn aangesloten en deze als uitgangen te definiëren. In de lus stellen we eerst de draairichting van de motor in door de richtingspinstatus HOOG te maken. Vervolgens sturen we met behulp van een “for”-lus 200 pulsen naar de STEP-pin, waardoor de motor een volledige cyclus zal draaien, aangezien deze in volledige stap-modus werkt. De pulsen worden eenvoudigweg gegenereerd door de status van de STEP-pin HOOG naar LAAG te schakelen, met enige tijdsvertraging ertussen. Deze tijdsvertraging definieert feitelijk de rotatiesnelheid. Als we deze verlagen, zal de rotatiesnelheid toenemen naarmate de stappen sneller plaatsvinden, en omgekeerd.

Vervolgens veranderen we de draairichting, en met behulp van een andere “for”-lus sturen we 400 pulsen, waardoor de motor twee volledige cycli zou laten draaien. Als we echter de microstepping-modus van de driver veranderen, laten we zeggen een kwartstap, waardoor de motor nu 800 stappen heeft, zal de eerste lus de motor slechts 90 graden laten draaien, en de tweede lus slechts een halve rotatie.

Voorbeeldcode 2

Hier is nog een eenvoudig voorbeeld, waarbij de snelheid van de stappenmotor wordt geregeld met behulp van een potentiometer.

Voor dat doel hoeft u alleen maar de potentiometer op de Arduino aan te sluiten en de waarde ervan af te lezen met behulp van de functie analogRead().

 /*
 *   Basic example code for controlling a stepper without library
 *   by HHA, https://rotor.harry-arends.nl / info@harry-arends.nl
*/

// defines pins
#define stepPin 2
#define dirPin  5

int customDelay, customDelayMapped;

void setup() {
  // Sets the two pins as Outputs
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  speedControl();
  // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}
// Custom function for reading the potentiometer and mapping its value from 300 to 3000, suitable for the custom delay value in microseconds
void speedControl() {
  customDelay = analogRead(A0); // Read the potentiometer value
  customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // Convert the analog input from 0 to 1024, to 300 to 3000
}

Codebeschrijving

We kunnen vervolgens de potentiometerwaarden, die van 0 tot 1023 liggen, in kaart brengen of converteren naar waarden die geschikt zijn als vertragingstijd in microseconden voor de stappulsen. Ik vond dat de minimumwaarde voor de vertraging tussen de stappen ongeveer 300 microseconden was. Door lager te gaan begon de stappenmotor stappen over te slaan. Over het algemeen is het besturen van stappenmotoren met deze methode eenvoudig en werkt het, maar alleen als de vereiste bediening eenvoudig is, zoals weergegeven in de voorbeelden. Als we complexere besturing nodig hebben, is de beste manier om een ​​Arduino-bibliotheek te gebruiken.

Stappenmotoren besturen met Arduino en de AccelStepper-bibliotheek

In de besturing van mijn ArduKaMoto project

Voorbeelden

De meest populaire bibliotheek voor het aansturen van stappenmotoren met Arduino is de AccelStepper-bibliotheek van Mike McCauley. Het is een uiterst veelzijdige bibliotheek met snelheids-, acceleratie- en vertragingsregeling, het instellen van doelposities, het gelijktijdig besturen van meerdere stappenmotoren enzovoort.

De bibliotheek heeft geweldige documentatie waarin wordt uitgelegd hoe elke functie werkt. Ik heb deze bibliotheek al gebruikt voor verschillende van mijn Arduino-projecten, voor het besturen van de beweging van mijn DIY Camera Slider, de 3D-draadbuigmachine, de SCARA-robotarm en enkele andere. Als u geïnteresseerd bent, vindt u voor elk project details en code-uitleg op de website.

Laten we nu eens kijken naar enkele voorbeeldcodes die deze bibliotheek gebruiken. oorbeeldcode – Snelheidsregeling van stappenmotor met behulp van een potentiometer

Het eerste voorbeeld is het regelen van de snelheid van de motor met behulp van de potentiometer.

/*   
 *   Basic example code for controlling a stepper with the AccelStepper library
 *   by HHA, https://rotor.harry-arends.nl / info@harry-arends.nl
 */
#include <AccelStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Type of driver: with 2 pins, STEP, DIR)

void setup() {
  // Set maximum speed value for the stepper
  stepper1.setMaxSpeed(1000);
}

void loop() {
  stepper1.setSpeed((analogRead(A0));
  // Step the motor with a constant speed previously set by setSpeed();
  stepper1.runSpeed();
}

Codebeschrijving

Dus hier moeten we eerst de AccelStepper-bibliotheek opnemen. Voordat we dat doen, moeten we natuurlijk de bibliotheek installeren en dat kunnen we doen vanuit de Arduino IDE-bibliotheekmanager. We hoeven alleen maar naar “AccelStepper” te zoeken en de bibliotheek zal verschijnen en we kunnen deze installeren.

Vervolgens moeten we een exemplaar van de AccelStepper-klasse voor onze motor maken. De eerste parameter hier is het type driver, in dit geval voor een driver met twee controlepinnen is deze waarde 1, en de andere twee parameters zijn de pinnummers waarmee onze driver is verbonden met de Arduino. Als we meerdere stappenmotoren hebben, moeten we ze allemaal op deze manier definiëren, en we kunnen ze een naam geven zoals we willen. In dit geval heb ik mijn motorstepper1 genoemd.

In het setup-gedeelte hoeven we alleen maar de maximale snelheid van de motor in te stellen, die wordt gedefinieerd als stappen per seconde. Deze waarde kan oplopen tot 4000, maar in de documentatie van de bibliotheek staat dat snelheidswaarden van meer dan 1000 stappen per seconde onbetrouwbaar kunnen zijn.

In het lusgedeelte stellen we met behulp van de functie setSpeed() de huidige snelheid van de motor in, en in dit geval is dat de analoge ingang van de potentiometer, die van 0 tot 1023 loopt.

Om de motor te laten bewegen en die constante snelheid te implementeren, moeten we elk interval de functie runSpeed() aanroepen. Een negatieve waarde hier, of simpelweg een minteken vóór de waarde plaatsen, zou de stappenmotor in de tegenovergestelde richting laten draaien.

Voorbeeldcode – Besturing van twee stappenmotoren met versnelling en vertraging

Hier is nog een voorbeeld van het besturen van twee stappenmotoren met het implementeren van versnelling en vertraging met behulp van de AccelStepper-bibliotheek.

/*
    Twee steppers besturen met de AccelStepper-bibliotheek

     door Dejan, https://howtomechatronics.com
*/

#include <AccelStepper.h>

// Definieer de stappenmotor en de pinnen waarmee deze is verbonden
AccelStepper-stepper1(1, 2, 5); // (Type stuurprogramma: met 2 pinnen, STEP, DIR)
AccelStepper-stepper2(1, 3, 6);

ongeldige setup() {

  stepper1.setMaxSpeed(1000); // Stel de maximale snelheidswaarde in voor de stepper
  stepper1.setAcceleration(500); // Stel de versnellingswaarde in voor de stepper
  stepper1.setCurrentPosition(0); // Stel de huidige positie in op 0 stappen

  stepper2.setMaxSpeed(1000);
  stepper2.setAcceleration(500);
  stepper2.setCurrentPosition(0);
}

lege lus() {

  stepper1.moveTo(800); // Stel de gewenste zet in: 800 stappen (in kwartstapresolutie is dat één rotatie)
  stepper1.runToPosition(); // Verplaatst de motor naar de doelpositie met versnelling/vertraging en blokkeert totdat hij in positie is

  stepper2.moveTo(1600);
  stepper2.runToPosition();

  // Ga terug naar positie 0, gebruik run() wat niet-blokkerend is - beide motoren zullen tegelijkertijd bewegen
  stepper1.moveTo(0);
  stepper2.moveTo(0);
  terwijl (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
    stepper1.run(); // Beweeg of stap de motor en implementeer versnellingen en vertragingen om de doelpositie te bereiken. Niet-blokkerende functie
    stepper2.run();
    //
    //
  }
}

Codebeschrijving

We moeten dus de twee stappenmotoren definiëren en in de installatie met behulp van de functie setAcceleration() de versnellingswaarde voor de motoren instellen. Met behulp van de functie setCurrentPosition() stellen we de positie van de motoren in op 0 stappen.

In de lussectie beginnen we met de functie moveTo() waarmee we de motor vertellen naar welke positie hij moet gaan of hoeveel stappen hij moet bewegen. In het geval van een kwartstapresolutie zouden 800 stappen één volledige rotatie betekenen. Vervolgens verplaatst de functie runToPosition() de motor naar die positie terwijl versnelling en vertraging worden geïmplementeerd. Dit is echter een blokkeerfunctie, dus de code-uitvoering zal daar blijven totdat de stappenmotor die positie bereikt. Met dezelfde methode verplaatsen we de tweede motor 1600 stappen of twee volledige rotaties met een kwartstapresolutie.

Als we niet willen dat onze code wordt geblokkeerd totdat de motor de doelpositie bereikt, moeten we in plaats van de functie runToPosition() de functie run() gebruiken. Run() implementeert ook versnelling en vertraging om de doelpositie te bereiken, maar maakt slechts één stap per aanroep. Daarom moeten we het zo vaak mogelijk bellen. Om die reden plaatsen we hier de run()-functies voor beide motoren in deze while-lus, die wordt uitgevoerd totdat beide stappenmotoren positie 0 bereiken. We hebben eerder de twee motoren zo ingesteld dat ze naar positie 0 gaan met de moveTo()-functies.

We zouden ook meer code kunnen toevoegen aan die “while”-lus en ook andere dingen kunnen doen terwijl de motor draait. Eigenlijk zijn er veel methoden om de motoren te laten draaien en ook andere dingen te doen. Ik raad aan om de mooi beschreven documentatie van de bibliotheek door te nemen, zodat u kunt begrijpen hoe elke functie werkt en deze kunt implementeren volgens uw behoeften.

Voorbeeldcode – Meerdere stappenmotoren besturen met de AccelStepper-bibliotheek

Ik wil je nog een voorbeeld laten zien met behulp van de AccelStepper-bibliotheek en dat is het op een gecoördineerde manier besturen van meerdere stappenmotoren. Dit betekent dat we doelposities voor elke stepper kunnen instellen en dat ze hun posities allemaal tegelijkertijd kunnen bereiken, ongeacht de verschillende afstanden die ze moeten afleggen. [[]] Dit kan eenvoudig worden gedaan met behulp van de MultiStepper-klasse die bij de AccelStepper-bibliotheek wordt geleverd.

/*
 *   Bedien meerdere steppers met de AccelStepper- en MultiStepper-bibliotheek
 *   by HHA, https://rotor.harry-arends.nl / info@harry-arends.nl
*/

#include <AccelStepper.h>
#include <MultiStepper.h>

// Definieer de stappenmotor en de pinnen waarmee deze is verbonden
AccelStepper-stepper1(1, 2, 5); // (Type stuurprogramma: met 2 pinnen, STEP, DIR)
AccelStepper-stepper2(1, 3, 6);
AccelStepper-stepper3(1, 4, 7);

MultiStepper steppersControl; // Maak een exemplaar van MultiStepper

lange gotopositie[3]; // Een array om de doelposities voor elke stappenmotor op te slaan

ongeldige setup() {

  stepper1.setMaxSpeed(1000); // Stel de maximale snelheidswaarde in voor de stepper
  stepper2.setMaxSpeed(1000);
  stepper3.setMaxSpeed(1000);

  // De 3 steppers toevoegen aan de steppersControl-instantie voor multi-stepper-besturing
  steppersControl.addStepper(stepper1);
  steppersControl.addStepper(stepper2);
  steppersControl.addStepper(stepper3);
}

lege lus() {
  // Bewaar de doelposities in de "gotopostion" -array
  ga naar positie[0] = 800; // 800 stappen - volledige rotatie met kwartstapsresolutie
  gotopositie[1] = 1600;
  gotopositie[2] = 3200;

  steppersControl.moveTo(gotopositie); // Berekent het vereiste toerental voor alle motoren
  steppersControl.runSpeedToPosition(); // Blokkeert totdat alle steppers in positie zijn

  vertraging(1000);

  gotopositie[0] = 0;
  gotopositie[1] = 0;
  gotopositie[2] = 0;

  steppersControl.moveTo(gotopositie);
  steppersControl.runSpeedToPosition();

  vertraging(1000);
}

Codebeschrijving

Hier moeten we ook de klasse MultiStepper opnemen en er een exemplaar van maken. Vervolgens moeten we een array definiëren, van het type “long”, die zal worden gebruikt voor het opslaan van de doelposities voor onze motoren. In het setup-gedeelte moeten we de maximale snelheidswaarden van de steppers definiëren en de steppers toevoegen aan de eerder gemaakte MultiStepper-instantie, die ik in mijn geval “steppersControl” noemde.

In de lussectie beginnen we met het opslaan van de doelpositiewaarden in de array die we eerder hebben gemaakt. Ik heb de eerste stepper ingesteld om één rotatie te verplaatsen, de tweede twee rotaties en de derde drie rotaties. Vervolgens kunnen we deze array toewijzen aan de functie moveTo() die de vereiste snelheden berekent voor alle motoren om tegelijkertijd op die posities aan te komen. Dan hoeven we alleen maar de functie runSpeedToPosition() aan te roepen die de motoren naar hun positie zal verplaatsen. We moeten er echter rekening mee houden dat deze functie de code blokkeert totdat de steppers hun doelpositie bereiken. We zouden in plaats daarvan de functie run() kunnen gebruiken als we de code niet willen blokkeren. We moeten ook opmerken dat de MultiStepper-klasse geen versnelling en vertraging ondersteunt.

Drivers

DRV8825 versus A4988

Oké, laten we nu verder gaan en kijken hoe we stappenmotoren kunnen besturen met behulp van de andere driver die ik in het begin noemde, de DRV8825.

Eigenlijk geldt alles wat we tot nu toe hebben uitgelegd over het aansturen van stappenmotoren met de A4988 stappenmotor ook voor de DRV8825. Het werkingsprincipe, de aansluitingen en de codering zijn voor beide drivers vrijwel hetzelfde. Het verschil tussen hen zit in hun technische kenmerken en nu zullen we ze bekijken en vergelijken.

DRV8825			vs	A4988
		1,5A	Current	1A
		45V	V Motor	35V
		1/32	MicroStep	1/16

De DRV8825 is een driver-ICvan Texas Instruments die kan worden gebruikt als directe vervanging voor de Allegro A4988-driver, omdat hun aansluitingen hetzelfde zijn. De drie belangrijkste verschillen tussen beide zijn dat de DR8825 meer stroom kan leveren dan de A4988 zonder extra koeling (1,5 A versus 1 A), een hogere maximale voedingsspanning heeft (45 V versus 35 V) en een hogere microstepping-resolutie biedt (32 versus 16 microstappen). ).

Natuurlijk hebben ze ook nog enkele andere kleine verschillen. De stroomlimietpotentiometer heeft bijvoorbeeld een andere locatie en de relatie tussen de stroomlimietinstelling en de referentiepinspanning is anders. De DRV8825 heeft geen logische voeding nodig en de pinlocatie wordt gebruikt als FOUT-uitgang.

Het is echter veilig om de FAULT-pin rechtstreeks op 5V aan te sluiten, zodat de DRV8825 kan worden gebruikt als directe vervanging in systemen die zijn ontworpen voor de A4988-driver.

Het is echter vermeldenswaard dat het bij het vervangen van een A4988-driver door een DRV8825 erg belangrijk is om ervoor te zorgen dat de oriëntatie van de driver correct is. Ik zei al dat hun potentiometers op verschillende locaties zitten, bij de A4988 zit hij onder de chip, en bij de DRV8825 boven de chip, en dat kan soms voor verwarring zorgen en de driver kan gemakkelijk op de verkeerde kant worden geplaatst.

Voor het instellen van de stroomlimiet kunnen we de referentiespanning meten met één sonde op GND en de andere op de potentiometer zelf. [[]] De berekeningsformule voor de DRV8825-stappenaandrijving is als volgt:

Stroomlimiet = Vref x 2

Wat betreft het selecteren van de microstepping-resolutie kunnen we de volgende tabel gebruiken.

Tabel volgt

Over het geheel genomen is de DRV8825 een betere stappenmotor dan de A4988, omdat hij hogere stroom- en spanningswaarden biedt en een nog hogere microstepping-resolutie, wat resulteert in een soepelere en stillere werking van de stappenmotor.

DRV8825

De DRV8825 biedt een geïntegreerde motordriveroplossing voor printers, scanners en andere geautomatiseerde apparaten apparatuur toepassingen. Het apparaat heeft twee H-brugdrivers en kan een bipolaire stappenmotor of twee gelijkstroommotoren aandrijven motoren. Het uitgangsstuurblok voor elk bestaat uit N-kanaals vermogens-MOSFET's die zijn geconfigureerd als volledige H-bruggen drijven de motorwikkelingen aan. De DRV8825 kan een piekstroom van maximaal 2,5 A of een RMS-uitgangsstroom van 1,75 A leveren (met de juiste koellichaam bij 24 V en 25°C). Een eenvoudige stap/richting-interface maakt een gemakkelijke interface met controllercircuits mogelijk. Pinnen maken configuratie van de motor in volledige stap- tot 1/32-stapsmodi. Decay-modus is programmeerbaar. Interne uitschakelfuncties zijn voorzien voor overstroombeveiliging, kortsluitbeveiliging en onderspanningsblokkering en te hoge temperatuur.

Microstepping

Microstepping is een manier om kleine stappen in een stappenmotor nog kleiner te maken. Hoe kleiner de stap, hoe hoger de resolutie en hoe beter de trillingseigenschappen. Bij microstepping is een fase niet volledig aan of volledig uit. Het is gedeeltelijk aan. Sinusgolven worden toegepast op zowel fase A als fase B, 90° uit elkaar (0,72° in een 5-fase stappenmotor).

MICROSTEPPING
MS1	MS2	MS3	STEP
low	low	low	Full
high	low	low	1/2
low	high	low	1/4
high	high	high	1/8
low	low	high	1/16
high	low	high	1/32
low	high		1/64
high	high	high	1/128

Hoe stel ik de stroomlimiet in?

Voordat je begint met het programmeren van je Arduino en het stuurprogramma gaat gebruiken, is er één heel belangrijk ding dat je moet doen dat veel mensen vergeten: stel de stroomlimiet in!

Deze stap is niet erg ingewikkeld maar absoluut noodzakelijk om uw stappenmotor en de driverte beschermen. Als u geen geschikte stroomlimiet instelt, kan uw motor meer stroom trekken dan hij of uw driver aankan. Dit zal waarschijnlijk een of beide beschadigen.

Om de stroomlimiet in te stellen, moet u een referentiespanning meten en de ingebouwde potentiometer dienovereenkomstig aanpassen. U hebt een kleine schroevendraaier nodig, een multimeter om de referentiespanning te meten en krokodillenmeetsnoeren (optioneel maar erg handig).

Stroomlimiet formule

De volgende stap is het berekenen van de stroomlimiet met de volgende formule:

Stroomlimiet = Vref × 2

Dit betekent dus dat voor een stroomlimiet van 1 A de Vref 0,5 V moet zijn.

Om de juiste stroomlimiet te selecteren, bekijk de datasheet van jouw stappenmotor. Als u de stroomsterkte van uw motor niet kunt vinden, raad ik u aan te beginnen met een stroomlimiet van 1A. Je kunt het later altijd verhogen als er stappen ontbreken in je motor/bestuurder.

Als uw motor veel lawaai maakt, probeer dan de stroomlimiet te verlagen. Het is het beste om de stroomlimiet net hoog genoeg in te stellen, zodat de motor geen stappen mist.

Vref meten

Nu moet u de referentiespanning (Vref) meten tussen de twee punten die op de onderstaande afbeelding zijn gemarkeerd (GND en de potentiometer) en deze aanpassen aan de waarde die u hebt berekend.

Ik raad aan om krokodillenmeetsnoeren te gebruiken die op de schroevendraaier zijn vastgeklemd om de stroomlimiet in te stellen. Hierdoor kunt u de potentiometer afstellen en tegelijkertijd de referentiespanning meten.

Opmerking: Er is een andere manier om de stroomlimiet te meten en dat is door direct het stroomverbruik van de stappenmotor te meten. Persoonlijk vind ik bovenstaande methode een stuk makkelijker.

Veelgestelde vragen over stroomlimieten

Moet ik de stappenmotor wel of niet aangesloten hebben?

Nee, u hoeft de stappenmotor niet op de driver aan te sluiten bij het instellen van de stroomlimiet. Voor de zekerheid: koppel je motor los, deze interfereert soms bij het meten van de Vref-spanning.

Moet ik de motor draaien door de Arduino-motorschets uit te voeren?

Nee, zie vraag hierboven.

Moet ik de potentiometer met de klok mee of tegen de klok in draaien om Vref te verhogen?

Dit is afhankelijk van de fabrikant van de driver. Als je een origineel Polulu breakout-bord van de DRV8825 of A4988 hebt, draai je de potentiometer met de klok mee om Vref te verhogen en tegen de klok in om hem te verlagen.

Het koelen van de driver

Het DRV8825-driver-IC heeft een maximale stroomsterkte van 2,5 A per spoel, maar kan zonder koellichaam slechts ongeveer 1,5 A per spoel leveren voordat deze oververhit raakt.