Stappenmotoren Meesteren met Arduino: De Uitgebreide Gids

In deze tutorial leren we alles wat we hoeven te weten over het besturen van stappenmotoren met Arduino. We behandelen hoe een NEMA17 stappenmotor te besturen in combinatie met een A4988, een DRV8825 en een TMC2208 stappendriver.

Deze combinatie van stappenmotoren en drivers wordt in talloze toepassingen gebruikt waar positiecontrole nodig is, zoals 3D-printers, CNC-machines, robotica, automatiseringsmachines, enz.

Ik heb het zelf al in veel van mijn Arduino-projecten gebruikt, zoals de volgende:

• DIY Camera Slider
• 3D Draadbodem Machine
• DIY Schuim Snijmachine
• DIY Laser Graveerder
• Pen Plotter met Automatische Pen Wisselaar
• SCARA Robot Arm

Ik zal in detail uitleggen hoe ze werken, hoe u stappenmotoren met Arduino kunt aansluiten, hoe u de stroomlimiet van de drivers instelt en hoe u ze programmeert met of zonder een Arduino-bibliotheek. Ook laat ik zien hoe we gemakkelijk meerdere stappenmotoren kunnen besturen met een Arduino CNC shield voor elk type Arduino-project.

Dus, we hebben een hoop te behandelen in deze tutorial. U kunt de volgende video bekijken of de geschreven tutorial hieronder lezen die ook alle voorbeeldcodes en aansluitschema's bevat.

Wat is een Stappenmotor en Hoe Werkt Het?

Ik begin met kort uitleggen wat een stappenmotor is en hoe het werkt, aangezien dit ons helpt om alles anders in deze tutorial beter te begrijpen.

Een stappenmotor is een uniek type borstelloze DC-motor waarvan de positie precies gecontroleerd kan worden, zelfs zonder enige feedback.

Het werkingsprincipe van een stappenmotor is gebaseerd op magnetische velden. Het heeft twee hoofdcomponenten, een stator en een rotor. De rotor is meestal een permanente magneet en wordt omringd door enkele spoelen op de stator.

Wanneer we de spoelen energiseren of stroom doorlaten, worden specifieke magnetische velden in de stator gegenereerd die de rotor either aantrekken of afstoten. Door de spoelen stap voor stap, één na de ander, in een bepaalde volgorde te activeren, kunnen we continue beweging van de rotor bereiken, maar ook, we kunnen hem op elke positie laten stoppen.

Dus, daarom heten deze motoren stappenmotoren, ze bewegen in discrete stappen.

Door het aantal magnetische polen op de rotor te verhogen, kunnen we het aantal mogelijke stopposities verhogen, wat de resolutie of precisie van de motor verhoogt. Let op dat dit slechts een basisuitleg is en u meer details kunt vinden in mijn "Hoe Stappenmotoren Werken" tutorial.

Een typische stappenmotor, bijvoorbeeld een NEMA17, heeft 50 stoppunten of stappen op de rotor. Aan de andere kant kan de stator verschillende spoelen hebben georganiseerd in twee fasen die vier verschillende magnetische veldoriëntaties of posities bieden.

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

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

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

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

Niettemin, met deze korte uitleg begrijpen we nu dat voor het aansturen van een stappenmotor, we niet gewoon stroom kunnen aansluiten want er zal niets gebeuren. In plaats daarvan moeten we de twee motorfasen in beide richtingen energiseren en pulsen naar hen sturen in een bepaalde volgorde, in een tijdige sequentie. Dus, daarom hebben we drivers nodig voor het besturen van stappenmotoren.

Er zijn veel typen en formaten van drivers, overeenkomend met de veel typen en formaten van stappenmotoren. Echter, het basisch werkingsprincipe van al deze is dat ze twee H-bruggen hebben die het energiseren van de motorfasen in beide richtingen toestaan.

Natuurlijk hebben ze veel andere functies zoals microstepping, stroombegrenzing, enz. die ons in staat stellen om de stappenmotoren gemakkelijk te besturen, wat het hele doel van hen is.

Hoe Een NEMA17 Stappenmotor Te Besturen Met Arduino en A4988 Stappendriver

Goed, nu kunnen we kijken naar het eerste voorbeeld voor deze tutorial, hoe een NEMA 17 stappenmotor te besturen met een A4988 stappendriver.

Goed, nu kunnen we kijken naar het eerste voorbeeld voor deze tutorial, hoe een NEMA 17 stappenmotor te besturen met een A4988 stappendriver.

