Care este diferența dintre tipurile de motoare pas cu pas Nema. Care este diferența dintre tipurile de motoare pas cu pas Nema Nema 17 pentru sistemele de control al scurgerilor

Acasă / Punct de control

Compania SteepLine se angajează în producția de mașini-unelte cu numerice managementul programului(CNC). În producția noastră folosim motoare pas cu pas Nema standard. Rotația discretă a arborelui cu un unghi fix de rotație vă permite să realizați cea mai precisă etapă de mișcare a căruciorului cu un instrument fix. Puterea motorului depinde de dimensiunile carcasei și ale flanșei de conectare.

Motoare pentru mașini CNC de la SteepLine

Mașinile de frezat (sau frezat și gravat) sunt utilizate pe scară largă în prelucrarea unei game largi de materiale: lemn, metale, piatră, plastic. În producția de mașini de frezat CNC, SteepLine folosește doar elemente de înaltă calitate, datorită cărora produsele se disting prin fiabilitate și durabilitate. În același timp, utilizarea dezvoltărilor moderne ne permite să creăm mașini capabile de cele mai fine și mai precise manipulări.

Pe site puteți alege și cumpăra motor pas cu pas pentru mașini CNC în format Nema 17, precum și orice alte accesorii pentru mașini-unelte. De asemenea, la cerere, putem asambla o mașină în funcție de nevoile individuale ale clientului. Plata se face prin transfer bancar, card sau numerar. Livrarea se efectuează companii de transport, dar auto-ridicare este, de asemenea, posibilă: Rusia, regiunea Rostov, Kamensk-Shakhtinsky, per. Câmpul 43.

Motor pas cu pas bipolar cu flanșă de 42 mm (standard NEMA17). Motoarele NEMA17 de putere redusă sunt potrivite pentru utilizarea cu sisteme de control numeric în care nu există nici o solicitare a piesei mobile - în scanere, arzătoare, imprimante 3D, instalatoare de componente etc.

(General specificatii tehnice) motor pas cu pas 42HS4813D5

  • Specificații
  • Model: _____________________________________________ 42HS4813D5
  • Flanșă: ____________________________________ 42 mm (standard NEMA 17)
  • Dimensiuni motor: ________________________________________ 42x42x48 mm
  • Dimensiuni ax: ____________________________________________ 28x5 mm
  • Greutate: ________________________________________________________ 0,35 kg
  • Curent: __________________________________________________________ 1,3 A
  • Rezistența la fază: _________________________________________ 1,5 Ohm
  • Inductanță de înfășurare: _______________________________________ 2,8 mH
  • Cuplu: ___________________________________________ 5,2 N / cm
  • Cuplul de susținere: __________________________________________ 2,8 N / cm
  • Inerția rotorului: _____________________________________________ 54 g / cm2
  • Temperaturi de funcționare: ________________________________ de la -20 ° С la + 85 ° С
  • Pitch: ___________________________________________________________ 1,8 °
  • Turn complet: ______________________________ efectuat în 200 de pași
  • Conector: ___________________ 4 PIN, lungimea firului 70 cm, conector detașabil

Plată

Puteți alege orice metodă de plată convenabilă pentru dvs.: transfer bancar, plată cu card de credit sau numerar la biroul companiei.

Livrare în toată Rusia

Livrarea mărfurilor se efectuează de către TC: SDEK, Business lines, PEK, Kit, ZhelDorEkspeditsiya.) - vezi livrarea

Livrarea și expedierea mărfurilor se efectuează de către companiile de transport, după plata comenzii. Costul de expediere va fi calculat de către manager după plata comenzii. Livrarea este plătită integral de către client la primirea bunurilor.

Ridica

Puteți ridica comanda în mod independent la depozitul de la adresa Rusia, regiunea Rostov, Kamensk-Shakhtinsky, per. Câmpul 43 (coordonate pentru navigator 48.292474, 40.275522). Folosiți un vehicul pentru comenzi mari.

