Considerații teoretice [303895]

Considerații teoretice

Motorul pas cu pas

Motorul pas cu pas (MPP) este un convertor electromecanic care realizează transformarea unui tren de impulsuri digitale într-o mișcare proporțională a axului său. [anonimizat], de mărimi egale și care reprezintă pașii motorului. [anonimizat] “memorează” ultima poziție până la primirea unui alt tren de impulsuri.

[anonimizat], situate împrejurul acestui magnet. Pentru a obține o rezoluție satisfăcatoare (număr de pasi pentru o rotație completa suficient de mare), magnetul este multipolar. [anonimizat] 50 [anonimizat] o jumătate de dinte. Statorul este constituit din două bobine (model bipolar) montate sub forma de opt electromagneți.

Motorul pas cu pas mai prezintă proprietatea de a [anonimizat], [anonimizat]. [anonimizat], fără pierderi de pași pe tot domeniul de lucru.

Viteza unui motor pas cu pas poate fi reglată în limite largi prin modificarea frecvenței impulsurilor de intrare. Astfel, dacă pasul unghiular al motorului este 1,8° numărul de impulsuri necesare efectuării unei rotații complete este 200, iar pentru un semnal de intrare cu frecvența de 400 impulsuri pe secundă turația motorului este de 120 rotații pe minut.

Motorul pas cu pas poate lucra pentru frecvențe între 1.000 si 20.000 pași / secundă, având pași unghiulari cuprinși între 180° si 0,3°.

Aplicații ale motoarelor pas cu pas

Aplicațiile motorului pas cu pas sunt limitate la situațiile în care nu se cer puteri mari (puteri uzuale cuprinse între domeniile microwaților si kilowaților).

[anonimizat], precise, repetabile: plotere x-y, [anonimizat], [anonimizat] a [anonimizat] 2D, pentru mașinile de găurit etc.

Avantajele și dezavantajele folosirii motoarelor pas cu pas

Avantaje:

asigură univocitatea conversiei numărului de impulsuri în deplasare și ca urmare pot fi utilizate în circuit deschis ([anonimizat] a poziției unghiulare);

gamă largă a frecvențelor de comandă;

precizie de poziționare și rezoluție mare;

[anonimizat], schimbări ale direcției fără pierderi de pași;

memorează poziția;

sunt compatibile cu comanda numerică.

Dezavantaje:

[anonimizat], de valoare fixă pentru un motor dat;

viteză de rotație relativ scăzută;

putere dezvoltată la arbore de valoare redusă;

randament energetic scăzut;

Unul dintre cele mai importante avantaje a unui motor pas cu pas este capacitatea sa de a fi controlat cu precizie. [anonimizat]. Poziția este determinata pur și simplu prin impulsurile de intrare.

Mărimi caracteristice ale motoarelor pas cu pas

Unghiul de pas (Up) este unghiul cu care se deplasează rotorul la aplicarea unui impuls de comandă.

Frecvența maximă de start-stop în gol este frecvența maximă a impulsurilor de comandă, la care motorul poate porni, opri sau schimba direcția fără pierderi de pași.

Frecvența limită de pornire reprezintă frecvența maximă a impulsurilor de comandă, cu care MPP poate porni, fără pierderi de pași, pentru un cuplu rezistent și un moment de inerție date.

Cuplul limită de pornire reprezintă cuplul rezistent maxim la arbore, cu care MPP poate porni, la o frecvență si un moment de inerție date, fără pierderi de pași.Caracteristica limită de pornire definește domeniul cuplu-frecvență de comandă limită, în care MPP poate poni fără pierderi de pași.

Frecvența maximă de mers în gol este frecvența maximă a impulsurilor de comandă pe care o poate urmări motorul, fără pierderea sincronismului.

Frecvența limită de mers reprezintă frecvența maximă cu care poate funcționa un MPP, pentru un cuplu rezistent și un moment de inerție date.

Cuplul limită de mers reprezintă cuplul rezistent maxim, cu care poate fi încărcat un MPP pentru un moment de inerție dat și o frecvență de comandă cunoscută.

Caracteristica de mers definește domeniul cuplu limită de mers – frecvență limită de mers în care MPP poate funcționa în sincronism, fără pierderi de pasi.

Viteza unghiulară (w) poate fi calculată ca produs dintre unghiul de pas si frecvența de comandă.

Puterea la arbore este puterea utilă la arborele motorului, corespunzătoare punctului de funcționare de pe caracteristica de mers, punct caracterizat de cuplul limită de mers și de frecvența maximă de mers.

Cuplul de menținere este egal cu cuplul rezistent maxim, care poate fi aplicat la arborele motorului cu fazele nealimentate, fără ca să provoace rotirea continuă a rotorului.

Construcția și funcționarea motoarelor pas cu pas

Din punctul de vedere al construcției circuitului magnetic sunt:

MPP cu magnet permanent (de tip activ);