De NEMA17 is de populairste stappenmotor onder makers, omdat het geweldige prestaties biedt en tegelijkertijd betaalbaar is. Het kan ook in bijna elke desktop 3D-printer en laser graveerder gevonden worden.

Over het algemeen heeft de NEMA17 stappenmotor 200 stappen, of 1,8 graden per stap resolutie, maar er zijn ook modellen met 400 stappen en 0,9 graden per stap resolutie. We moeten hier noteren dat de aanduiding NEMA17 eigenlijk alleen de grootte van de motor beschrijft in termen van de frontfaceplate grootte.

Het nummer staat voor de grootte van de faceplate in inches gedeeld door 10, of in dit geval zou dat 17 gedeeld door 10 zijn gelijk aan 1,7 inches faceplate, of 2,3 inches faceplate in het geval van NEMA23.

Dus, de faceplate grootte is vast, maar de lengte van de NEMA17 steppers kan variëren van 20mm tot 60mm, en daarmee varieert ook de stroomvereiste van de motor. De stroomvereiste wordt meestal gedefinieerd door hoeveel stroom de motor mag trekken, en het bereik voor deze NEMA17 stappenmotoren is van 0,3A tot 2,5A.

Nu, volgens de stroomwaarde van de stappenmotor, moeten we een geschikte driver kiezen die die hoeveelheid stroom kan aan. De populairste driver voor het besturen van NEMA17 stappenmotoren is de A4988 stappenmotordriver.

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

Een geweldige functie die de A4988 stappendriver heeft, eigenlijk hebben alle andere drivers, is de stroombegrenzing. Hiermee kunnen we eenvoudig instellen hoeveel stroom de motor zal trekken, ongeacht de motorwaarde. Bijvoorbeeld, we kunnen zelfs een 2,5A gewaardeerde stappenmotor aansluiten, maar we zullen de stroom van de driver beperken tot 1,5A. Dus, hoewel de motor niet op zijn maximale capaciteit zal werken, zouden we het nog steeds kunnen gebruiken.

Aan de andere kant, als de motor lager gewaardeerd is dan de ingestelde stroomlimiet op de driver, zou de motor oververhit raken. Natuurlijk is het altijd aanbevolen om te proberen de stroomwaarde van de motor te matchen met de stroomwaarde van de driver.

A4988 en Arduino Aansluiting

Goed, dus nu laten we zien hoe de A4988 driver met de stappenmotor en de Arduino controller te verbinden.

U kunt de benodigde componenten voor deze Arduino tutorial via de onderstaande links verkrijgen:

• Stappenmotor NEMA 17………………… Amazon / Banggood / AliExpress
• A4988 Stappendriver…………………..… Amazon / Banggood / AliExpress
• DRV8825 Stappendriver……….……..… Amazon / Banggood / AliExpress
• TMC2208 Stappendriver ………………… Amazon / Banggood / AliExpress
• Arduino CNC Shield ………………………. Amazon / Banggood / AliExpress
• Arduino Uno………………………………..… Amazon / Banggood / AliExpress

Disclosure: Dit zijn affiliate links. Als Amazon Associate verdien ik aan kwalificerende aankopen.

In de rechterbovenhoek van de driver hebben we de VMOT en GND pennen en hier sluiten we de voeding voor de motor aan die kan variëren van 8 tot 36V. Hier wordt ook aanbevolen om een decoupling condensator over deze twee pennen te plaatsen om het bord te beschermen tegen spanningspieken. We moeten een grote elektrolytische condensator gebruiken met ten minste 47uF capaciteit.

Vervolgens zijn de vier pennen waar we de stappenmotor aan sluiten. Een fase van de motor gaat op 1A en 1B pennen, en de andere fase op 2A en 2B pennen.

Soms kan het een beetje moeilijk zijn om te herkennen welke twee draden van de motor een fase vormen, maar er zijn verschillende manieren om ze te identificeren. De simpelste manier is om de as van de stappenmotor met de hand te draaien, en dan twee draden aan elkaar te verbinden. Als u twee draden verbindt die een fase vormen, zou de rotatie van de as iets moeilijker zijn.

Een andere manier is om een multimeter te gebruiken en te controleren op doorloop tussen de twee draden. Als u twee draden verbindt die een fase vormen, heeft u een kortsluiting en de multimeter zal beginnen te piepen.

Zodra we een fase vinden, kunnen we het aan elke positie van de twee posities op de driver aansluiten, de volgorde maakt niet uit.