Înainte de a începe un alt proiect Arduino, s-a decis utilizarea unui motor pas cu pas Nema 17.

De ce Nema 17? În primul rând, datorită raportului excelent preț / calitate.

Înainte de a conecta Nema 17, am avut ceva experiență cu stepby-ul 24byj48 (foaie tehnică). A fost controlat atât de Arduino, cât și de Raspberry pi, nu au existat probleme. Principala frumusețe a acestui motor este prețul său (aproximativ 3 dolari în China). Mai mult, pentru această sumă achiziționați un motor cu șofer inclus. De acord, puteți chiar arde acest lucru, fără a regreta cu adevărat ceea ce ați făcut.

Acum există o sarcină mai interesantă. Acționați motorul pas cu pas Nema 17 (fișă tehnică). Acest model de la producătorul original se vinde la un preț de aproximativ 40 USD. Copiile chinezești costă de o jumătate până la două ori mai ieftin - aproximativ 20-30 USD. Un model foarte reușit, care este adesea utilizat în imprimante 3D și proiecte CNC. Prima problemă care a apărut este cum să alegeți un driver pentru acest motor. Nu există suficient curent pe pinii Arduino pentru alimentare.

Alegerea unui driver pentru controlul Nema 17

Google a sugerat să puteți utiliza driverul A4988 al lui Poulou (foaie de date) pentru a revigora Nema 17.

În plus, există o variantă a utilizării microcircuitelor L293D. Dar A4988 este considerată o opțiune mai potrivită, așa că s-au stabilit pe ea pentru a evita potențialele probleme.

După cum sa menționat mai sus, motorul și șoferul au fost comandate din China. Link-uri de mai jos.

  • CUMPĂRĂ șofer cu motor pas cu pas A4988 cu livrare din China;

Conectarea Nema 17 prin A4988

Conexiunea a fost realizată pe baza acestui thread de pe forumul Arduino. Figura este prezentată mai jos.


De fapt, acest circuit este prezent pe aproape fiecare site de blog dedicat Arduino. Placa a fost alimentată de o sursă de alimentare de 12 volți. Dar motorul nu a pornit. Am verificat toate conexiunile, am verificat din nou și din nou ...

Prima problemă

Adaptorul nostru de 12 volți nu a furnizat un amperaj suficient. Ca urmare, adaptorul a fost înlocuit cu 8 baterii AA. Și motorul a început să se întoarcă! Ei bine, atunci am vrut să sar de la panoul de control la o conexiune directă. Și apoi a fost

A doua problemă

Când totul a fost cablat, motorul s-a oprit din nou în mișcare. De ce? Încă nu este clar. A trebuit să mă întorc la tablă. Și aici a apărut a doua problemă. A meritat să vă așezați mai întâi pe forumuri sau să citiți cu atenție foaia tehnică. Nu conectați / deconectați motorul atunci când controlerul este alimentat! Ca urmare, controlerul A4988 a ars în siguranță.

Această problemă a fost rezolvată prin achiziționarea unui nou driver de pe eBay. Acum, ținând cont de experiența tristă acumulată, Nema 17 a fost conectat la A4988 și lansat, dar ...

Motorul pas cu pas vibrează foarte mult

Motorul a vibrat puternic în timpul rotației rotorului. Nu se punea problema unei mișcări lină. Google vă va ajuta din nou. Primul gând este legătura greșită a înfășurărilor. Familiarizarea cu fișa tehnică a motorului pas cu pas și mai multe forumuri au convins că nu aceasta este problema. Dacă înfășurările sunt conectate incorect, motorul pur și simplu nu va funcționa. Soluția problemei stătea în schiță.

Programul Arduino

S-a dovedit că există o bibliotecă minunată pentru motoare pas cu pas scris de oamenii de la Adafruit. Folosim biblioteca AcclStepper, iar motorul pas cu pas începe să funcționeze lin, fără vibrații excesive.