MPP cu reluctanță variabilă (de tip reactiv);

MPP hibride.

Motoare pas cu pas cu magnet permanent

Caracteristica MPP este construcția rotorului din magneți permanenți și polii dispuși radial. Statorul este alcătuit din două sau mai multe bobine.

Fiecare bobină, deși este o singură entitate, este împărțită în două. În figura 2.1. s-a notat bobina A cu A și A’, iar bobina B cu B și B’.

Figura 2.1. MPP cu magnet permanent.

Pentru a învârti rotorul se aplică tensiune pe fiecare bobină într-o anumită ordine și cu o anumită polaritate ca în figura 2.2.

Figura 2.2. Funționarea MPP cu magnet permanent.

Pentru îmbunătățirea rezoluției rotației rotorului sau pentru a scade unghiul pasului se crește numarul de perechi de poli ai rotorului (Figura 2.3a) sau se adaugă mai multe bobine pe stator (Figura 2.3b).

a)

b)

Figura 2.3. Metode de îmbunătățire a acurateței rotației motorului.

Motoare pas cu pas cu reluctanță variabilă

Are atât statorul cât si rotorul prevăzute cu dinți uniform distribuiți, pe dintii statorului fiind montate înfășurările de comandă. Rotorul este pasiv. Fiecare înfășurare este alimentată separat pentru a crea o polaritate pe polul corespunzător al statorului. Rotorul se învârte pentru a minimiza reluctanța fluxului magnetic.

Pentru a învârti rotorul într-o anumită direcție, secvența de alimentare a înfăsurărilor statorului este invers față de cea folosită la motorul cu magnet permanent. Unghiul pasului este jumătate față de cel al unui motor cu magnet permanent cu același numar de înfășurări.

În figura 2.4. este alimentată pe rând câte o fază statorică. Rotorul se va deplasa în pași întregi iar unghiul de pas va fi de 60°.

Figura 2.4. Funționarea MPP cu reluctanță variabilă.

Motoare pas cu pas hibrid

Acest tip de motor împrumută din caracteristicile motorului cu magnet permanent și ale motorului cu reluctanță variabilă. În cazul unui MPP hibrid, rotorul este constituit dintr-un magnet permanent, dispus longitudinal, la ale cărui extremități sunt fixate două coroane dințate din material feromagnetic. Dinții unei coroane constituie polii nord, iar dinții celeilalte coroane, polii sud. Dinții celor două coroane sunt decalați spațial, astfel încât, dacă un dinte al unei coroane se găsește în dreptul unui dinte statoric, dintele rotoric de pe cealaltă coroană să se afle la jumătatea unghiului dintre doi dinți statorici.

Figura 2.5. Privire laterală a motorului hibrid cu rotorul scos.

Motoare pas cu pas unipolare și bipolare

Motoare cu magnet permanent și cele hibride se împart în două subcategorii:

unipolare

bipolare

Aceste două subcategorii sunt determinate de modul în care capetele fiecărei faze sunt scoase în afara motorului.

În figura 2.6a. este prezentată o configurație bipolară. Fiecare capăt al unei înfășurări este scos în afară separat. Acest tip de înfășurare poate produce flux de curent în ambele direcții, în funție de ce tensiune și la ce capăt este aplicată. Acest lucru permite fiecărui pol al statorului sa fie magnetizat la nord sau sud.

Configurația unipolară (figura 2.6b) permite circularea curentului în jumătate de înfășurare odată. Fiecare înfășurare are un contact central care este scos în afara motorului, împreună cu firele de la fiecare înfășurare.

a) b)

Figura 2.6. Configurația bipolară și unipolară ale unui motor pas cu pas.

Placa de dezvoltare Nexys 2

Figura 2.7. Schema bloc Nexys 2

Prezentare generală

Circuitul Nexys2 se bazează pe o placa Xilinx spartan 3E FPGA. Placa Nexys2 poate fi utilizata cu un computer/laptop pentru a crea un design cu adevărat portabil.

Nexys2 aduce tehnologii noi care conduc la o platformă pe care oricine o poate folosi pentru a obține experiență in programarea digitală. Placa se poate interconecta cu nenumărate alte sisteme digitale, desene și modele industriale bazate pe FPGA folosind toate cele cinci expansiuni de conectori. Patru conectori periferici de 12 pini pot găzdui până la opt module Pmod pentru controlul motoarelor, circuite audio, precum și o gazdă de senzor. Toate semnalele de pe placa accesibile utilizatorului sunt protejate de scurtcircuit, si asigura un timp de viață de operare, în orice mediu.

Placa Nexys 2 este perfect compatibila cu toate versiunile Xilinx ISE. Acum, oricine poate construe sisteme digitale real. Placa Nexys 2 se poate alimenta de la un cablu USB, de la o baterie sau de la un alimentator de 5VDC-15VDC.