Vervolgens hebben we de IC of de logica voedingspennen, VDD en GND, die van 3V tot 5V kunnen zijn. Aan de andere kant hebben we de Step en de Direction pennen, die aan elke pin van het Arduino-bord verbonden kunnen worden. Met de Direction pin selecteren we de rotatierichting van de motor, en met de Step pin controleren we de stappen van de motor. Met elke puls die we naar de Step pin sturen, zal de motor één stap vooruitgaan in de geselecteerde richting.

Rechtboven deze pennen, hebben we de Sleep en de Reset pennen die gebruikt worden voor, zoals hun namen suggereren, de driver in slaapmodus te zetten of te resetten. We moeten noteren dat beide pennen active low zijn. De Sleep pin is standaard in HIGH staat, maar de RST pin is zwevend. Dat betekent dat de makkelijkste manier om de driver ingeschakeld te hebben, is om deze twee pennen gewoon met elkaar te verbinden, aannemend dat we deze pinfuncties niet zullen gebruiken.

De Enable pin is ook active low, dus tenzij we het HIGH trekken, zal de driver ingeschakeld zijn.

De volgende drie pennen, MS1, MS2 en MS3, zijn voor het selecteren van de stapresolutie van de motor. We zeiden al dat de stapresolutie afhangt van de constructie van de motor wat meestal 200 stappen per omwenteling is voor een NEMA 17 stappenmotor. Echter, alle stappendrivers hebben deze functie genaamd microstepping wat het aansturen van de motor op hogere resoluties toestaat. Dit wordt bereikt door de spoelen op een intermediair stroomniveau te energiseren, wat intermediaire staplocaties produceert.

Bijvoorbeeld, als we kwart-stap resolutie selecteren, zullen de 200 stappen van de motor worden, 200 vermenigvuldigd met 4 is gelijk aan 800 microstappen per omwenteling. De driver zal vier verschillende stroomniveaus op de spoelen gebruiken om dit te bereiken.

De A4988 driver heeft een maximale resolutie van 16 microstappen, wat een 200 stappen NEMA17 motor 3200 stappen per omwenteling zou maken, of dat is 0,1125 graden per stap. Dat is echt indrukwekkende precisie en daarom worden deze typen stappenmotoren en drivers in zoveel toepassingen gebruikt. Eigenlijk zijn er stappendrivers die tot 256 microstappen hebben, of dat is een ongelooflijke 51200 stappen per omwenteling, of 0,007 graden per stap.

Niettemin, deze drie pennen hebben pull-down weerstanden, dus als we ze loslaten, zal de driver in full-step modus werken. Voor het selecteren van een andere microstepping resolutie moeten we 5V aan de juiste pennen verbinden volgens deze tabel.

A4988 Stroombegrenzing

Goed, dus nu we weten hoe de stappenmotor en de driver met het Arduino-bord te verbinden, kunnen we doorgaan met het uitleggen hoe de Arduino te programmeren of coderen voor het besturen van de stappenmotor. Echter, voordat we dat doen, of voordat we de motor voeden, is er nog een heel belangrijk ding dat we moeten doen, en dat is het aanpassen van de stroomlimiet van de driver.

Zoals we al uitlegden, moeten we de stroomlimiet van de driver aanpassen om lager te zijn dan de stroomwaarde van de motor, of anders zou de motor oververhit raken.

Er zit een kleine trimmer potentiometer op de A4988 driver waarmee we de stroomlimiet kunnen aanpassen. Door de potentiometer met de klok mee te draaien, stijgt de stroomlimiet, en vice versa. Er zijn twee methoden die gebruikt kunnen worden om de daadwerkelijke 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 gebruiken in de volgende formule om de stroomlimiet van de driver te berekenen:

Stroomlimiet = Vref / (8 x Rcs)

De Rcs is de stroomsensweerstand of de waarden van de stroomsensorweerstanden vlak naast de chip. Afhankelijk van de fabrikant, zijn deze waarden meestal 0,05, 0,1 of 0,2 ohm. Dus, we moeten nader kijken naar de waarde van deze weerstanden om de stroomlimiet met deze methode nauwkeurig te berekenen. In mijn geval waren deze weerstanden gelabeld R100, wat 0,1 ohm betekende.

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

De tweede methode voor het instellen van de stroomlimiet is door direct de stroom door de spoelen te meten. Voor dat doel, moeten we de stappenmotor en de driver verbinden zoals eerder uitgelegd. We kunnen de controllerverbinding overslaan, maar in plaats daarvan 5V verbinden met de Direction en de Step pennen zodat de motor actief blijft en één positie vasthoudt. De MS pennen moeten losgelaten worden zodat de driver in full-step modus zou werken. Dan kunnen we één lijn of spoel van de motor loskoppelen, en het in serie met een amperemeter verbinden. Op deze manier, zodra we de driver voeden met zowel de logica spanning, de 5V, en de stroom voor de motor 12V in mijn geval, kunnen we aflezen hoeveel stroom door de spoel loopt.