Principalele concluzii

  1. Nu conectați / deconectați niciodată motorul în timp ce controlerul este alimentat.
  2. Atunci când alegeți o sursă de alimentare, acordați atenție nu numai tensiunii, ci și puterii adaptorului.
  3. Nu vă descurajați dacă controlerul A4988 eșuează. Doar comandați unul nou;)
  4. Utilizați biblioteca AcclStepper în locul codului Arduino. Un motor pas cu pas care utilizează această bibliotecă va funcționa fără vibrații inutile.

Schițe de comandă a motorului pas cu pas

Cod Arduino simplu pentru a testa un motor pas cu pas

// conexiune simplă A4988

// resetarea și pinii de repaus sunt conectați împreună

// conectați VDD la pinul de 3,3V sau 5V de pe Arduino

// conectați GND la Arduino GND (GND lângă VDD)

// conectați 1A și 1B la 1 bobină motor pas cu pas

// conectați 2A și 2B la bobina 2 a motorului pas cu pas

// conectați VMOT la sursa de alimentare (sursa de alimentare de 9V + termen)

// conectați GRD la sursa de alimentare (sursa de alimentare de 9V - termen)

int stp = 13; // conectați 13 pini la pas

int dir = 12; // conectați 12 pini la dir

pinMode (stp, OUTPUT);

pinMode (dir, OUTPUT);

în cazul în care o< 200) // вращение на 200 шагов в направлении 1

digitalWrite (stp, HIGH);

digitalWrite (stp, LOW);