La intrare avem un regulator de tensiune ce scoate 3.3V si este suficient pentru toate elementele necesare de pe placa.

Figura 2.8. Schema bloc de alimentare a placii Nexys 2

Circuitul FPGA de pe placa Nexys2 trebuie să fie configurat (sau programat) de către utilizator, înainte de a putea îndeplini o anumită funcție. În timpul de configurare, un fisier este transferat în celulele de memorie în FPGA pentru a defini funcțiile logice și interconexiunile din circuit. Kitul gratuit ISE / WebPack CAD de la Xilinx poate fi folosit pentru a crea în VHDL, Verilog, sau pe bază de schematică niște fișiere sursă care să compună programul dorit. Placa FPGA poate fi programata în două moduri: direct de pe un PC, folosind portul USB, sau de la o platformă on-board Flash ROM (Flash ROM este, de asemenea, programabilă prin intermediul portului USB). Un switch de pe placa Nexys2 determină ce sursă (PC sau ROM) de FPGA va folosi pentru a încărca fisierele de configurare. Placa va încărca în mod automat o configurație de la Flash ROM în cazul în care Jumper-ul de configurare este setat pe "Master de serie". În cazul în care Jumper-ul este setat la "JTAG",placa FPGA va aștepta programare de la PC (prin intermediul cablului Figura 3.3. Circuitele programabile USB).

După ce placa FPGA este configurată, va rămâne așa până când se va reseta de la butonul de reset FPGA. Platforma Flash ROM va menține in memorie fișierele până când nu se reprogrameaza.

Placa Nexys2 include un Oscilator de 50MHz. Ceasul semnalelor de la oscilatoare se conecteaza la ceasul globale al pinilor de intrare de pe FPGA astfel încât să poată conduce impreuna la ceasul Sintetizor de blocuri disponibile în FPGA.

Ceasurile sintetizatoare (numite DLLs) furnizează ceasul de management de capabilități, care include dublarea sau quadruplarea frecvenței de intrare, împărțirea frecvenței de intrare, și definirea exactă fază întârziere precum și relațiile dintre diverse semnale de ceas.

Placa Nexys2 include mai multe dispozitive pentru introducere de date, dispozitive de ieșire, și porturile de date, care să permită mai multe desene și modele pentru a fi puse în aplicare fără a fi nevoie de orice alte componente.

Dispozitive intrare/iesire

Switch-uri și butoane

Patru butoane și opt comutatoare sunt prevăzute ca semnale de intrare. Butoanele si comutatoarele utilizează un rezistor în serie pentru protecția împotriva scurt-circuitelor.

Figura 2.9. Dispozitive I/O a placii Nexys 2

LED-uri

Opt LED-uri sunt furnizate pentru ieșirile circuitului. Al nouălea LED este utilizat pentru a indica dacă placa noastra este pornita, iar al zecelea LED indică starea de programare a placii. Placa Nexys2 conține un display cu șapte segmente cu patru cifre. Fiecare din cele patru cifre este compus din șapte segmente aranjate într-un model "cifra 8", cu un LED încorporat în fiecare segment. Segmentul de LED-uri pot fi iluminate individual, astfel încât oricare dintre cele 128 de modele pot fi afișate pe o cifră prin iluminarea anumitor segmente cu LED-uri lăsându-le pe celelalte stinse. Dintre aceste 128 posibile modele, cele zece corespunzătoare cifrelor zecimale, sunt cele mai utile.

Anozii celor șapte LED-uri care formează fiecare cifră sunt legați împreună într-un anod comun, dar catozii de la LED-uri rămân separati. Semnalele anozilor comuni pun la dispoziție patru cifre de afișare. Catozii de pe toate cele patru cifre sunt conectați în circuitul de șapte noduri etichetate de la CA la CG (deci, de exemplu, cei patru catozi "D" de la cele

patru cifre sunt grupati într-un singur nod de circuit numit "CD"). Semnalele acestor șapte catozi sunt disponibile ca intrări pentru display-ul de 4 cifre. Acest sistem de conexiune a semnalelor

creează o multiplexare a afișarii.

Figura 2.10. Display-ul cu sapte segmente a placii Nexys 2

Portul USB

Placa Nexys2 include un port USB de mare viteză, bazat pe un controller USB Cypress CY7C68013A. Portul USB poate fi folosit de Programul Xilinx, pentru a efectua transferuri de date de până la 38Mbytes/sec, si pentru a alimenta placa.

Tastatura

Placa Nexys2 poate folosi tastatura cu următoarele coduri:

Figura 2.11. Codurile tastelor

Mouse

Mouse-ul se deplasează în sistemul de coordonate xOy fapt care generează numere binare la placă; daca mouse-ul se deplasează spre dreapta generează un număr pozitiv, pe axa X, daca se deplasează la stânga generează un număr negativ. De asemenea, daca se deplasează în sus generează un număr pozitiv, pe axa Y, iar daca se deplasează în jos, generează un număr negativ.