Hoewel, we moeten hier noteren dat wanneer de driver in full-step modus werkt, de stroom in de spoelen slechts 70% van de daadwerkelijke stroomlimiet kan bereiken. Dus, bij het gebruik van de driver in de andere microstepping modi, moet de aflezing van de amperemeter vermenigvuldigd worden met 1,3 om de daadwerkelijke waarde van de stroomlimiet van de driver te krijgen.

Ik probeerde beide methoden voor het instellen van de stroomlimiet van de driver en ze gaven me ongeveer dezelfde resultaten.

Stappenmotoren en Arduino – Voorbeeldcodes

Niettemin, nu kunnen we doorgaan met het programmeren van de Arduino, of kijken naar verschillende voorbeeldcodes voor het besturen van een stappenmotor met een Arduino-bord.

Laten we beginnen met een heel basiscodevoorbeeld van hoe een stappenmotor te besturen zonder een bibliotheek te gebruiken.

Voorbeeldcode 1

/* * Basiscodevoorbeeld voor het besturen van een stappenmotor zonder bibliotheek * * door Dejan, https://howtomechatronics.com */ // definieert pennen #define stepPin 2 #define dirPin 5 void setup() { // Stelt de twee pennen in als Outputs pinMode(stepPin,OUTPUT); pinMode(dirPin,OUTPUT); } void loop() { digitalWrite(dirPin,HIGH); // Stelt de motor in om in een bepaalde richting te bewegen // Maakt 200 pulsen voor één volledige cyclus rotatie for(int x = 0; x < 800; x++) { digitalWrite(stepPin,HIGH); delayMicroseconds(700); // door deze tijdsvertraging tussen de stappen te veranderen kunnen we de rotatiesnelheid veranderen digitalWrite(stepPin,LOW); delayMicroseconds(700); } delay(1000); // Een seconde vertraging digitalWrite(dirPin,LOW); // Verandert de rotatierichting // Maakt 400 pulsen voor twee volledige cyclus rotatie for(int x = 0; x < 1600; x++) { digitalWrite(stepPin,HIGH); delayMicroseconds(500); digitalWrite(stepPin,LOW); delayMicroseconds(500); } delay(1000); }Code language: PHP (php)

Codebeschrijving:

Hier hoeven we alleen te definiëren op welk pinnummer de STEP en DIR pennen zijn aangesloten en ze als outputs te definiëren. In de loop, stellen we eerst de rotatierichting van de motor in door de Direction pin status HIGH te maken. Dan gebruiken we een "for" lus om 200 pulsen naar de STEP pin te sturen wat de motor een volledige cyclus zal laten draaien, rekening houdend met dat het in full-step modus werkt. De pulsen worden simpelweg gegenereerd door de status van de STEP pin van HIGH naar LOW te togglen met een bepaalde tijdsvertraging ertussen. Deze tijdsvertraging definieert eigenlijk de rotatiesnelheid. Als we het verlagen, zal de rotatiesnelheid toenemen omdat de stappen sneller zullen gebeuren, en vice versa.

Dan veranderen we de rotatierichting, en met nog een "for" lus sturen we 400 pulsen wat de motor twee volledige cycli zou laten draaien. Echter, als we de microstepping modus van de driver veranderen, laten we zeggen naar een kwart-stap, wat de motor 800 stappen zou maken, zal de eerste lus de motor alleen 90 graden laten draaien, en de tweede lus alleen een halve rotatie.

Voorbeeldcode 2

Hier is nog een simpel voorbeeld, de stappenmotorsnelheid besturen met een potentiometer.

Voor dat doel, hoeven we alleen de potentiometer aan de Arduino te verbinden en de waarde te lezen met de analogRead() functie.

/* Basiscodevoorbeeld voor het besturen van een stappenmotor zonder bibliotheek door Dejan, https://howtomechatronics.com */ // definieert pennen #define stepPin 2 #define dirPin 5 int customDelay, customDelayMapped; void setup() { // Stelt de twee pennen in als Outputs pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); } void loop() { speedControl(); // Maakt pulsen met custom delay, afhankelijk van de Potentiometer, waar de snelheid van de motor van afhangt digitalWrite(stepPin, HIGH); delayMicroseconds(customDelayMapped); digitalWrite(stepPin, LOW); delayMicroseconds(customDelayMapped); } // Custom functie voor het lezen van de potentiometer en het mappen van de waarde van 300 tot 3000, geschikt voor de custom delay waarde in microseconden void speedControl() { customDelay = analogRead(A0); // Lees de potentiometerwaarde customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // Converteer de analoge input van 0 tot 1024, naar 300 tot 3000 }Code language: PHP (php)