else (digitalWrite (dir, HIGH);

digitalWrite (stp, HIGH);

digitalWrite (stp, LOW);

dacă (a> 400) // rotație 200 de pași în direcția 2

digitalWrite (dir, LOW);

Al doilea cod pentru Arduino pentru a asigura o rotație lină a motorului. Este utilizată biblioteca AccelStepper.

#include

AccelStepper Stepper1 (1,13,12); // folosește pinii 12 și 13 pentru dir și step, 1 - modul „driver extern” (A4988)

int dir = 1; // folosit pentru a schimba direcția

Stepper1.setMaxSpeed ​​(3000); // a stabilit viteza maxima rotația rotorului motorului (trepte / secundă)

Stepper1.setAcceleration (13000); // setează accelerația (pași / secundă ^ 2)

if (Stepper1.distanceToGo () == 0) (// verificați dacă motorul a funcționat mișcarea anterioară

Stepper1.move (1600 * dir); // setează următoarea mișcare la 1600 de pași (dacă dir este -1 se va deplasa -1600 -> direcție opusă)

dir = dir * (- 1); // valoare dir negativă, datorită căreia se realizează rotația în direcția opusă

întârziere (1000); // întârziere 1 secundă

Stepper1.run (); // porniți motorul pas cu pas. Această linie se repetă mereu pentru a menține motorul în funcțiune.

Lasă-ți comentariile, întrebările și distribuie-le experienta personala de mai jos. Idei și proiecte noi se nasc adesea în discuție!

Motoarele pas cu pas NEMA 17 sunt printre cele mai populare și utilizate pe scară largă, datorită gamei de cuplu, a dimensiunii compacte și a costului redus, sunt excelente pentru marea majoritate a proiectelor în care este necesar un sistem de mișcare precis.

Această dimensiune este o alegere excelentă atunci când construiți imprimante 3D. În modelele populare, de la trei piese la patru piese sunt utilizate pentru a organiza mișcarea de-a lungul a trei axe (4 piese pentru acele modele în care două motoare sunt utilizate pentru a se deplasa de-a lungul axei Y - de exemplu, RepRap Prusa i3 sau RepRap Prusa Mendel și altele asemenea) . De asemenea, veți avea nevoie de unul pentru un extruder care imprimă cu un filament de plastic sau de două pentru un extruder care poate imprima cu două filamente de plastic în același timp. De obicei, modele mai puternice sunt luate pe axe, iar modele mai slabe sunt luate pe extruder, deoarece un cuplu mic este suficient pentru extruder, iar greutatea mai mică a motoarelor utilizate permite reducerea sarcinii pe axele de deplasare.

Standardul NEMA definește dimensiunile flanșei motorului pas cu pas, NEMA 17 înseamnă că dimensiunea flanșei este de 1,7 ", în sistemul metric va corespunde 42,3 mm, iar distanța dintre dimensiunile scaunului va fi de 31 mm. Marea majoritate a motoarelor de această dimensiune au o grosime a axului de 5 mm. Puteți vedea desenul flanșei pentru această dimensiune în imaginea de mai sus.

De asemenea, aveți nevoie de un driver de motor pas cu pas pentru controlul mișcării. Un număr mare de șoferi din diferite categorii de prețuri sunt potrivite pentru această dimensiune standard. De exemplu, datorită costului redus, sunt utilizate adesea micro-drivere precum A4988, DVR8825 și altele asemenea. Este convenabil să le utilizați împreună cu Arduino - în acest caz, scutul excelent RAMPS 1.4 va fi util, ceea ce vă permite să conectați până la 5 axe. De asemenea, driverele cu o singură placă bazate pe microcircuite TB6560 și TB6600 de la Toshiba au devenit răspândite; pot fi atât monocanale, cât și multicanale. Aceste dispozitive pot fi deja clasificate drept drivere semi-profesionale, au intrări / ieșiri opto-cuplate, pot fi conectate direct la portul LPT al unui computer, implementează o logică de control mai avansată și puterea lor este suficientă pentru motoare mai mari. Puteți menționa și drivere modulare profesionale, acestea pot controla săritura pașilor, pot implementa mișcarea cu accelerație, capacitatea de a face față situațiilor critice (de exemplu, scurtcircuit), dar nu sunt deosebit de populare în segmentul amatorilor datorită prețului mai mare .

O clasă separată este controlerele specializate pentru imprimantele 3D, de exemplu, Printrboard, spre deosebire de driverele convenționale, pe lângă implementarea mișcărilor de-a lungul axelor, acestea pot controla și monitoriza temperatura duzei extruderului, temperatura mesei de încălzire și instrumentul alte capacități specifice zonei. Este preferată utilizarea unor astfel de controlere.

Aici puteți alege și cumpăra motoare pas cu pas NEMA 17 pentru construirea unei imprimante 3D la prețuri competitive.

Controlul unui motor pas cu pas folosind o placă Arduino.

În acest articol, continuăm să ne ocupăm de tema motoarelor pas cu pas. Ultima dată am conectat un mic motor 28BYJ-48 (5V) la placa Arduino NANO. Astăzi vom face la fel, dar cu un motor diferit - NEMA 17, seria 17HS4402 și un driver diferit - A4988.

Motorul pas cu pas NEMA 17 este un motor bipolar cu cuplu ridicat. Poate fi rotit cu un număr specificat de pași. Într-un singur pas, face o revoluție de 1,8 °, respectiv, face o revoluție completă de 360 ​​° în 200 de pași.
Un motor bipolar are două înfășurări, una în fiecare fază, care este inversată de conducător pentru a schimba direcția câmpului magnetic. În consecință, patru fire părăsesc motorul.

Acest motor este utilizat pe scară largă în mașini CNC, imprimante 3D, scanere etc.
Acesta va fi controlat folosind placa Arduino NANO.

Această placă este capabilă să furnizeze 5V în timp ce motorul funcționează la o tensiune mai mare. Am ales o sursă de alimentare de 12V. Deci, avem nevoie de un modul suplimentar - un driver capabil să conducă o tensiune mai mare prin impulsurile de putere redusă ale Arduino. Driverul A4988 este perfect pentru aceasta.

Șofer motor pas cu pas A4988.

Placa se bazează pe cipul Allegro A4988, un driver de motor bipolar pas cu pas. A4988 dispune de protecție reglabilă la curent, supraîncărcare și supraîncălzire, iar șoferul are, de asemenea, cinci opțiuni de microstep (până la 1/16 trepte). Funcționează la o tensiune de 8 - 35 V și poate furniza un curent de până la 1 A pe fază fără radiator și răcire suplimentară (este necesară o răcire suplimentară atunci când se aplică un curent de 2 A la fiecare înfășurare).

Specificații:

Model: A4988;
tensiune de alimentare: de la 8 la 35 V;
capacitatea de a seta pasul: de la 1 la 1/16 din pasul maxim;
tensiune logică: 3-5,5 V;
protecție la supraîncălzire;
curent maxim pe fază: 1 A fără radiator, 2 A cu radiator;
distanța dintre rândurile de picioare: 12 mm;
dimensiunea plăcii: 20 x 15 mm;
dimensiunile șoferului: 20 x 15 x 10 mm;
dimensiunile radiatorului: 9 x 5 x 9 mm;
greutate cu radiator: 3 g;
fără radiator: 2 g.

Pentru a lucra cu driverul, este necesară o sursă de alimentare cu nivel logic (3 - 5,5 V) la pinii VDD și GND, precum și puterea motorului (8 - 35 V) pinilor VMOT și GND. Placa este foarte vulnerabilă la supratensiuni, mai ales dacă firele de alimentare sunt mai lungi de câțiva centimetri. Dacă aceste supratensiuni depășesc valoarea maximă admisibilă (35 V pentru A4988), atunci placa se poate arde. O modalitate de a proteja placa de astfel de supratensiuni este instalarea unui condensator electrolitic mare (cel puțin 47 μF) între pinul sursei de alimentare (VMOT) și masă aproape de placă.
Conectarea sau deconectarea motorului pas cu pas în timp ce șoferul este pornit poate deteriora motorul!
Motorul selectat face 200 de pași pe o rotație completă de 360 ​​°, ceea ce corespunde cu 1,8 ° pe pas. Un driver de microstepping precum A4988 vă permite să măriți rezoluția controlând pașii intermediari. De exemplu, controlul unui motor într-un mod cu un sfert de pas va oferi unui motor de 200 de pași pe rotație 800 microstep atunci când se utilizează diferite niveluri de curent.
Rezoluția (dimensiunea pasului) este setată de combinația de comutatoare de pe intrări (MS1, MS2 și MS3).

MS1 MS2 MS3 Rezoluție microstep
Mic de statura Mic de statura Mic de statura Pas complet
Înalt Mic de statura Mic de statura 1/2 pas
Mic de statura Înalt Mic de statura 1/4 pas
Înalt Înalt Mic de statura 1/8 pas
Înalt Înalt Înalt 1/16 pas

Fiecare impuls la intrarea STEP corespunde unui microstep al motorului, a cărui direcție de rotație depinde de semnalul de la pinul DIRECȚIE. Pinii STEP și DIRECTION nu sunt legați de nicio tensiune internă specială, deci nu ar trebui lăsați să plutească atunci când construiți aplicații. Dacă doriți doar să rotiți motorul într-o singură direcție, puteți conecta DIR direct la VCC sau GND. Cipul are trei intrări diferite pentru controlul stării de alimentare: RESET, SLEEP și ENABLE. Pinul RESET plutește, dacă nu este necesar să-l utilizați, atunci ar trebui să îl conectați la pinul SLEEP adiacent de pe placă de circuit imprimat să o solicite nivel inaltși include tabloul.

Schema de conexiune.

Am folosit următoarea sursă de alimentare (12V).

Pentru confortul conectării la placa Arduino UNO, am folosit o piesă realizată manual. Carcasa din plastic este imprimată pe o imprimantă 3D, contactele sunt lipite de ea.

De asemenea, am folosit un astfel de set de fire, unele dintre ele au un contact la un capăt, un știft pe celălalt, iar altele au contacte pe ambele părți.

Conectăm totul conform schemei.

Apoi deschidem mediul de dezvoltare pentru programele Arduino și scriem un program care rotește motorul mai întâi într-o direcție cu 360 °, apoi în cealaltă.

/ * Program pentru rotație motor pas cu pas NEMA 17, seria 17HS4402 + driver A4988. Mai întâi, motorul face o revoluție completă într-o direcție, apoi în cealaltă * /

const int pinStep = 5;


const int pinDir = 4;


const int move_delay = 3;

// pași pentru un viraj complet


configurare nulă ()
{

pinMode (pinStep, OUTPUT);
pinMode (pinDir, OUTPUT);


digitalWrite (pinDir, LOW);
}


bucla nulă ()
{

digitalWrite (pinDir, HIGH);

pentru (int i = 0; i< steps_rotate_360; i++)
{
digitalWrite (pinStep, HIGH);
întârziere (move_delay);
digitalWrite (pinStep, LOW);
întârziere (move_delay);
}

întârziere (move_delay * 10);


digitalWrite (pinDir, LOW);

pentru (int i = 0; i< steps_rotate_360; i++)
{
digitalWrite (pinStep, HIGH);
întârziere (move_delay);
digitalWrite (pinStep, LOW);
întârziere (move_delay);
}

întârziere (move_delay * 10);
}

Dacă vrem ca motorul să se rotească pur și simplu într-o direcție sau alta, atunci putem conecta știftul driverului DIRECTION la sol (rotație în sensul acelor de ceasornic) sau sursa de alimentare (în sens invers acelor de ceasornic) și umple Arduino cu un program atât de simplu:

/ * Program pentru rotirea motorului pas cu pas NEMA 17, seria 17HS4402 + driver A4988. Programul pune motorul în mișcare.
În mod implicit, rotația este în sensul acelor de ceasornic, deoarece pinul DIRECȚIE al șoferului este conectat la masă. Dacă îl conectați la o sursă de alimentare de 5V, atunci
motorul se rotește în sens invers acelor de ceasornic * /
/ * o constantă întreagă care deține numărul PIN-ului digital Arduino care dă semnalul Step șoferului. Fiecare impuls de la acest contact este o mișcare a motorului cu un pas * /

const int pinStep = 5;

// întârziere între pașii motorului în ms
const int move_delay = 3;

/ * Funcție în care sunt inițializate toate variabilele de program * /
configurare nulă ()
{
/ * setați modul de ieșire la contactul Step, adică dau tensiune * /
pinMode (pinStep, OUTPUT);
// setați modul inițial
digitalWrite (pinStep, LOW);
}

/ * Buclă funcțională în care este setat comportamentul programului * /
bucla nulă ()
{
/ * după o întârziere specificată, motorul se deplasează cu un pas * /
digitalWrite (pinStep, HIGH);
întârziere (move_delay);
digitalWrite (pinStep, LOW);
întârziere (move_delay);
}

Toate acestea le-am considerat modul pas cu pas al motorului, adică 200 de trepte pe rotație completă. Dar, așa cum s-a descris deja, motorul poate funcționa în moduri de pas 1/2, 1/4, 1/8, 1/16, în funcție de ce combinație de semnale se aplică contactelor driverului MS1, MS2, MS3.
Să exersăm cu asta, conectăm acești trei pini la placa Arduino, conform diagramei, și completăm codul programului.

Codul unui program care demonstrează toate cele cinci moduri de funcționare a motorului, rotind motorul într-o direcție și cealaltă timp de 200 de pași în fiecare dintre aceste moduri.

/ * Program pentru rotirea motorului pas cu pas NEMA 17, seria 17HS4402 + driver A4988. Programul alternează între modurile de pas: pas complet, 1/2, 1/4, 1/8, 1/16 pas, cu fiecare dintre ele motorul rotește 200 de pași într-o direcție, apoi în cealaltă * /
/ * o constantă întreagă care deține numărul PIN-ului digital Arduino care dă semnalul Step șoferului. Fiecare impuls de la acest contact este o mișcare a motorului cu un pas * /

const int pinStep = 5;

/ * o constantă întreagă care deține numărul pinului digital Arduino care trimite semnalul de direcție către șofer. Prezența unui impuls - motorul se rotește într-o direcție, absența - în cealaltă * /
const int pinDir = 4;

// întârziere între pașii motorului în ms
const int move_delay = 3;

// pași pentru un viraj complet
const int steps_rotate_360 = 200;


bool StepMode = (
{ 0, 0, 0},
{ 1, 0, 0},
{ 0, 1, 0},
{ 1, 1, 0},
{ 1, 1, 1} };

// dimensiunea matricei StepMode
const int StepModeSize = 5;

/ * Funcție în care sunt inițializate toate variabilele de program * /
configurare nulă ()
{
/ * setați modul de ieșire la contactele pas și direcție, adică dau tensiune * /
pinMode (pinStep, OUTPUT);
pinMode (pinDir, OUTPUT);

pentru (int i = 0; i< StepModePinsCount; i++)
{

}

// setați modul inițial
digitalWrite (pinStep, HIGH);
digitalWrite (pinDir, LOW);
}

/ * Buclă funcțională în care este setat comportamentul programului * /
bucla nulă ()
{
pentru (int i = 0; i< StepModeSize; i++)
{
pentru (int j = 0; j< StepModePinsCount; j++)
{
digitalWrite (StepModePins [j], StepMode [i] [j] == 1? HIGH: LOW);
}

// rotiți motorul într-un sens, apoi în celălalt
MakeRoundRotation ();
}
}

/ * o funcție în care motorul face 200 de pași într-o direcție, apoi 200 de pași în direcția opusă * /
void MakeRoundRotation ()
{
// setați direcția de rotație
digitalWrite (pinDir, HIGH);

pentru (int i = 0; i< steps_rotate_360; i++)
{
digitalWrite (pinStep, HIGH);
întârziere (move_delay);
digitalWrite (pinStep, LOW);
întârziere (move_delay);
}

întârziere (move_delay * 10);

// setați direcția de rotație la opus
digitalWrite (pinDir, LOW);

pentru (int i = 0; i< steps_rotate_360; i++)
{
digitalWrite (pinStep, HIGH);
întârziere (move_delay);
digitalWrite (pinStep, LOW);
întârziere (move_delay);
}

întârziere (move_delay * 10);
}

Ei bine, iar ultimul lucru care ne-a rămas de adăugat la schemă este controlul extern. Ca și în articolul precedent, vom adăuga un buton care setează direcția de rotație și un rezistor variabil (potențiometru) care va modifica viteza de rotație. Vom avea doar 5 viteze, în funcție de numărul de moduri de pas posibile pentru motor.

Completăm schema cu elemente noi.

Pentru a conecta butoanele, vom folosi astfel de fire.

Codul programului.

/ * Program pentru rotirea motorului pas cu pas NEMA 17, seria 17HS4402 + driver A4988. Circuitul include un buton cu 3 poziții (I, II, middle - off) și un potențiometru. Butonul ajustează direcția de rotație a motorului, iar datele din potențiometru arată care dintre cele cinci moduri ale pasului motorului trebuie activat (pas complet, 1/2, 1/4, 1/8, 1/16 pas) * /
/ * o constantă întreagă care deține numărul PIN-ului digital Arduino care dă semnalul Step șoferului. Fiecare impuls de la acest contact este o mișcare a motorului cu un pas * /

const int pinStep = 5;

/ * o constantă întreagă care deține numărul pinului digital Arduino care trimite semnalul de direcție către șofer. Prezența unui impuls - motorul se rotește într-o direcție, absența - în cealaltă * /
const int pinDir = 4;

/ * Contacte din două poziții ale butonului - digital * /
const int ButtonOn1 = 9;
const int ButtonOn2 = 10;

/ * Valoarea potențiometrului de înregistrare a contactelor - analogic * /
const int PotenciomData = 1;

// întârziere între pașii motorului în ms
const int move_delay = 3;

/ * constantă întreagă care arată întârzierea dintre citirea stării butonului și a potențiometrului * /
const int CheckButtonDelay = 15;

/ * O variabilă întreagă care arată cât timp a trecut și este timpul să citiți starea butonului * /
int CurrentButtonDelay = 0;

/ * pini pe driver care setează modul pasului motorului - MS1, MS2, MS3 * /
int StepModePins = (8, 7, 6);

// dimensiunea matricei StepModePins
const int StepModePinsCount = 3;

// starea butonului on / off
int ButtonState = 0;

// direcția de rotație conform butonului I - 1, II - 0
int ButtonDirection = 0;

/ * O matrice care stochează stările contactelor MS1, MS2, MS3 ale driverului, la care moduri diferite rotație: pas complet, 1/2, 1/4, 1/8, 1/16 pas * /
bool StepMode = (
{ 0, 0, 0},
{ 1, 0, 0},
{ 0, 1, 0},
{ 1, 1, 0},
{ 1, 1, 1} };

// dimensiunea matricei StepMode
const int StepModeSize = 5;

// indexul curent al matricei StepMode
int StepModeIndex = 0;

/ * Funcție în care sunt inițializate toate variabilele de program * /
configurare nulă ()
{
/ * setați modul de ieșire la contactele pas și direcție, adică dau tensiune * /
pinMode (pinStep, OUTPUT);
pinMode (pinDir, OUTPUT);

pentru (int i = 0; i< StepModePinsCount; i++)
{
pinMode (StepModePins [i], OUTPUT);
}

/ * contactele de la buton și potențiometru sunt setate la modul de intrare * /
pinMode (ButtonOn1, INPUT);
pinMode (ButtonOn2, INPUT);
pinMode (PotenciomData, INPUT);

// setați modul inițial
digitalWrite (pinStep, LOW);
digitalWrite (pinDir, LOW);
}

/ * Buclă funcțională în care este setat comportamentul programului * /
bucla nulă ()
{
if (CurrentButtonDelay> = CheckButtonDelay)
{
CheckButtonState ();
CurrentButtonDelay = 0;
}

if (ButtonState == 1)
{
MakeMotorStep ();
}

întârziere (move_delay);
CurrentButtonDelay + = move_delay;
}

// funcție în care se efectuează un pas al motorului
void MakeMotorStep ()
{
digitalWrite (pinStep, HIGH);
digitalWrite (pinStep, LOW);
}

/ * funcție în care este verificată starea curentă a butonului și a potențiometrului * /
void CheckButtonState ()
{
int CurrentButtonState = 0, CurrentButtonDirection = 0, CurrentStepModeIndex = 0;

bool readbuttonparam = digitalRead (ButtonOn1);

if (readbuttonparam)
{
CurrentButtonState = 1;
CurrentButtonDirection = 1;
}

readbuttonparam = digitalRead (ButtonOn2);

if (readbuttonparam)
{
CurrentButtonState = 1;
CurrentButtonDirection = 0;
}

if (ButtonState! = CurrentButtonState)
{
ButtonState = CurrentButtonState;
}

if (ButtonDirection! = CurrentButtonDirection)
{
ButtonDirection = CurrentButtonDirection;
digitalWrite (pinDir, ButtonDirection);
}

CurrentStepModeIndex = map (analogRead (PotenciomData), 0, 1023, 0, StepModeSize-1);
if (StepModeIndex! = CurrentStepModeIndex)
{
StepModeIndex = CurrentStepModeIndex;
pentru (int i = 0; i< StepModePinsCount; i++)
{
digitalWrite (StepModePins [i], StepMode [i]);
}
}
}

© 2021 bugulma-lada.ru - Portal pentru proprietarii de mașini