Figura 2.12. Datele transmise de mouse

VGA Port

Placa Nexys2 folosește 10 semnale de la FPGA pentru a crea un port VGA cu 8 biți și de cele două semnale de sincronizare standard (HS – Horizontal Sync, și VS – Vertical Sync). Se pot afișa pe ecranul VGA atașat plăcii semnale de opt niveluri de culoare, doua de roșu și verde, și patru pe albastru (ochiul uman este mai puțin sensibil la nivelurile de albastru).

Utilizând acest circuit, se pot afișa 256 de culori diferite, câte una pentru fiecare model unic de 8 biți.

Figura 2.13. Pini VGA

Portul serial

Cele două dispozitive conectate la portul serial, sunt cunoscute sub numele de echipamente terminale de date (DTE) și echipamente de comunicații de date (DCE). DCE a fost inițial conceput pentru a fi un modem, dar acum multe dispozitive se conectează la calculator prin DCE. Dispozitivul DTE folosește un conector “tata” DB-9, și un dispozitiv periferic DCE utilizează un conector “mama” DB-9. Nexys 2 este configurat ca un dispozitiv DCE, presupunând ca el v-a fi conectat la un dispozitiv DCE, ca un calculator.

Memoria

Placa Nexys2 are dispozitive externe de memorie RAM și ROM. Memoria RAM este un Micron M45W8MW16 de 128Mbit. Memoria ROM este un Intel TE28F128J3D75-110 de 128Mbit.

Figura 2.14. Circuitele memoriilor

Conectori Periferici

Placa Nexys2 oferă patru conectori Pmod cu două rânduri de 6 pini, care împreună să poată găzdui până la 8 Pmod-uri. Cei patru conectori, au fiecare câte 8 pini ca semnale de date, doi pini GND, și doi pini ca alimentare.

Toți conectorii includ rezistențe de protecție la scurtcircuit și diode de protecție ESD. Fiecare conector poate furniza 3.3V si nu mai mult de 200mA. Pmod-urile pot fi atașate direct, sau prin utilizarea unui mic cablu. Pmod-urile disponibile includ convertoare A/D și D/A, driver pentru motoare, amplificatoare difuzoare, dispozitive de măsurare a distanței, etc.

Figura 2.15. Conectorul Pmod

Figura 2.16. Alocarea PIN-ilor

Limbajul VHDL

VHDL – descriere funcțională

VHDL reprezintă un limbaj utilizat pentru descrierea sistemelor numerice. Sistemele numerice pot fi calculatoare, componenete ale acestora sau alte structuri care manipulează informația numeric. În cele ce urmează accentul se va pune pe descrierea sisemelor numerice la nivelul transferurilor între registre (RTL – Register Transfer Language).

VHDL poate fi utilizat pentru descrierea sistemelor numerice din punct de vedere comportamental si structural:

descrierea comportamentală este legată de modul în care operează sistemul și utilizează construcții ale limbajelor traditionale de programare, de exemplu if sau atribuiri.

descrierea structurală exprimă modul în care entitățile/componentele logice ce alcătuiesc sistemul sunt interconectate în vedeea realizării comportamentului dorit.

Structura unui Program

Limbajul VHDL descrie un sistem numeric ca un set de module. Fiecare dintre aceste module are o interfață cu alte module, pentru a specifica maniera în care sunt interconectate. De regulă, un modul se plasează într-un fisier, fără ca aceasta sa fie o cerință obligatorie. Modulele opereaza concurent. Modulele reprezintă părți hardware, care pot fi de la simple porți până la sisteme complete ex., un microprocesor. Modulele pot fi specificate, fie comportamental, fie structural (sau o combinație a celor două).

Tipuri de Date

Tipuri de Date Fizice.

Întrucât scopul limbajului VHDL este acela de a modela hardware-ul numeric, tipurile primare de date vor fi destinate modelării registrelor (reg) și firelor (wire).

Variabilele reg stochează ultima valoare, care le-a fost atribuită procedural. Variabilele wire reprezintă conexiuni fizice între entități structurale cum ar fi porțile. Obiectele reg și wire, care reprezintă date, pot lua următoarele valori: 0 valoarea logică zero sau fals, 1 logic sau adevarat, x valoare logică necunoscută, z impedanța ridicată a unei porți “tristate”.

La începutul simulării variabilele reg sunt inițializate la valoarea x. Oricare variabilă wire neconectată la ceva are valoarea x.

Tipuri de Date Abstracte.

Într-un model de hardware, pe lângă variabilele, care modelează hardware-ul, se găsesc și alte tipuri de variabile. De exemplu, proiectantul dorește să folosească o variabilă integer, pentru a contoriza numărul de apariții ale unui eveniment. Pentru comoditatea proiectantului, VHDL HDL posedă mai multe tipuri de date cărora nu le corespund realizări hardware. Aceste tipuri de date includ integer, real și time.