Codebeschrijving:

We kunnen de potentiometerwaarden die van 0 tot 1023 zijn, dan mappen of converteren naar waarden geschikt voor een vertragingstijd in microseconden voor de Step pulsen. Ik vond de minimumwaarde voor de vertraging tussen stappen om de 300 microseconden. Door lager dan dat te gaan, begon de stappenmotor stappen over te slaan.

Over het algemeen is het besturen van stappenmotoren met deze methode eenvoudig en het werkt, maar alleen als de vereiste controle simpel is zoals in de voorbeelden getoond. In het geval dat we meer complexe controle nodig hebben, is de beste manier om een Arduino-bibliotheek te gebruiken.

Stappenmotoren Besturen met Arduino en de AccelStepper Bibliotheek – Voorbeelden

De populairste bibliotheek voor het besturen van stappenmotoren met Arduino is de AccelStepper bibliotheek van Mike McCauley. Het is een extrem veelzijdige bibliotheek met snelheid, versnelling en vertraging controle, doelposities instellen, het besturen van meerdere stappenmotoren tegelijkertijd en zo verder.

De bibliotheek heeft een geweldige documentatie die uitlegt hoe elke functie werkt. Ik heb deze bibliotheek al voor verschillende van mijn Arduino-projecten gebruikt, voor het besturen van de beweging van mijn DIY Camera Slider, de 3D draadbodem machine, de SCARA robotarm en een paar anderen. Als u geïnteresseerd bent, zijn er details en code-uitleg voor elk project op de website.

Nu laten we kijken naar een paar voorbeeldcodes met deze bibliotheek.

Voorbeeldcode – Stappenmotorsnelheidscontrole met een potentiometer

Het eerste voorbeeld zal het besturen van de snelheid van de motor met de potentiometer zijn.

/* * Basiscodevoorbeeld voor het besturen van een stappenmotor met de AccelStepper bibliotheek * * door Dejan, https://howtomechatronics.com */ #include <AccelStepper.h> // Definieer de stappenmotor en de pennen waar deze aan verbonden is AccelStepper stepper1(1, 2, 5); // (Type driver: met 2 pennen, STEP, DIR) void setup() { // Stel maximum snelheidswaarde in voor de stepper stepper1.setMaxSpeed(1000); } void loop() { stepper1.setSpeed((analogRead(A0)); // Stap de motor met een constante snelheid ingesteld door setSpeed(); stepper1.runSpeed(); }Code language: PHP (php)

Codebeschrijving:

Dus, hier moeten we eerst de AccelStepper bibliotheek includen. Natuurlijk, voordat we dat doen, moeten we de bibliotheek installeren en dat kunnen we vanuit de Arduino IDE library manager doen. We hoeven alleen "AccelStepper" te zoeken en de bibliotheek zal verschijnen en we kunnen het installeren.

Dan, moeten we een instantie van de AccelStepper klasse aanmaken voor onze motor. De eerste parameter hier is het type driver, in dit geval voor een driver met twee besturingpennen is deze waarde 1, en de andere twee parameters zijn de pinnummers waar onze driver aan de Arduino verbonden is. Als we meerdere stappenmotoren hebben, moeten we elk van ze zo definiëren, en we kunnen ze noemen hoe we willen, in dit geval noemde ik mijn motor stepper1.

In de setup sectie hoeven we alleen de maximumsnelheid van de motor in te stellen wat gedefinieerd is als stappen per seconde. Deze waarde kan tot 4000 gaan, maar in de documentatie van de bibliotheek wordt gesteld dat snelheidswaarden van meer dan 1000 stappen per seconde onbetrouwbaar kunnen zijn.

In de loop sectie, met de setSpeed() functie stellen we de huidige snelheid van de motor in, en in dit geval is dat de analoge input van de potentiometer wat van 0 tot 1023 is.

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

Voorbeeldcode – Twee stappenmotoren besturen met versnelling en vertraging

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