Tipurile de date integer și real se comportă ca și in alte limbaje, de exemplu C. Trebuie subliniat faptul că variabila reg este fara semn, în timp ce variabila integer reprezintă un întreg de 32 de biți cu semn. Acest fapt are o mare importanță la scădere.

Operatori

Operatori Aritmetici binari.

Operatorii aritmetici binari operează cu doi operanzi.

Operanzii de tip reg si net sunt tratați ca fără semn. Operanzii de tip real și integer pot avea semn.

Operator Nume Comentarii

+ Adunare

– Scădere

Înmultire / Împărțire Împărțirea cu zero furnizează un x, necunoscut

% Modul

Operatori Relaționali.

Operatorii relaționali compară doi operanzi și întorc o valoare logică, adica TRUE (1) sau FALSE (0). Dacă un bit oarecare este necunoscut, relația este ambiguă și rezultatul este necunoscut.

> Mai mare decât

>= Mai mare decât sau egal

< Mai mic decât

<= Mai mic decât sau egal

== Egalitate logică

!= Inegalitate logică

Operatori Logici

Operatorii logici operează cu operanzi logici și întorc o valoare logică, adică TRUE (1) sau FALSE (0). Sunt utilizați în instrucțiunile if și while. A nu se confunda cu operatorii logici Booleeni la nivel de bit. De exemplu, ! este un NOT logic, iar ~ este NOT la nivel de bit. Primul neaga, ex., !(5 == 6) este TRUE. Al doilea complementează biții, de exemplu: ~{1,0,1,1} este

0100.

Operatori la nivel de bit.

Operatorii la nivel de bit acționează pe biții operandului sau operanzilor. De exemplu, rezultatul lui A & B este AND pentru biții corespunzători din A și B.

Constructiile de Control.

VHDL posedă o bogată colecție de instrucțiuni de control, care pot fi utilizate în secțiunile procedurale de cod, adicț în cadrul blocurilor inițial și always. Cele mai multe sunt familiare programatorului, care cunoaște limbajele tradiționale de programare, cum ar fi limbajul C.

Principala diferență constă în aceea că in locul parantezelor { }, din limbajul C, VHDL utilizeaza begin si end. În VHDL, parantezele { } sunt utilizate pentru concatenarea șirurilor de biți. Deoarece cei mai multi utilizatori sunt familiarizați cu limbajul C, următoarele subsecțiuni vor conține numai câte un exemplu din fiecare construcție.

Selecția – Instrucțiunile if și case.

Instrucțiunea if este usor de utilizat:

if (A==4)

begin

B = 2;

end

else

begin

B = 4;

end

case (<expression>)

<value1>: <instructiune>

<value2>: <instructiune>

default: <instructiune>

endcase

Repetiția – Instrucțiunile for, while și repeat.

Instrucțiunea for este foarte apropiată de instrucțiunea for din C, cu excepția ca operatorii ++ și – nu sunt prezenți in VHDL. De aceea, se va folosi i = i + 1.

for(i = 0; i < 10; i = i + 1)

begin

$display("i= %0d", i);

end

Instrucțiunea while operează in forma normală:

i = 0;

while(i < 10)

begin

$display("i= %0d", i);

i = i + 1;

end

Instructiunea repeat repetă următorul bloc de un număr fixat de 5 ori, in exemplul următor:

– de 5 ori:

repeat (5)

begin

$display("i= %0d", i);

i = i + 1;

end

Task-uri si Functii

Task-urile sunt asemănătoare procedurilor din alte limbaje de programare, de exemplu, task-urile pot avea zero sau mai multe argumente și nu întorc o valoare. Funcțiile se comportă ca subrutinele din alte limbaje de programare.

Excepție:

O funcție VHDL trebuie să se execute într-o unitate de timp simulat. Nu vor exista instrucțiuni de control al timpului: comanda întârzierii (#), comanda de eveniment (@) sau instrucțiunea wait. Un task poate conține instrucțiuni controlate de timp. Este important ca blocul always să conțină cel puțin o instrucțiune cu întârziere sau controlată de un eveniment, în caz contrar blocul se va repeta la timpul zero, blocând simularea.

Scopul unei funcții este acela de a returna o valoare, care urmează să fie folosită într-o expresie.

Realizarea proiectului

Motoare pas cu pas

Pentru acest proiect am folosit următorul motor:

Mitsumi M24SP-7

Caracteristici:

Cuplu ridicat de ieșire;

Unghi de pășire: 7,5°.

Specificații:

Figura 3.1. Specificații motor

Figura 3.2. Motorul Mitsumi M24SP-7

Figura 3.3. Simularea pașilor motorului

Modul de comandă pentru motoare pas cu pas

Pentru comandarea motoarelor pas cu pas, am realizat un modul care se conectează la placa Nexys 2. Acestea au fost realizate pe calculator, prin intermediul softului specializat ARES. Pentru controlul motorului pas cu pas, am realizat modulul ce urmează a fi conectat la placa de dezvoltare Nexys 2, cu un driver specializat pentru motoare pas cu pas L293. Modul de comanda este izolat galvanic și pentru protecția plăcii Nexys 2, am folosit două optocuploare.

Figura 3.4. Specificații L293

Figura 3.5. Schema electrică a modului de comandă al motorului pas cu pas

Figura 3.6. Diagrama bloc L293

Implementarea prin VHDL

Implementarea prin VHDL am realizat-o cu trei module.

Debouncer care are rolul de a rotii motorul atâta timp cat unul dintre cele doua butoane setate pentru a controla direcția motorului sunt apăsate. Ca intrări are un clock care este un semnal al ceasului intern al plăcii, semnal care contorizează permanent fiecare mișcare realizată de program; a doua intrare a modului este cea pentru butoane, de patru biți, iar ultimul semnal este de opt biți, pentru switch-uri. Ca ieșiri sunt setate două ieșiri, una pentru butoane de patru biți, iar al doilea semnal este de opt biți, pentru switch-uri.

Al doilea modul, main_module, are rolul de seta viteza prin intermediul celor opt switch-uri de pe placa de dezvoltare Nexys 2, și direcția motorului. Acest modul are trei intrări, un clock care este un semnal al ceasului intern al plăcii, semnal care contorizează permanent fiecare mișcare realizată de program, a doua intrare a modului este cea pentru butoane, de patru biți, iar ultimul semnal este de opt biți, pentru switch-uri.

Ultimul modul folosit se numește display_7seg care afișează, pe cele patru display-uri de pe placa de dezvoltare, viteza setată de utilizator prin intermediul switch-urilor. Are două intrări și patru ieșiri. Cele două intrări sunt: clk cu rolul pe care il știm de mai sus, și data_in care primește datele și le afișează pe display.

Figura 3.7. Intrările și ieșirile modulului debouncer

Figura 3.8. Intrările și ieșirile modulului main_module

Figura 3.9. Intrările și ieșirile modulului display_7seg

Figura 3.10. Legăturile dintre module

Prezentarea practică

În figura 4.1. este prezentată placa de dezvoltare Nexys 2, împreună cu funcțiile de selectare a vitezei, a direcției și verificarea pe display-ul plăcii dacă viteza corespunde cu numărul in binar introdus prin intermediul switch-ului.

Figura 4.1. Prezentarea plăcii de dezvoltare

Switch-uri pentru selectarea Butoane pentru selectarea Display-ul plăcii

vitezei motorului pas cu pas direcției

În figura următoare este prezentat modulul de comandă al motorului pas cu pas.

Figura 4.2. Modulul de comandă al motorului pas cu pas

Optocuploarele împreuna cu Bornele de alimentare Driverul L293 pentru

izolarea galvanică a modulului ale plăcii comanda motoarelor

Figura 4.3. Prezentarea standului final

Contribuții personale

În acest proiect am studiat motoarele pas cu pas, precum și aplicațiile unde se pot folosii aceste motoare, pe lânga aceasta, am studiat construcția si funcționarea lor, mărimile caracteristice, tipurile acestora, precum și modurile de comandă ale motoarelor pas cu pas, și modul în care se poate implementa controlul acestora, pe placa de dezvoltare Nexys 2 prin intermediul unui limbaj de dezvoltare, eu preferând limbajul VHDL.

Implementarea prin VHDL am realizat-o cu ajutorul a trei module, fiecare având un rol important in realizarea proiectului, cum ar fi, afișarea corespunzătoare vitezei pe cele patru afișaje digitale ale plăcii de dezvoltare Nexys 2, setarea vitezei motorului prin intermediul celor 8 switch-uri, precum și definirea butoanelor de pe placă, pentru alegerea direcției motorului.

Am realizat de asemenea și modulul de comandă al motoarelor pas cu pas care se conecteaza la placa de dezvoltare Nexys 2, cu ajutorul programului ARES, modulul fiind izolat galvanic, pentru a prevenii distrugerea echipamentelor, izolarea galvanică având rolul de a izola electric și fizică a secțiunilor din sistemele electrice. Acesta are și un driver specializat pentru controlul motoarelor pas cu pas, și anume L293. Conexiunea modului cu placa de dezvoltare, am realizat-o prin intermediul unui Pmod de pe placa, iar alimentarea modului se realizeaza extern, de la o sursa de curent, de 9V.

Bibliografie

Cadence Design Systems, Inc., Verilog-XL Reference Manual.

Open Verilog International (OVI), Verilog HDL Language Reference Manual (LRM)

Peter J. Ashenden – The Student’s Guide to VHDL. 1998

John F. Wakerly: Circuite digitale – principiile și practicile folosite in proiectare, Editura Teora, București 2002

Xilinx – The Programmable Logic Data Book, 1998

Gheorghe Toacșe, Dan Nicula – Digital Integrated Circuits, Hardware Description Language – VHDL

http://www.atelierulelectric.ro/articole/Actionarea%20motoarelor%20pas%20cu%20pas.pdf

http://en.wikipedia.org/wiki/Vhdl

http://www.digilentinc.com/

Anexa 1

Debouncer.vhd

library ieee;

use ieee.std_logic_1164.all;

entity debouncer is

port

(

clk_in : in std_logic;

btns_in : in std_logic_vector (3 downto 0);

sw_in : in std_logic_vector (7 downto 0);

btns_out : out std_logic_vector (3 downto 0);

sw_out : out std_logic_vector (7 downto 0)

);

end debouncer;

architecture behavioral of debouncer is

constant max_count : integer range 0 to 4095 := 4095;

signal btns_state : std_logic_vector (3 downto 0) := "0000";

signal sw_state : std_logic_vector (7 downto 0) := "00000000";

signal sw_out7, sw_out6, sw_out5, sw_out4, sw_out3, sw_out2, sw_out1, sw_out0, btn_out3, btn_out2, btn_out1, btn_out0 : std_logic := '0';

begin

btns_state <= btns_in;

sw_state <= sw_in;

btns_out <= btn_out3 & btn_out2 & btn_out1 & btn_out0;

sw_out <= sw_out7 & sw_out6 & sw_out5 & sw_out4 & sw_out3 & sw_out2 & sw_out1 & sw_out0;

debounce3 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (btns_state(3) = '1') then

if (count = max_count) then

btn_out3 <= '1';

else

btn_out3 <= '0';

count := count + 1;

end if;

else

count := 0;

btn_out3 <= '0';

end if;

end if;

end process debounce3;

debounce2 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (btns_state(2) = '1') then

if (count = max_count) then

btn_out2 <= '1';

else

btn_out2 <= '0';

count := count + 1;

end if;

else

count := 0;

btn_out2 <= '0';

end if;

end if;

end process debounce2;

debounce1 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (btns_state(1) = '1') then

if (count = max_count) then

btn_out1 <= '1';

else

btn_out1 <= '0';

count := count + 1;

end if;

else

count := 0;

btn_out1 <= '0';

end if;

end if;

end process debounce1;

debounce0 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (btns_state(0) = '1') then

if (count = max_count) then

btn_out0 <= '1';

else

btn_out0 <= '0';

count := count + 1;

end if;

else

count := 0;

btn_out0 <= '0';

end if;

end if;

end process debounce0;

debouncer7 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(7) = '1') then