/* Twee stappenmotoren besturen met de AccelStepper bibliotheek door Dejan, https://howtomechatronics.com */ #include <AccelStepper.h> // Definieer de stappenmotor en de pennen waar deze aan verbonden is AccelStepper stepper1(1, 2, 5); // (Typeof driver: met 2 pennen, STEP, DIR) AccelStepper stepper2(1, 3, 6); void setup() { stepper1.setMaxSpeed(1000); // Stel maximum snelheidswaarde in voor de stepper stepper1.setAcceleration(500); // Stel 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); } void loop() { stepper1.moveTo(800); // Stel gewenste beweging in: 800 stappen (in kwart-stap resolutie is dat één rotatie) stepper1.runToPosition(); // Beweegt de motor naar doelpositie met versnelling/ vertraging en het blokkeert tot in positie stepper2.moveTo(1600); stepper2.runToPosition(); // Terug naar positie 0, met run() wat non-blocking is - beide motoren bewegen tegelijkertijd stepper1.moveTo(0); stepper2.moveTo(0); while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) { stepper1.run(); // Beweeg of stap de motor met implementatie van versnellingen en vertragingen om de doelpositie te bereiken. Non-blocking functie stepper2.run(); // // } }Code language: PHP (php)

Codebeschrijving:

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

In de loop sectie, beginnen we met de moveTo() functie waarmee we de motor vertellen naar welke positie te gaan of hoeveel stappen het moet bewegen. In het geval van kwart-stap resolutie, zouden 800 stappen één volledige rotatie betekenen. Dan, de runToPosition() functie beweegt de motor naar die positie terwijl versnelling en vertraging geïmplementeerd worden. Echter, dit is een blokkerende functie, dus de codeuitvoering blijft daar tot de stappenmotor die positie bereikt.

Met dezelfde methode bewegen we de tweede motor 1600 stappen of twee volledige rotaties met kwart-stap resolutie.

Als we niet willen dat onze code geblokkeerd wordt tot de motor de doelpositie bereikt, in plaats van de runToPosition() functie te gebruiken, moeten we de run() functie gebruiken. De run() implementeert ook versnelling en vertraging om de doelpositie te bereiken, maar het maakt slechts één stap per aanroep. Daarom moeten we het zo vaak mogelijk aanroepen. Daarom zetten we hier de run() functies voor beide motoren in deze while lus, die uitgevoerd wordt tot beide steppers positie 0 bereiken. We stelden de twee motoren eerder in om naar positie 0 te gaan met de moveTo() functies.

We konden ook meer code in die "while" lus toevoegen en andere dingen ook doen tijdens het draaien van de motor. Eigenlijk zijn er veel methoden om de motoren te laten draaien en andere dingen te doen. Ik raad aan om door de mooi beschreven documentatie van de bibliotheek te gaan zodat u begrijpt hoe elke functie werkt en ze implementeert volgens uw behoeften.

Voorbeeldcode – Meerdere stappenmotoren besturen met AccelStepper bibliotheek

Ik zou u nog één voorbeeld met de AccelStepper bibliotheek willen tonen en dat is het besturen van meerdere stappenmotoren op een gecoördineerde manier. Dit betekent, we kunnen doelposities instellen voor elke stepper en ze kunnen hun posities allemaal tegelijkertijd bereiken, ongeacht de verschillende afstanden die ze moeten afleggen.

Dit kan eenvoudig gedaan worden met de MultiStepper klasse die bij de AccelStepper bibliotheek hoort.

/* Meerdere steppers besturen met de AccelStepper en MultiStepper bibliotheek door Dejan, https://howtomechatronics.com */ #include <AccelStepper.h> #include <MultiStepper.h> // Definieer de stappenmotor en de pennen waar deze aan verbonden is AccelStepper stepper1(1, 2, 5); // (Typeof driver: met 2 pennen, STEP, DIR) AccelStepper stepper2(1, 3, 6); AccelStepper stepper3(1, 4, 7); MultiStepper steppersControl; // Maak instantie van MultiStepper long gotoposition[3]; // Een array om de doelposities voor elke stappenmotor op te slaan void setup() { stepper1.setMaxSpeed(1000); // Stel maximum snelheidswaarde in voor de stepper stepper2.setMaxSpeed(1000); stepper3.setMaxSpeed(1000); // De 3 steppers toevoegen aan de steppersControl instantie voor multi stepper controle steppersControl.addStepper(stepper1); steppersControl.addStepper(stepper2); steppersControl.addStepper(stepper3); } void loop() { // Sla de doelposities op in de "gotopostion" array gotoposition[0] = 800; // 800 stappen - volledige rotatie met kwart-stap resolutie gotoposition[1] = 1600; gotoposition[2] = 3200; steppersControl.moveTo(gotoposition); // Berekent de vereiste snelheid voor alle motoren steppersControl.runSpeedToPosition(); // Blokkeert tot alle steppers in positie zijn delay(1000); gotoposition[0] = 0; gotoposition[1] = 0; gotoposition[2] = 0; steppersControl.moveTo(gotoposition); steppersControl.runSpeedToPosition(); delay(1000); }Code language: PHP (php)

Codebeschrijving:

Hier moeten we ook de MultiStepper klasse includen, en een instantie daarvan aanmaken. Dan moeten we een array definiëren, type "long", wat gebruikt zal worden voor het opslaan van de doelposities voor onze motoren. In de setup sectie, moeten we de maximumsnelheidswaarden van de steppers definiëren en de steppers toevoegen aan de eerder aangemaakte MultiStepper instantie, wat in mijn geval "steppersControl" noemde.

In de loop sectie, beginnen we met het opslaan van de doelpositiewaarden in de array die we eerder aanmaakten. Ik stelde de eerste stepper in om één rotatie te maken, de tweede, twee rotaties en de derde, drie rotaties. Dan kunnen we deze array toewijzen aan de moveTo() functie wat de vereiste snelheden voor alle motoren zal berekenen om op die posities tegelijkertijd aan te komen. Dan hoeven we alleen de runSpeedToPosition() functie aan te roepen wat de motoren naar hun positie zal bewegen. Hoewel we moeten noteren dat deze functie de code blokkeert tot de steppers hun doelpositie bereiken. We zouden de run() functie kunnen gebruiken als we de code niet willen blokkeren. We moeten ook noteren dat de MultiStepper klasse geen versnelling en vertraging ondersteunt.

Niettemin, als u meer wilt leren, van meer geavanceerde voorbeelden, kunt u mijn Arduino-projecten bekijken die ik al noemde, alle details en codes voor hen staan op de website.

CNC Shield voor het Besturen van Meerdere Stappenmotoren voor Elk Arduino Project

Nog steeds pratend over het besturen van meerdere stappenmotoren, is het de moeite waard om te noemen en te kijken naar de Arduino CNC shield.

Het hoofddoel van de Arduino CNC shield is voor het besturen van 2 of 3-as CNC-machines, maar het is eigenlijk een geweldige optie voor het besturen van elk type project waar we meerdere stappenmotoren moeten besturen omdat het compact is en eenvoudige verbindingen biedt voor de drivers en de motoren.

Deze shield gaat bovenop een Arduino UNO bord, en kan tot 4 individuele stappenmotoren besturen, en heeft alle overige Arduino pennen beschikbaar voor gebruik. Ik gebruikte deze combinatie van een Arduino UNO bord en de CNC shield voor het besturen van mijn 4-as SCARA robotarm.

Ik zal deze sectie van het artikel, hoe de CNC shield met Arduino te gebruiken, binnenkort met meer details bijwerken.

DRV8825 vs A4988

Goed, dus nu laten we doorgaan en zien hoe we stappenmotoren kunnen besturen met de andere driver die ik aan het begin noemde, de DRV8825.

Eigenlijk, alles wat we tot nu toe uitlegden over het besturen van stappenmotoren met de A4988 stappendriver, geldt ook voor de DRV8825. Het werkingsprincipe, de verbindingen en de codering zijn bijna hetzelfde voor beide drivers. Het verschil tussen hen zit in hun technische kenmerken en nu zullen we ernaar kijken en ze vergelijken.

De DRV8825 is een stappendriver van Texas Instruments die gebruikt kan worden als directe vervanging voor de Allegro A4988 driver aangezien hun verbindingen hetzelfde zijn. De drie belangrijkste verschillen tussen hen zijn dat de DRV8825 meer stroom kan leveren dan de A4988 zonder additionele koeling (1,5A vs 1A), het een hogere maximum voedingspanning heeft (45V vs 35V), en het een hogere microstepping resolutie biedt (32 vs 16 microstappen).

Natuurlijk hebben ze ook enkele andere kleine verschillen. Bijvoorbeeld, de stroomlimiet potentiometer heeft een andere locatie en de relatie tussen de stroomlimiet instelling en de referentiepinspanning is anders. De DRV8825 heeft geen logica voeding nodig, en die pinlocatie wordt gebruikt als FAULT output.

Echter, het is veilig om de FAULT pin direct aan 5V te verbinden, dus de DRV8825 kan gebruikt worden als directe vervanging in systemen ontworpen voor de A4988 driver.

Het is de moeite waard om te noteren, dat bij het vervangen van een A4988 driver met een DRV8825 het erg belangrijk is om ervoor te zorgen dat de oriëntatie van de driver correct is. Ik noemde al, hun potentiometers zijn op verschillende locaties, op de A4988 is het onder de chip, en op de DRV8825 is het boven de chip, en dat kan soms verwarring veroorzaken en de driver kan gemakkelijk op de verkeerde kant worden geplaatst.