if (count = max_count) then

sw_out7 <= '1';

else

sw_out7 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out7 <= '0';

end if;

end if;

end process debouncer7;

debouncer6 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(6) = '1') then

if (count = max_count) then

sw_out6 <= '1';

else

sw_out6 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out6 <= '0';

end if;

end if;

end process debouncer6;

debouncer5 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(5) = '1') then

if (count = max_count) then

sw_out5 <= '1';

else

sw_out5 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out5 <= '0';

end if;

end if;

end process debouncer5;

debouncer4 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(4) = '1') then

if (count = max_count) then

sw_out4 <= '1';

else

sw_out4 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out4 <= '0';

end if;

end if;

end process debouncer4;

debouncer3 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(3) = '1') then

if (count = max_count) then

sw_out3 <= '1';

else

sw_out3 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out3 <= '0';

end if;

end if;

end process debouncer3;

debouncer2 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(2) = '1') then

if (count = max_count) then

sw_out2 <= '1';

else

sw_out2 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out2 <= '0';

end if;

end if;

end process debouncer2;

debouncer1 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(1) = '1') then

if (count = max_count) then

sw_out1 <= '1';

else

sw_out1 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out1 <= '0';

end if;

end if;

end process debouncer1;

debouncer0 : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (sw_state(0) = '1') then

if (count = max_count) then

sw_out0 <= '1';

else

sw_out0 <= '0';

count := count + 1;

end if;

else

count := 0;

sw_out0 <= '0';

end if;

end if;

end process debouncer0;

end behavioral;

Main_module.vhd

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

entity main_module is

port

(

clk_in : in std_logic;

btns_in : in std_logic_vector (3 downto 0);

sw_in : in std_logic_vector (7 downto 0);

displ_out : out std_logic_vector (7 downto 0);

ctrl_out : out std_logic_vector (3 downto 0)

);

end main_module;

architecture behavioral of main_module is

signal speed : integer range 0 to 255 := 0;

signal clk2, clk3 : std_logic := '0';

signal ctrl : std_logic_vector (3 downto 0) := "0000";

signal dir : std_logic_vector (1 downto 0) := "00";

begin

ctrl_out <= ctrl;

displ_out <= sw_in;

speed <= to_integer(unsigned(sw_in));

clk_div1 : process (clk_in)

variable count : integer range 0 to 195312;

begin