Voor het instellen van de stroomlimiet, kunnen we de referentiespanning meten met een meetpunt op GND en de ander op de potentiometer zelf.

De formule voor het berekenen voor de DRV8825 stappendriver is als volgt:

Stroomlimiet = Vref x 2

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

Over het algemeen is de DRV8825 een betere stappendriver dan de A4988, aangezien het hogere stroom- en spanningwaarden biedt, en hogere microstepping resolutie wat resulteert in gladder en stilere werking van de stappenmotor.

TMC2208 Stappendriver

Sprekend over gladder en stilere werking, laten we kijken naar de TMC2208 stappendriver. De TMC2208 chip is gemaakt door Trinamic, een Duits bedrijf gespecialiseerd in motion control elektronica. De TMC2208 is een stille stappenmotordriver die ook als directe vervanging gebruikt kan worden in systemen ontworpen voor de A4988 of de DRV8825 drivers. Het wordt wijd gebruikt in desktop 3D-printers, laser graveerders, scanners, enz.

Wat deze driver onderscheidt van de twee anderen is de geïntegreerde interpolatie-eenheid die 256 subdivisies of microstappen biedt. Dit stelt perfecte sinusoïdale controle in die intern binnen de chip gegenereerd wordt. Dit betekent dat de driver 256 microstappen naar de stappenmotor zal outputten, ongeacht welke microstapresolutie we geselecteerd hebben via de twee MS pennen, 2, 4, 8 of 16 microstappen. Dit biedt gladder werking en vermindert de belasting van de microcontroller aanzienlijk.

Deze functie van de driver, in combinatie met de noiseless stroomcontrole StealthChop2 technologie, biedt die ultra-stille controle van de stappenmotoren. Hier is een vergelijking van de geluidsniveaus tussen de drie drivers.

Stappendriver geluidsniveaus: A4988 rond 65dB, DRV8825 rond 67dB en TMC2208 rond 41dB.

De TMC2208 stuurt de stappenmotoren volledig stil, wat echt indrukwekkend is.

De stroomwaarde van de TMC2208 is iets hoger dan de A4988 driver, of het is 1,2A met 2A piekstroom. Voor het instellen van de stroomlimiet van de driver, kunnen we weer dezelfde methode gebruiken als uitgelegd voor de andere drivers. We moeten de referentiespanning meten met een meetpunt op GND, en de ander op de hele rechter naast de Enable pin.

De formule voor het berekenen van de stroomlimiet is als volgt:

Stroomlimiet = Vref x 0,71

Hoewel het als directe vervanging gebruikt kan worden, heeft de TMC2208 driver een iets andere pinout vergeleken met de A4988 driver. Hier hebben we slechts twee pennen voor het selecteren van de microstapresolutie en voor het inschakelen van de driver moeten we de Enable pin met GND verbinden.

Wat codering betreft, is het hetzelfde als de andere twee drivers.

De TMC2208 driver heeft ook enkele andere, meer geavanceerde functies vergeleken met de twee andere drivers, zoals bijv. een eenvoudig te gebruiken UART interface wat het besturen van de driver met slechts een enkele lijn mogelijk maakt, in plaats van de twee Step en Dir pennen. Daarnaast biedt het meer tuning en controle opties.

Over het algemeen is de TMC2208 een betere driver dan de A4988 en de DRV8825, maar dat is normaal aangezien het met een hogere prijs komt. Hoewel, als u deze extra functies niet nodig heeft en de geluidsniveaus u niet bekommern, zijn de andere twee drivers gewoon een geweldige keuze.

Conclusie

Dus we hebben vrijwel alles behandeld wat we hoeven te weten over het besturen van stappenmotoren met Arduino. De NEMA17 en de drie drivers, de A4988, de DRV8825 en de TMC2208 zijn gewoon ongelooflijk veelzijdig en kunnen in zoveel toepassingen gebruikt worden waar positiecontrole nodig is. U kunt altijd meer leren door enkele van mijn Arduino-projecten te verkennen.

Als u geïnteresseerd bent in het leren hoe grotere stappenmotoren zoals NEMA23 of NEMA34 te besturen, zal ik daar ook een speciale tutorial voor hebben.

Ik hoop dat u van deze tutorial genoten hebt en iets nieuws geleerd hebt. Vergeet niet te abonneren en voel u vrij om vragen te stellen in de commentaarsectie hieronder.