if (rising_edge(clk_in)) then

if (count = 195312) then

clk2 <= '1';

count := 0;

else

clk2 <= '0';

count := count + 1;

end if;

end if;

end process clk_div1;

clk_div2 : process (clk2)

variable count : integer range 0 to 256;

begin

if (rising_edge(clk2)) then

if (count > 255 – speed) then

clk3 <= '1';

count := 0;

else

clk3 <= '0';

count := count + 1;

end if;

end if;

end process clk_div2;

fsm : process (clk_in)

begin

if (rising_edge(clk_in)) then

case (btns_in) is

when "1000" =>

dir <= "10";

when "0100" =>

dir <= "01";

when "0010" =>

when "0001" =>

when others =>

dir <= "00";

end case;

end if;

end process fsm;

sequencer : process (clk3)

begin

if (rising_edge(clk3)) then

case dir is

when "10" =>

case ctrl is

when "1000" => ctrl <= "0001";

when "0100" => ctrl <= "1000";

when "0010" => ctrl <= "0100";

when "0001" => ctrl <= "0010";

when others => ctrl <= "1000";

end case;

when "01" =>

case ctrl is

when "1000" => ctrl <= "0100";

when "0100" => ctrl <= "0010";

when "0010" => ctrl <= "0001";

when "0001" => ctrl <= "1000";

when others => ctrl <= "1000";

end case;

when "00" =>

ctrl <= "0000";

when others =>

end case;

end if;

end process sequencer;

end behavioral;

Display_7seg.vhd

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

entity display_7seg is

port

(

clk_in : in std_logic;

data_in : in std_logic_vector (7 downto 0);

an_out : out std_logic_vector (3 downto 0);

seg_out : out std_logic_vector (6 downto 0);

leds_out : out std_logic_vector (7 downto 0);

dp_out : out std_logic

);

end display_7seg;

architecture behavioral of display_7seg is

constant max_count : integer range 0 to 100000 := 100000;

signal clk2 : std_logic := '0';

signal anode : std_logic_vector (3 downto 0) := "1111";

signal segm : std_logic_vector (6 downto 0) := "1111111";

signal steps : integer range 0 to 3 := 0;

signal digit3, digit2, digit1, digit0 : integer range 0 to 15 := 0;

signal data1 : integer range 0 to 255 := 0;

begin

an_out <= anode;

seg_out <= segm;

dp_out <= '1';

leds_out <= data_in;

data1 <= to_integer(unsigned(data_in));

clk_div : process (clk_in) is

variable count : integer range 0 to max_count;

begin

if (rising_edge(clk_in)) then

if (count = max_count) then

clk2 <= '1';

count := 0;

else

clk2 <= '0';

count := count + 1;

end if;

end if;

end process clk_div;

converter : process (clk_in) is

variable count, data2 : integer range 0 to 255;

variable d3, d2, d1, d0 : integer range 0 to 15;

begin

if (rising_edge(clk_in)) then

if (data2 /= data1) then

data2 := data1;

count := 0;

d3 := 0;

d2 := 0;

d1 := 0;

d0 := 0;

else

if (count /= data2) then

count := count + 1;

d0 := d0 + 1;

if (d0 = 10) then

d1 := d1 + 1;

d0 := 0;

end if;

if (d1 = 10) then

d2 := d2 +1;

d1 := 0;

d0 := 0;

end if;

if (d2 = 10) then

d3 := d3 + 1;

d2 := 0;

d1 := 0;

d0 := 0;

end if;

if (d3 = 10) then

d3 := 10;

d2 := 10;

d1 := 10;

d0 := 10;

end if;

else

digit3 <= d3;

digit2 <= d2;

digit1 <= d1;

digit0 <= d0;

end if;

end if;

end if;

end process converter;

sequencer : process (clk2) is

variable digit_data : integer range 0 to 15 := 0;

begin

if (rising_edge(clk2)) then

case steps is

when 3 =>

anode <= "0111";

digit_data := digit3;

steps <= 2;

when 2 =>

anode <= "1011";

digit_data := digit2;

steps <= 1;

when 1 =>

anode <= "1101";

digit_data := digit1;

steps <= 0;

when 0 =>

anode <= "1110";

digit_data := digit0;

steps <= 3;

when others =>

anode <= "1111";

digit_data := 0;

steps <= 3;

end case;

case digit_data is

when 0 => segm <= "1000000";

when 1 => segm <= "1111001";

when 2 => segm <= "0100100";

when 3 => segm <= "0110000";

when 4 => segm <= "0011001";

when 5 => segm <= "0010010";

when 6 => segm <= "0000010";

when 7 => segm <= "1111000";

when 8 => segm <= "0000000";

when 9 => segm <= "0010000";

when others => segm <= "0111111";

end case;

end if;

end process sequencer;

end behavioral;

Anexa 2

Figura 8.1. Legăturile modului pentru comanda motorului pas cu pas